les itérateurs en Python
Iterateur en python est tout type pouvant être utilisé avec une boucle "for in". Les listes, les tuples, les dict et les sets sont tous des exemples d'itérateurs intégrés. Ces types sont des itérateurs car ils implémentent les méthodes suivantes. En fait, tout objet qui veut être un itérateur doit implémenter les méthodes suivantes :
- __ iter__ méthode appelée sur l'initialisation d'un itérateur. Cela devrait renvoyer un objet qui a une méthode __next__.
- __ next__, doit retourner la valeur suivante pour l'itérable. Quand un itérateur est utilisé avec la boucle for, la boucle for appelle implicitement __ next__ sur l'objet itérateur.
Cette méthode devrait générer une exception StopIteration pour signaler la fin de l'itération.
itérateurs intégrés dans Python
List
L = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samed', 'Dimanche'] for jour in L: print(jour)
Lundi Mardi Mercredi Jeudi Vendredi Samed Dimanche
Tuple
L = ('Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samed', 'Dimanche') for jour in L: print(jour)
Lundi Mardi Mercredi Jeudi Vendredi Samed Dimanche
Dict - Dictionnaire
D = {} D['nom'] = 'ESSADDOUKI' D['prenom'] = 'Mostafa' D['Annee'] = 2019 for cle in D: print(cle, ' : ', D[cle])
nom : ESSADDOUKI prenom : Mostafa Annee : 2019
range
# range(fin) for i in range(5): print(i, end=" ")
0 1 2 3 4
Chaines de caractères
msg = 'Bonjour' for lettre in msg: print(lettre)
B o n j o u r
Définir un itérateur
Exemple
class Tableau: def __init__(self): self.tab = [] def inserer(self, elm): self.tab.append(elm) def __iter__(self): self.n = len(self.tab) self.i = -1 return self def __next__(self): if self.i < self.n-1: self.i += 1 return self.tab[self.i] raise StopIteration Tab = Tableau() Tab.inserer(1) Tab.inserer(2) Tab.inserer(9) Tab.inserer(3) Tab.inserer(12) Tab.inserer(4) Tab.inserer(5) for elm in Tab: print(elm)
1 2 9 3 12 4 5
module itertools
Python, dans sa définition, permet également quelques fonctions d’itérateur intéressantes et utiles pour une exécution efficace de la boucle et une exécution plus rapide du code.
Il existe de nombreux itérateurs intégrés dans le module "itertools".
accumulate(iter, func)
Cet itérateur prend deux arguments, un objet itérable cible et la fonction qui serait suivie à chaque itération de valeur dans la cible. Si aucune fonction n'est passé, l'ajout par défaut. Si l'entrée itérable est vide, la sortie itérable sera également vide.
Exemple 1
calculer le modulo 5 d'une liste
import itertools def prod(prec, courant): return prec*courant liste = [1, 2, 5, 8, 9] res = itertools.accumulate(liste, prod) print(list(res))
[1, 2, 10, 80, 720]
Exemple 2
import itertools class Tableau: def __init__(self): self.tab = [] def inserer(self, elm): self.tab.append(elm) def __iter__(self): self.n = len(self.tab) self.i = -1 return self def __next__(self): if self.i < self.n-1: self.i += 1 return self.tab[self.i] raise StopIteration def somme(prec, courant): return prec+courant Tab = Tableau() Tab.inserer(1) Tab.inserer(2) Tab.inserer(3) Tab.inserer(4) Tab.inserer(5) Tab.inserer(6) Tab.inserer(7) res = itertools.accumulate(Tab, somme) print(list(res))
[1, 3, 6, 10, 15, 21, 28]
Exemple 3
import itertools class Personne: def __init__(self, nom, salaire): self.nom = nom self.salaire = salaire class Ecole: def __init__(self): self.profs = [] def ajouter(self, personne): self.profs.append(personne) def __iter__(self): self.i = -1 return self def __next__(self): if self.i < len(self.profs)-1: self.i += 1 return self.profs[self.i].salaire raise StopIteration def salaire(prec, courant): return prec+courant p1 = Personne('Mohamed', 8000) p2 = Personne('Ahmed', 7000) p3 = Personne('Sara', 7500) p4 = Personne('Kaoutar', 5000) ec = Ecole() ec.ajouter(p1) ec.ajouter(p2) ec.ajouter(p3) ec.ajouter(p4) res = itertools.accumulate(ec, salaire) print(list(res))
[8000, 15000, 22500, 27500]
chain(iter1, iter2..)
Cette fonction est utilisée pour afficher toutes les valeurs des objets itérables (iter1, iter2 ...) les unes après les autres
Exemple
import itertools L1 = [1, 6, 5, 9] L2 = [8, 10, 5, 4] print(list(itertools.chain(L1, L2)))
islice(iterable, debut, fin, pas)
Cet itérateur affiche sélectivement les valeurs mentionnées dans son conteneur itérable passé en argument. Cet itérateur prend 4 arguments, un conteneur itérable, une position de départ, une position de fin et un pas.
Exemple 1
import itertools L1 = [1, 6, 5, 9] res = list(itertools.islice(L1, 1, 4, 2)) print(res)
[6, 9]
Exemple 2
import itertools class Tableau: def __init__(self): self.tab = [] def inserer(self, elm): self.tab.append(elm) def __iter__(self): self.n = len(self.tab) self.i = -1 return self def __next__(self): if self.i < self.n-1: self.i += 1 return self.tab[self.i] raise StopIteration def somme(prec, courant): return prec+courant Tab = Tableau() Tab.inserer(1) Tab.inserer(2) Tab.inserer(3) Tab.inserer(4) Tab.inserer(5) Tab.inserer(6) Tab.inserer(7) res = itertools.islice(Tab, 2, 8, 2) print(list(res))
permutations(iterable, taille_groupe)
Cet itérateur affiche toutes les permutations possibles de tous les éléments d'iterable. La taille de chaque groupe permuté est déterminée par l'argument taille_groupe.
import itertools liste = [1, 2, 5] res = itertools.permutations(liste, 2) print(list(res))
[(1, 2), (1, 5), (2, 1), (2, 5), (5, 1), (5, 2)]
combinations(iterable, taille_groupe)
Cet itérateur imprime toutes les combinaisons possibles (sans remise) du conteneur passé en arguments dont la taille de groupe est spécifiée par taille_groupe.
import itertools liste = [1, 2, 5] res = itertools.combinations(liste, 2) print(list(res))
[(1, 2), (1, 5), (2, 5)]
combinations_with_replacement(iterable, taille_groupe)
Cet itérateur affiche toutes les combinaisons possibles (avec remise) du conteneur passé en arguments dont la taille de groupe est spécifiée par taille_groupe.
import itertools liste = [1, 2, 5] res = itertools.combinations_with_replacement(liste, 2) print(list(res))
[(1, 1), (1, 2), (1, 5), (2, 2), (2, 5), (5, 5)]