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)]
