Langage Python

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

Partager ce cours avec tes amis :
Rédigé par Mostafa Sedoki
Computer science teacher and the founder of the e-learning platform "developpement-informatique.com", my mission is to provide high-quality courses for free to all computer science students and teachers

Cours Similaires :