Itérateurs en Python

Un itérateur est un outil précieux pour Python. C'est un objet utilisé pour 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 tout seul. Il fonctionne comme un curseur de base de données et est utilisé pour lire la liste des 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 les objets itérables, tels que les listes, les tuples, les dictionnaires, etc. Sans ces itérateurs, 'itertools' les fonctions peuvent être utilisées pour renvoyer d'autres itérateurs en Python. Cet article montre comment utiliser la boucle en tant qu'itérateur, itérateur personnalisé, itérateur infini et itérateur infini de contrôle dans Python 3. Quelques 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_ _()' en 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 illustrée dans le diagramme suivant.

Itérer avec des boucles

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

Exemple 1 : Itération d'objets itérables avec la boucle 'for'

Le script suivant montre l'utilisation de 'pour' boucles pour itérer cinq objets itérables différents. La première 'pour' boucle est utilisée pour itérer la valeur de la chaîne et imprimer chaque caractère de la chaîne à 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 à chaque itération. Le troisième 'pour' boucle est utilisée pour itérer les valeurs d'un tuple. Le quatrième 'pour' boucle est utilisée pour itérer les valeurs contenues dans une liste. Le cinquième 'pour' boucle permet d'itérer les valeurs contenues dans un dictionnaire.

# Itération d'une chaîne à l'aide de la boucle for
print("Itération de chaîne utilisant la boucle for")
str = "Python"
pour val dans str :
imprimer(val)
# Itération d'un fichier existant à l'aide de la boucle for
print("\n\nLecture d'un fichier ligne par ligne en utilisant la boucle for")
pour la ligne dans open("test.SMS"):
print(ligne, fin="")
# # Itération d'un tuple en utilisant la boucle for
print("\n\nItération de tuple utilisant la boucle for")
tup = ("Livre", "Papier", "Crayon", "Stylo")
pour val en tup :
imprimer(val)
# Itérer une liste en utilisant la boucle for
print("\n\nListe Itération utilisant la boucle for")
listdata = ["Concepteur", "Analyste", "Programmeur","Administrateur"]
pour val dans listdata :
imprimer(val)
# Itération d'un dictionnaire en utilisant la boucle for
print("\n\nItération du dictionnaire utilisant la boucle for")
dictval = 'Meher': 95, 'Sakib': 97, 'Akhi': 70, 'Fiaz': 78
pour index dans dictval :
print("%s ont atteint %d points" %(index, dictval[index]))

Production

La sortie suivante montre que les caractères de la valeur de chaîne ; les lignes de la 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 la boucle 'while'

Le script suivant montre l'utilisation d'un 'tandis que' boucle pour itérer une liste de données. Ici le 'iter()La méthode ' est utilisée pour initialiser l'objet itérable, et la méthode 'suivant()La méthode ' est utilisée pour lire la valeur suivante de l'objet itérable. Arrêter l'itération signal est utilisé pour terminer de l'infini 'tandis que' boucle quand aucun élément de la liste ne reste à lire.

# 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)
print("Itération des données de la liste à l'aide de la boucle while :\n")
# Déclaration et boucle while infinie
tant que vrai :
essayer:
# la méthode next() est utilisée pour itérer la valeur suivante
valeur = suivant(init_iter_object)
imprimer (valeur)
sauf StopIteration :
# Terminer la boucle après avoir itéré toutes les valeurs
Pause

Production

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 la méthode '__next__()' et la boucle 'while'

Dans le script suivant, à la fois 'suivant()' et '__suivant__()' les méthodes sont utilisées pour itérer les 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()' méthode est appelée deux fois pour imprimer les deux premières valeurs du tuple. Ensuite, un infini 'tandis queLa boucle ' est utilisée pour itérer les valeurs restantes du tuple et le 'Arrêter l'itération' est utilisé pour terminer 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 itérateur en utilisant iter()
init_iter = iter(animal_tuple)
# itérer et imprimer la valeur en utilisant la méthode next()
imprimer(suivant(init_iter))
imprimer(suivant(init_iter))
# Définir une boucle while infinie
tant que vrai :
essayer:
# itérer et imprimer la valeur à l'aide de la méthode __next__()
print(init_iter.__suivant__())
sauf StopIteration :
# Terminer la boucle après avoir itéré toutes les valeurs
Pause

Production

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'é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 implémentés en créant des classes. Tant le '__iter__()' et le '__suivant__()Les méthodes ' seront implémentées dans une classe, et les 'tandis 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 itérateur personnalisé simple

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

"Créez une classe pour calculer le
x à la puissance n en utilisant l'itérateur
"
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__(self):
soi.résultat = 1
retourner soi-même
# Calculer la valeur à chaque itération
def __next__(self):
si soi.n >= 0 :
soi.résultat *= soi.X
soi.n -= 1
retourner soi-même.résultat
# Prendre les valeurs de x et n
x = int(input("Entrez la valeur de x: "))
n = int(input("Entrez la valeur de n: "))
# Créer un objet de la classe
nombres = x_to_the_power_n(x,n)
# Créer un itérable
iter_obj = iter(nombres)
essayer:
je = 0
alors que je < n-1):
# Récupérer la valeur suivante en utilisant la méthode next()
suivant(iter_obj)
je+=1
print("\n%d à la puissance %d est %d" %(x,n,iter_obj.__suivant__()))
sauf StopIteration :
# Terminer à partir du script si aucune valeur n'existe
imprimer(suivant(iter_obj))

Production

La sortie suivante montre que 2 est considérée comme la valeur de X et 4 est considérée comme la valeur de m. 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 délai d'une seconde jusqu'à ce que l'utilisateur appuie Ctrl + c pour générer le 'ClavierInterruption'signaler. L'infini 'tandis 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 d'une seconde. Le chiffre 5 est initialisé au 'nombre' variable comme premier nombre divisible dans le script, et le nombre suivant est généré en ajoutant 5 avec la valeur précédente du 'nombre'variable.

# Importer le module de temps
heure d'importation
"
Créer une classe pour générer les nombres
qui sont divisibles par 5 continûment
"
classe Number_Divisible_by_five :
# Initialise la valeur de num
def __iter__(self):
soi.nombre = 5
retourner soi-même
# Calcule le prochain nombre qui est divisible par 5
def __next__(self):
next_num = soi.nombre
temps.dormir(1)
soi.nombre += 5
retourner num_suivant
# Créer un objet de la classe
Objet = Number_Divisible_by_five()
# Créer un objet itérable
iterObjet = iter(Objet)
# Définir une boucle infinie
tant que vrai :
essayer:
# Passer à la prochaine itération
print(iterObject.__suivant__())
sauf KeyboardInterrupt :
print("Ctrl+C est pressé.")
# Terminer la boucle lorsque Ctrl+C est enfoncé
Pause

Production

La sortie suivante montre que le numéro a commencé à s'imprimer à partir de 5 et a imprimé en continu les numéros suivants l'un après l'autre avec une durée d'une seconde. Lorsque l'utilisateur a appuyé sur Ctrl + c après avoir imprimé le numéro 60, le message 'Ctrl+C est enfoncé.' 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 'm' et 'résultat' variables de classe. Le script calculera les carrés des nombres, à partir de 1, qui sont stockés dans la variable m, et imprimer la valeur carrée de m jusqu'à ce que la valeur de m est supérieur à 5. Une boucle while infinie est déclarée ici pour appeler le '__suivant__()' méthode pour imprimer la valeur carrée de m. Lorsque la valeur de m atteint 6, les 'Arrêter l'itération' le signal sera généré pour terminer la boucle.

# Importer le module de temps
heure d'importation
"
Créer une classe pour calculer
le carré du nombre commence de 1 à
la valeur du nombre est inférieure à 6
"
classe calculate_power :
# Initialise la valeur de num
def __iter__(self):
soi.n = 1
soi.résultat=0
retourner soi-même
# Calcule le prochain nombre qui est divisible par 5
def __next__(self):
# Vérifiez que la valeur de n est inférieure ou égale à 5 ou non
si soi.m <= 5:
soi.résultat = soi.n**2
temps.dormir(0.5)
soi.n += 1
retourner soi-même.résultat
autre:
augmenter StopIteration
# Créer un objet de la classe
Objet = calculate_power()
# Créer un objet itérable
iterObjet = iter(Objet)
# Définir une boucle infinie
tant que vrai :
essayer:
# Passez à l'itération suivante et imprimez la valeur carrée
print("Le carré de %d est %d" %(iterObject.n,iterObjet.__suivant__()))
sauf StopIteration :
print("\nTerminé de la boucle.")
# Terminer à partir de la boucle
Pause

Production

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

Itérer avec itertools

Python a un module intégré nommé 'itertools' qui peut être utilisé pour créer un itérateur pour itérer des 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.suiteLa fonction ' peut être utilisée avec le 'carte()' méthode pour générer des données séquentielles et avec le 'Zip *: français()' 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.compte (début=0, pas=1)

Ici, le premier paramètre, 'démarrer,' 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 count() Fonction d'itertools

Le script suivant calculera la somme à partir de 0 à m nombres, où la valeur de m sera retiré à l'utilisateur. Le 'compter()' la fonction est importée de 'itertools' au début du script. Le 'mon_itérateur' l'objet est initialisé avec le 'compter()' fonction, avec un 'démarrer' 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 nombre de départ est stocké en tant que caractère dans la variable, nombres qui seront utilisés pour combiner d'autres nombres à chaque itération. Les valeurs des numéros séquentiels seront ajoutées à chaque itération lorsque le 'suivant()' méthode est appelée. Lorsque la valeur de je devient supérieur à m, le script se terminera en affichant le résultat de la somme.

"Le script suivant calculera
la somme de 0 au nombre qui sera pris en entrée.
"
# Nombre d'importations
à partir du nombre d'importations d'itertools
# Crée un objet itérable de count()
my_iterator = count(start=0, step=1)
# Lire la première valeur de l'itérateur
sum_result = next(my_iterator)
# Prend une entrée numérique pour terminer la boucle while infinie
n = int(input("Entrez la valeur limite :"))
# Initialise la valeur de i et des nombres
i = somme_résultat
nombres = f'i'
# Déclarer une boucle infinie
tant que vrai :
# Ajouter le nombre à chaque itération
sum_result += je
i = suivant(mon_itérateur)
# Termine la boucle si la valeur de i est supérieure à n
si(je > n) :
Pause
# Ajoutez la valeur numérique sous forme de chaîne avec le symbole '+'
nombres += "+" + f'i'
# Imprimer la valeur finale
print("%s = %d" % (nombres,sum_result))

Production

La sortie suivante montre que le nombre dix est considérée 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 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, des chaînes, des tuples, des listes, etc. peut être utilisé comme objet. Les retours d'objet itérables de cette fonction permettent d'itérer chaque valeur de l'objet qui sera utilisée comme argument en utilisant le 'suivant()' méthode. Le nombre d'itérations des valeurs de l'objet itérable sera basé 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 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 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()' une fonction. L'objet itérable nommé 'liste_num' est initialisé par la valeur de retour de cette fonction. Le 'compter' variable est initialisée à 0, et lorsque la valeur de cette variable devient 6, les 'tandis que' la boucle se terminera. Alors le 'tandis que' boucle itérera six fois, et chaque valeur de la liste ne se répétera qu'une seule fois.

# Importer un module aléatoire
importer au hasard
# Importer le module itertools
importer des itertools
# Générer 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.randint
(100 500)] )
# Initialiser le compteur
compte = 0
# Itérer la boucle 6 fois
tandis que (compter != 6):
print('Le nombre aléatoire actuel est : ' + f'next(num_list)')
compte+=1

Production

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 itérations suivantes.

Itertools.répéter()

La fonction 'repeat()' fonctionne comme un itérateur infini et peut prendre deux arguments. Lorsque le deuxième argument est omis, la fonction 'repeat()' 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 à 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 lorsqu'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 de 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()' une fonction. Une valeur de chaîne sera extraite de l'utilisateur pour répéter, et une valeur numérique sera extraite de l'utilisateur pour définir la limite de répétition. La valeur de retour du 'répéter()La fonction ' sera alors convertie en une liste avec le 'liste()' méthode et stocké dans le 'listeDonnées'variable. Les valeurs du 'listeDonnées' sera imprimé avec le 'pour' boucle.

# Importer le module itertools
importer des itertools
# Prenez la valeur d'entrée qui se répétera
string = input("Entrez une chaîne : ")
# Prendre la valeur numérique à répéter
repeat = int(input("Entrez le nombre à répéter : "))
# utilisation de repeat() pour ajouter à plusieurs reprises la chaîne dans une liste
listData= list(itertools.répéter (chaîne, répéter))
# Initialiser je
je = 1
print ("Les valeurs de la liste sont : \n")
# Itérer la liste en utilisant la boucle for
pour val dans listData :
print("Élément de liste %d =%s" %(i,val))
je += 1

Production

La sortie suivante montre que 'Python' est pris comme valeur de chaîne, et 3 est considéré comme le nombre utilisé pour répéter la valeur de 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 en Python sont tenté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 des besoins. 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 n'importe quelle boucle pour lire n'importe quel objet itérable. Certaines utilisations de itertools module de python sont également expliqués dans cet article pour connaître plus de détails sur l'itérateur en python.