Itertools.produit

Itertools est un package qui offre différentes méthodologies dans Python. Les attributs d'itération sur les attributs sont plus faciles en utilisant ces méthodes. La fonction Product () du package Itertools produit le produit cartésien des listes ou ensembles fournis. Le paramètre de répétition, qui est une partie supplémentaire de la fonction, fournit la combinaison cartésienne de la valeur avec elle-même sur les itérations indiquées dans l'argument répété. Voyons les méthodes d'utilisation de la fonction Product () du module Itertools ().

Exemple 1:
Dans cet exemple, nous créons deux listes, puis trouvons le produit cartésien de ces listes définies.

à partir du produit d'importation Itertools
List = [21, 44, 63, 74, 15]
imprimer ("Liste réelle est:", liste)
Print ("Le produit cartésien de cette liste:", liste (produit (liste, répétition = 3)))
List_1 = [51, 12, 23]
List_2 = ['xa', 'yb', 'zc']
print ("Le produit cartésien des deux listes:", liste (produit (list_1, list_2))))

Nous commençons le code en intégrant la méthode produit () associée au framework Itertools. Ensuite, nous indiquons quelques éléments sous la forme d'une liste. Ces valeurs sont stockées dans une variable «liste». Maintenant, nous utilisons la fonction print () pour afficher la liste réelle. La fonction product () se compose de deux arguments qui incluent la liste et l'attribut «répéter». La valeur de cet attribut devrait être 3 ici pour obtenir le produit cartésien de la liste définie avec lui-même. Ce produit de la liste est affiché à l'écran en utilisant la fonction print ().

De plus, nous créons deux nouvelles listes. La première liste contient trois valeurs numériques et la deuxième liste contient les ensembles alphabétiques. Maintenant, nous appelons la méthode Product (). Nous passons les deux listes comme les arguments de la fonction. Ce faisant, nous trouvons le produit cartésien entre ces deux listes. La méthode print () est utilisée pour afficher le produit cartésien.

Exemple n ° 2:
Ici, nous utilisons la méthode cartesian_product () pour acquérir le produit cartésien de deux tableaux.

à partir du produit d'importation Itertools
def cartesian_product (a_1, a_2):
Liste de retour (produit (a_1, a_2))
Si __name__ == "__main__":
a_1 = [101, 938, 854]
a_2 = [370, 691, 287]
imprimer (cartesian_product (a_1, a_2)))

Nous incorporons la bibliothèque de produits à partir du package Itertools. Ensuite, nous définissons la fonction cartesian_product (). Dans cette fonction, nous passons deux tableaux comme paramètre de la fonction. Cette méthode renvoie les valeurs des deux tableaux en prenant le produit des valeurs. Nous utilisons également la méthode produit () dans l'instruction RETOUR.

Maintenant, il est temps d'appeler la fonction du pilote. À l'intérieur du corps de la fonction principale, nous créons deux tableaux et définissons quelques valeurs aléatoires dans ces tableaux. Nous appelons la fonction cartesian_product () pour acquérir le produit cartésien des tableaux mentionnés. Nous utilisons la fonction print () pour représenter leur produit.

Exemple n ° 3:
Dans cette illustration, pour simplicité et efficacité, la fonction product () est utilisée à la place de la boucle pour.

heure d'importation
Importer Itertools
l_1 = [4,8,2]
l_2 = [1,7,3]
l_3 = [5,6,2]
s_1 = heure.temps()
iter_list = itertools.produit (l_1, l_2, l_3)
a_1 = heure.temps()
Imprimer ("Résultat des Itertools.Produit () Fonction: ")
print (list (iter_list))
list_new = []
S_2 = temps.temps()
pour l dans l_1:
pour m en l_2:
pour n en l_3:
list_new.Ajouter ((l, m, n))
a_2 = temps.temps()
Imprimer ("Résultat en utilisant pour Loop:")
imprimer (list_new)
Imprimer (F "Temps pris pour obtenir les itertools.Product (): a_1-s_1 ")
print (f "Temps pris pour l'utilisation de 'For' Loop: a_2-s_2")

Pour commencer le programme, nous introduisons deux modules requis. Le cadre «Time» est intégré pour déterminer la vitesse des exécutions et le module «Itertools» est importé pour traiter la fonctionnalité de produit () et pour une boucle. Ensuite, nous déclarons trois variables qui incluent «l_1», «l_2» et «l_3». Ces variables sont utilisées pour stocker différentes valeurs. Toutes ces listes contiennent trois chiffres.

Pour acquérir la rapidité de la mise en œuvre, nous appelons la méthode Time (). Le temps calculé est stocké dans une variable «S_1». Cette méthode est tirée du fichier d'en-tête temporel. À l'étape suivante, nous utilisons la méthode Product () du package Itertools. Nous passons les trois listes définies comme les arguments de la fonction du produit. Nous appelons la méthode print () pour afficher le produit des listes en utilisant la méthode Product ().

Parallèlement à cela, nous utilisons la méthode print () pour imprimer la liste. Maintenant, initialisons une nouvelle variable appelée «list_new». Cette liste est définie comme vide. Nous utilisons la fonction Time () pour déterminer l'efficacité de la mise en œuvre du système. La variable «S_2» contient le temps déterminé. Le fichier d'en-tête temporel est l'endroit où cette méthodologie est adoptée. Il exclut le L_3 pour les valeurs de n 2 & 3 dans la première exécution de la boucle «pour» avec l = 4, m = 8 et n = 2. Le processus est répété tout en spécifiant le M = 7. Il arrête le L_3 pour les valeurs des paramètres K 2 & 3 dans la deuxième série de la boucle «pour» ayant l = 1, m = 7 et n = 3. Le processus est ensuite répété lors de la définition du m = 7. Pour l = 5, ceci est exécuté en conséquence.

Nous utilisons la méthode annexée () et passons les trois itérations comme paramètres car nous ajoutons le résultat de ces itérations. Nous appelons l'approche Time () pour évaluer à quelle vitesse ces itérations se produisent. La variable «A_2» détient le temps estimé. Maintenant, nous avons utilisé la fonction print () pour présenter le produit des listes en appliquant une boucle «pour».

De plus, nous montrons la liste à l'aide de la fonction print (). Pour afficher les heures calculées pour les deux procédures, nous invoquons finalement la méthode print (). La fonction () Product () du produit () pour les temps relatives et les temps de fin des itérations de la boucle est montré par les variables S_1, S_2, et A_1 et A_2, respectivement. Les temps d'exécution de la fonction FOR LOOP et Product () sont présentés comme A_1 - S_1 et A_2 - S_2, en conséquence.

Conclusion

Dans cet article, nous avons expliqué comment utiliser la méthode Product () du module Itertools à Python. Les utilisateurs peuvent traverser le produit cartésien d'un ensemble d'itérables avec cette méthode. Le code est simplifié et efficace en utilisant la méthode produit (). Dans le premier exemple de ce guide, nous avons créé une liste et obtenu le produit cartésien de la liste elle-même. Dans un autre cas, nous avons déclaré deux tableaux et obtenu le produit cartésien de ces tableaux. Nous avons utilisé la fonction Product () au lieu de la boucle «pour».