Itérateurs en python

Un itérateur est un outil précieux pour Python. C'est un objet habitué à itérer tous les éléments d'une collection. Iterator donne accès aux éléments d'un conteneur, mais il ne fait pas l'itération en soi. Il fonctionne comme un curseur de la base de données et est utilisé pour lire la liste d'enregistrements un par un. Par exemple, un 'pour'boucle qui itère les valeurs d'un conteneur fonctionne comme un itérateur. Python a de nombreux itérateurs intégrés pour des objets itérables, tels que des listes, des tuples, des dictionnaires, etc. Sans ces itérateurs, 'itertools'Les fonctions peuvent être utilisées pour retourner d'autres itérateurs en python. Cet article montre comment utiliser la boucle comme itérateur, itérateur personnalisé, itérateur infini et contrôler l'itérateur infini dans Python 3. Certaines utilisations du 'itertools«Les fonctions sont également expliquées dans la dernière partie de ce tutoriel.

Méthodes d'itérateur

Chaque objet itérateur contient les deux méthodes suivantes.

• _ _iter_ _ ()

Cette méthode est utilisée pour initialiser l'objet itérable. L'objet retourné a la méthode '_ _suivant_ _()'Dans Python 3.

• _ _suivant_ _()

Cette méthode renvoie la valeur suivante de l'objet itérable. La relation entre l'itérateur et l'objet itérable est indiquée dans le diagramme suivant.

Itération avec des boucles

Il a été mentionné plus tôt que le 'pour'Loop appelle le'suivant()'Méthode implicitement lors de l'itération d'un objet itérable. Lorsqu'une boucle est utilisée pour itération d'un objet itérable, le 'pour'Loop appelle le'suivant()'Méthode implicitement et le'alors que'Loop appelle le'suivant()' ou '__suivant__()'Méthode explicitement pour lire la valeur suivante de l'objet itérable. Les deux types de boucle continuent d'appeler cette méthode jusqu'à ce que le 'Étape'Le signal est généré.

Exemple 1: iterating itérable d'objets avec «pour» boucle

Le script suivant montre l'utilisation de 'pour«Boucles pour itération de cinq objets itérables différents. La première 'pour'Loop est utilisé pour itérer la valeur de la chaîne et imprimer chaque caractère de la chaîne dans chaque itération. La deuxième 'pour'Loop est utilisé pour itérer le contenu d'un fichier texte existant et imprimer chaque ligne du fichier dans chaque itération. Le troisième 'pour'Loop est utilisé pour itérer les valeurs d'un tuple. Le quatrième 'pour'Loop est utilisé pour itérer les valeurs contenues dans une liste. Le cinquième 'pour'Loop est utilisé pour itérer les valeurs contenues dans un dictionnaire.

# Itération d'une chaîne en utilisant pour la boucle
print ("String itération Using for Loop")
str = "python"
Pour Val dans Str:
Imprimer (Val)
# Itération d'un fichier existant à l'aide de la boucle
print ("\ n \ nreading un fichier ligne par ligne à l'aide de la boucle")
Pour la ligne en ouverte ("Test.SMS"):
imprimer (ligne, end = "")
# # Itération d'un tuple en utilisant pour la boucle
print ("\ n \ ntuple itération Using for Loop")
tup = ("livre", "papier", "crayon", "stylo")
pour val dans tup:
Imprimer (Val)
# Itération d'une liste à l'aide de la boucle
print ("\ n \ nlist itération Using for Loop")
listData = ["Designer", "Analyst", "Programmer", "Administrator"]
pour Val dans ListData:
Imprimer (Val)
# Itération d'un dictionnaire en utilisant pour la boucle
Imprimer ("\ n \ ndictionary itération Using for Loop")
dictval = 'meher': 95, 'Sakib': 97, 'akhi': 70, 'fiaz': 78
pour l'index dans dictval:
Imprimer ("% s obtenu% d marques"% (index, dictval [index]))

Sortir

La sortie suivante montre que les caractères de la valeur de chaîne; les lignes du test.SMS déposer; Et les éléments des tuples, de la liste et du dictionnaire sont imprimés après l'exécution du script.

Exemple 2: itérer des listes avec «While» boucle

Le script suivant montre l'utilisation d'un 'alors que«Boucle pour itération d'une liste de données. Ici le 'iter ()'La méthode est utilisée pour initialiser l'objet itérable, et le'suivant()'La méthode est utilisée pour lire la valeur suivante de l'objet itérable. Étape Le signal est utilisé pour se terminer de l'infini 'alors que' Boucle Quand il n'y a plus d'élément de la liste pour la lecture.

# Définir une liste
listData = ['Google.com ',' bing.com ',' yahoo.com ',' baidu.com ',' DuckDuckgo.com ']
# Initialiser l'objet itérable
init_iter_object = iter (listData)
Imprimer ("iterating lister les données à l'aide de la boucle: \ n")
# Déclarer et infini en boucle
Bien que vrai:
essayer:
# Next () La méthode est utilisée pour itérer la valeur suivante
Value = Suivant (init_iter_object)
Imprimer (valeur)
sauf une étape:
# Se terminer de la boucle après avoir itérant toutes les valeurs
casser

Sortir

La sortie suivante montre que chaque valeur de la liste a été imprimée dans chaque ligne en utilisant le 'suivant()'Méthode après avoir exécuté le script.

Exemple 3: itération d'un tuple avec '__Next __ ()' Méthode et 'While' Loop

Dans le script suivant, les deuxsuivant()' et '__suivant__()«Des méthodes sont utilisées pour itération des valeurs d'un tuple. Le 'iter ()'La méthode est utilisée pour créer l'objet itérable, nommé'init_iter.' Ici le 'suivant()'La méthode est appelée deux fois pour imprimer les deux premières valeurs du tuple. Ensuite, un infinialors que'Loop est utilisé pour itérer les valeurs restantes du tuple et du'Étape'Le signal est utilisé pour se terminer de la boucle, comme dans l'exemple précédent.

# définir un tuple
Animal_tuple = («oiseau», «lion», «singe», «serpent», «éléphant»)
Print ("Les valeurs du tuple sont: \ n")
# Initialiser un objet Iterator en utilisant Iter ()
init_iter = iter (animal_tuple)
# itérer et imprimer la valeur en utilisant la méthode suivante ()
imprimer (suivant (init_iter))
imprimer (suivant (init_iter))
# Définir une boucle infinie
Bien que vrai:
essayer:
# itérer et imprimer la valeur en utilisant __Next __ () Méthode
imprimer (init_iter.__suivant__())
sauf une étape:
# Se terminer de la boucle après avoir itérant toutes les valeurs
casser

Sortir

La sortie suivante montre qu'après l'exécution du script, les deux premières valeurs, 'Oiseau' et 'Lion,'sont imprimés avec le'suivant()«Méthode, tandis que les trois autres valeurs»Singe,"Serpent,' et 'Éléphant,'sont imprimés avec le'__suivant__()' méthode.

Itérer avec un itérateur personnalisé

Cette section montre comment différents types d'itérateurs personnalisés peuvent être mis en œuvre en créant des classes. Les deux '__iter __ ()' et le '__suivant__()"Les méthodes seront implémentées dans une classe, et les"alors que'Loop sera utilisé pour itérer les valeurs de l'objet itérable. La prochaine partie de cet article montrera également comment créer un itérateur personnalisé infini et contrôler l'itération.

Exemple 4: Utilisation d'un simple itérateur personnalisé

Le script suivant vous permet de calculer la valeur de Xⁿ En utilisant un itérateur personnalisé sans utiliser de fonction intégrée de Python. La classe nommée 'x_to_the_power_n'est déclaré dans le script. Le '__init __ ()'La méthode de la classe inialisera les valeurs de X et n qui sera utilisé au moment de la création d'objets. Le '__iter __ ()'La méthode initialisera la variable de classe, qui stockera le'résultat'Variable du calcul dans chaque itération. Les valeurs de X et n sera pris comme entrée de l'utilisateur. Un objet de la classe 'Nombres'est créé avec X et n. Ensuite, un objet itérable nommé 'iter_obj'est créé pour appeler le'__suivant__()'Méthode pour n-1 fois en utilisant le 'alors que'boucle pour calculer la valeur de Xⁿ. Dans chaque itération, la valeur de X sera multiplié par la valeur précédente du 'résultat'Variable. Après avoir terminé le 'alors que'Loop, le'__suivant__()'La méthode sera à nouveau appelée pour imprimer la valeur de Xⁿ.

"Créez une classe pour calculer le
x à la puissance n en utilisant iterator
"
classe x_to_the_power_n:
# Initialiser la valeur de x et n
def __init __ (self, x = 0, n = 0):
soi.x = x
soi.n = n
# Initialiser l'itérable
def __iter __ (soi):
soi.résultat = 1
se retourner
# Calculez la valeur dans chaque itération
def __Next __ (self):
Si vous-même.n> = 0:
soi.Résultat * = soi.X
soi.n - = 1
se retourner.résultat
# Prenez les valeurs de x et n
x = int (entrée ("Entrez la valeur de x:"))
n = int (entrée ("Entrez la valeur de n:"))
# Créez un objet de la classe
nombres = x_to_the_power_n (x, n)
# Créez un itérable
iter_obj = iter (nombres)
essayer:
i = 0
alors que je < n-1):
# Récupérer la valeur suivante en utilisant la méthode suivante ()
Suivant (iter_obj)
i + = 1
imprimer ("\ n% d à la puissance% d est% d"% (x, n, iter_obj.__suivant__()))
sauf une étape:
# Se terminer du script si aucune valeur n'existe
print (suivant (iter_obj))

Sortir

La sortie suivante montre que 2 est considéré comme la valeur de X et 4 est considéré comme la valeur de n. Ainsi, le script a calculé la valeur de 2⁴ être 16.

Exemple 5: Utilisation d'un itérateur personnalisé infini

Le script suivant imprimera en continu les nombres divisibles par 5 avec un retard d'une seconde jusqu'à ce que l'utilisateur appuie Ctrl + c pour générer le 'Clavier'Signal. L'infini 'alors que'Loop est utilisé ici pour créer un itérateur personnalisé infini. Le 'temps'Le module est importé au début du script pour utiliser le'dormir()'Méthode pour retarder chaque sortie pendant une seconde. Le numéro 5 est initialisé au 'nobs'variable comme premier numéro divisible dans le script, et le numéro suivant est généré en ajoutant 5 avec la valeur précédente du'nobs'Variable.

# Module d'heure d'importation
heure d'importation
"
Créer une classe pour générer les nombres
qui sont divisibles par 5 continuellement
"
classe numéro_divisible_by_five:
# Initialiser la valeur de num
def __iter __ (soi):
soi.num = 5
se retourner
# Calculez le numéro suivant qui est divisible par 5
def __Next __ (self):
next_num = self.nobs
temps.sommeil (1)
soi.num + = 5
retourner next_num
# Créez un objet de la classe
Object = numéro_divisible_by_five ()
# Créer un objet itérable
iterObject = iter (objet)
# Définir une boucle infinie
Bien que vrai:
essayer:
# Optez pour la prochaine itération
Imprimer (iterObject.__suivant__())
sauf le clavier Interrupteur:
imprimer ("Ctrl + C est pressé.")
# Terminez de la boucle lorsque Ctrl + C est pressé
casser

Sortir

La sortie suivante montre que le nombre a commencé à imprimer à partir de 5 et a imprimé en continu les numéros suivants les uns après l'autre avec une durée d'une seconde. Lorsque l'utilisateur a appuyé Ctrl + c Après avoir imprimé le numéro 60, le message 'Ctrl + C est pressé.'a été imprimé, avant de terminer le script.

Exemple 6: Contrôle d'un itérateur infini personnalisé

Le script suivant montre comment arrêter l'itérateur infini personnalisé après avoir terminé un nombre spécifié d'itérations. Le '__iter __ ()«La méthode de la classe initialisera les valeurs du»n' et 'résultat'Variables de classe. Le script calculera les carrés des nombres, à partir de 1, qui sont stockés dans la variable n, et imprimer la valeur carrée de n Jusqu'à la valeur de n est supérieur à 5. Une boucle infinie while est déclarée ici pour appeler le '__suivant__()'Méthode pour imprimer la valeur carrée de n. Lorsque la valeur de n tronçon 6, le 'Étape'Le signal va générer pour terminer la boucle.

# Module d'heure d'importation
heure d'importation
"
Créer une classe pour calculer
Le carré du nombre commence de 1 jusqu'à
La valeur du nombre est inférieure à 6
"
Classe Calcule_Power:
# Initialiser la valeur de num
def __iter __ (soi):
soi.n = 1
soi.résultat = 0
se retourner
# Calculez le numéro suivant qui est divisible par 5
def __Next __ (self):
# Vérifier que la valeur de n est inférieure ou égale à 5 ou non
Si vous-même.n <= 5:
soi.résultat = soi.n ** 2
temps.sommeil (0.5)
soi.n + = 1
se retourner.résultat
autre:
augmenter la pertinence
# Créez un objet de la classe
Objet = calcul_power ()
# Créer un objet itérable
iterObject = iter (objet)
# Définir une boucle infinie
Bien que vrai:
essayer:
# Optez pour la prochaine itération et imprimez la valeur carrée
Print ("Le carré de% D est% d"% (iterObject.n, iterobject.__suivant__()))
sauf une étape:
Imprimer ("\ Nterminé à partir de la boucle.")
# Se terminer de la boucle
casser

Sortir

La sortie suivante montre que l'itérateur personnalisé infini a été terminé lorsque la valeur de n est devenue supérieure à 5. Le script a calculé et imprimé les valeurs carrées des valeurs de nombre de 1 à 5.

Itérer avec itertools

Python a un module intégré nommé 'itertools'Cela peut être utilisé pour créer un itérateur pour itératiser les données à l'aide d'une boucle. La section suivante de cet article montre comment utiliser trois fonctions dans ce module.

itertools.compter()

Le 'itertools.suite"La fonction peut être utilisée avec le"carte()«Méthode pour générer des données séquentielles et avec le»zipper()'Méthode pour ajouter des séquences en utilisant le paramètre Count de cette méthode. La syntaxe de cette fonction est donnée ci-dessous.

Syntaxe

itertools.compter (start = 0, étape = 1)

Ici, le premier paramètre, 'commencer,'est utilisé pour définir la valeur de départ de la séquence, et 0 est la valeur par défaut de ce paramètre. Le deuxième paramètre, 'marcher,'est utilisé pour définir la différence entre les nombres consécutifs, et 1 est la valeur par défaut de ce paramètre.

Exemple 7: Utilisation de la fonction de count () d'Itertools

Le script suivant calculera la somme de 0 pour n nombres, où la valeur de n sera tiré de l'utilisateur. Le 'compter()'La fonction est importée de'itertools'Au début du script. Le 'my_iterator'L'objet est initialisé avec le'compter()'fonction, avec un'commencer«valeur de 0 et A»marcher'Valeur de 1. Ensuite, le 'sum_result'La variable est initialisée par la première valeur de l'objet itérable. La valeur de départ est initialisée à la variable je et le numéro de départ est stocké comme le caractère dans la variable, des nombres qui seront utilisés pour combiner d'autres nombres dans chaque itération. Les valeurs des nombres séquentielles seront ajoutées dans chaque itération lorsque le 'suivant()'La méthode est appelée. Lorsque la valeur de je devient plus grand que n, Le script se terminera en affichant le résultat de la somme.

"Le script suivant calculera
la somme de 0 au nombre qui sera prise en entrée.
"
# Compte d'importation
à partir du nombre d'importations Itertools
# Crée un objet itérable de comte ()
my_iterator = count (start = 0, étape = 1)
# Lisez la première valeur de l'itérateur
sum_result = next (my_iterator)
# Prenez une entrée de nombre pour terminer l'infini pendant la boucle
n = int (entrée ("Entrez la valeur limite:"))
# Initialiser la valeur de I et des nombres
i = sum_result
nombres = f 'i'
# Déclarer la boucle infinie
Bien que vrai:
# Ajouter le numéro dans chaque itération
sum_result + = i
i = suivant (my_iterator)
# Terminer la boucle si la valeur de i est plus que n
if (i> n):
casser
# Ajouter la valeur du nombre en tant que chaîne avec le symbole '+'
nombres + = "+" + f 'i'
# Imprime la valeur finale
imprimer ("% s =% d"% (nombres, sum_result)))

Sortir

La sortie suivante montre que le nombre dix est pris comme l'entrée utilisée pour terminer la boucle après l'exécution du script. Dans cette sortie, le script a calculé la somme de 0 à 10 et a imprimé la sortie, 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55.

Itertools.cycle()

Cette fonction ne contient qu'un seul argument, qui peut être n'importe quel objet. Le but de cette fonction est de répéter les valeurs de l'objet après avoir terminé l'itération de toutes les valeurs. Ici, cordes, tuples, listes, etc. peut être utilisé comme objet. Les rendements d'objet itérable de cette fonction sont utilisés pour itérer chaque valeur de l'objet qui sera utilisé comme argument en utilisant le 'suivant()' méthode. Le nombre de fois que les valeurs de l'objet itérable irateront seront basées sur le nombre d'itérations de la boucle. La syntaxe de cette fonction est donnée ci-dessous.

Syntaxe

itertools.cycle (objet)

Exemple 8: Utilisation de la fonction de cycle () d'Itertools

Le 'aléatoire' et 'itertools«Les modules sont importés au début du script pour générer un nombre aléatoire et pour utiliser le»cycle()'fonction du'itertools'Module pour répéter les données. Une liste de trois nombres aléatoires est utilisée comme argument du 'cycle()' fonction. L'objet itérable nommé 'num_list'est initialisé par la valeur de retour de cette fonction. Le 'compter'La variable est initialisée à 0, Et lorsque la valeur de cette variable devient 6, le 'alors que'Loop se terminera. Alors le 'alors que'Loop iratera six fois, et chaque valeur de la liste ne répétera qu'une seule fois.

# Importer un module aléatoire
Importer au hasard
# Importer le module Itertools
Importer Itertools
# Générez un objet itérable basé sur la liste de trois nombres aléatoires
num_list = itertools.cycle ([aléatoire.Randint (1,5), aléatoire.Randint (10,50), aléatoire.Randin
(100 500)])
# Initialiser le compteur
comte = 0
# Itérer la boucle pendant 6 fois
tandis que (compter != 6):
print ('Le nombre aléatoire actuel est:' + f 'next (num_list)')
compter + = 1

Sortir

La sortie suivante montre que trois nombres aléatoires, 3, 17, et 185, ont été générés en tant qu'éléments de liste. La boucle est itérée six fois, et ces trois valeurs sont répétées pour les prochaines itérations.

Itertools.répéter()

La fonction «répéter ()» fonctionne comme un itérateur infini et peut prendre deux arguments. Lorsque le deuxième argument est omis, la fonction «répéter ()» fonctionne comme un itérateur infini et répète la valeur un nombre infini de fois. Cette fonction n'occupe pas de mémoire pour chaque répétition. Il crée simplement la variable une fois dans la mémoire et répète la même variable un nombre infini de fois où un seul argument est défini pour cette fonction. La syntaxe de cette fonction est donnée ci-dessous.

Syntaxe

itertools.répéter (valeur, limite)

Le premier argument est utilisé pour prendre la valeur qui se répétera. Le deuxième argument est facultatif et est utilisé pour définir la limite des répétitions.

Exemple 9: Utilisation de la fonction Repeat () du module Itertools

Le 'itertools'Le module est importé au début du script pour utiliser le'répéter()' fonction. Une valeur de chaîne sera tirée de l'utilisateur à répéter, et une valeur de nombre sera prise de l'utilisateur pour définir la limite de répétition. La valeur de retour du 'répéter()'La fonction sera ensuite convertie en liste avec le'liste()'Méthode et stocké dans le'listData'Variable. Les valeurs du 'listData'sera imprimé avec le'pour' boucle.

# Importer le module Itertools
Importer Itertools
# Prenez la valeur d'entrée qui se répétera
String = Input ("Entrez une chaîne:")
# Prenez la valeur du nombre pour répéter
répéter = int (entrée ("Entrez le numéro à répéter:"))
# Utilisation de la répétition () pour ajouter à plusieurs reprises la chaîne dans une liste
listData = list (itertools.répéter (chaîne, répéter))
# Inilize I
i = 1
print ("Les valeurs de la liste sont: \ n")
# Itérer la liste en utilisant pour Loop
pour Val dans ListData:
Imprimer ("Élément de liste% d =% s"% (i, val))
i + = 1

Sortir

La sortie suivante montre que 'Python'est considéré comme la valeur de la chaîne, et 3 est considéré comme le nombre utilisé pour répéter la valeur de la chaîne après l'exécution du script. La sortie montre que la chaîne 'Python'est répété trois fois.

Conclusion

Le concept d'itérateur et les utilisations de différents types d'itérateurs à Python sont essayés d'expliquer avec les exemples très simples de cet article. Les utilisateurs de Python peuvent utiliser un itérateur intégré ou créer leur itérateur personnalisé en fonction de l'exigence. Cet article aidera les utilisateurs de Python à connaître les méthodes utilisées dans l'itérateur et comment ces méthodes fonctionnent avec une boucle pour lire n'importe quel objet itérable. Certaines utilisations de itertools Le module de Python est également expliqué dans cet article pour connaître plus de détails sur l'itérateur dans Python.