En Python, les itérateurs et les générateurs sont des outils puissants pour travailler avec des séquences de données. Ils vous permettent de parcourir les données sans avoir à stocker la séquence entière en mémoire. Ce blog expliquera les itérateurs et les générateurs d'une manière simple et compréhensible, avec des exemples pratiques.
Définition : Un itérateur est un objet en Python qui vous permet de parcourir tous les éléments d'une collection (comme une liste ou un tuple) un à la fois. Il suit le protocole itérateur, qui inclut l'implémentation de deux méthodes : __iter__() et __next__().
Comment fonctionnent les itérateurs :
__iter__() : Cette méthode renvoie l'objet itérateur lui-même.
__next__() : Cette méthode renvoie la valeur suivante de la collection. S'il n'y a plus d'éléments à renvoyer, l'exception StopIteration est déclenchée.
Exemple d'itérateur personnalisé :
class MyIterator: def __init__(self, data): self.data = data self.index = 0 def __iter__(self): return self def __next__(self): if self.index < len(self.data): result = self.data[self.index] self.index += 1 return result else: raise StopIteration my_iter = MyIterator([1, 2, 3]) for item in my_iter: print(item)
Sortie :
1 2 3
Explication : Dans cet exemple, MyIterator est une classe d'itérateur personnalisée qui parcourt une liste de nombres. La méthode __next__() renvoie l'élément suivant de la liste et déclenche StopIteration lorsqu'il n'y a plus d'éléments à renvoyer.
Python fournit des itérateurs par défaut pour les collections intégrées telles que les listes, les tuples, les dictionnaires et les ensembles. Vous pouvez utiliser la fonction iter pour obtenir un itérateur à partir de ces collections, puis utiliser next pour les parcourir.
my_list = [1, 2, 3] my_iter = iter(my_list) print(next(my_iter)) # Output: 1 print(next(my_iter)) # Output: 2 print(next(my_iter)) # Output: 3 # print(next(my_iter)) # This will raise StopIteration
Définition : Un générateur est un type spécial d'itérateur en Python, défini à l'aide d'une fonction et du mot-clé rendement. Les générateurs vous permettent de parcourir une séquence de valeurs sans les stocker toutes en mémoire en même temps, ce qui les rend plus efficaces en mémoire que les listes.
Comment fonctionnent les générateurs :
Exemple :
def my_generator(): yield 1 yield 2 yield 3 gen = my_generator() for item in gen: print(item)
Sortie :
1 2 3
Explication : Dans cet exemple, my_generator est une fonction génératrice qui génère trois valeurs une par une. Chaque appel à rendement produit une valeur et met la fonction en pause jusqu'à ce que la valeur suivante soit demandée.
Efficacité de la mémoire : Les générateurs génèrent des valeurs à la volée et ne stockent pas la séquence entière en mémoire, ce qui les rend idéaux pour travailler avec de grands ensembles de données ou des flux de données.
Exemple :
def large_sequence(): for i in range(1, 1000001): yield i gen = large_sequence() print(next(gen)) # Output: 1 print(next(gen)) # Output: 2
Explication : Ce générateur produit une séquence d'un million de nombres sans les stocker tous en mémoire, démontrant son efficacité en mémoire.
Itérateurs :
Objets itérables personnalisés : lorsque vous avez besoin de plus de contrôle sur la logique d'itération.
Séquences infinies : générer une séquence infinie de valeurs, telles que les données d'un capteur.
Générateurs :
Évaluation paresseuse : traitement de grands ensembles de données, un élément à la fois.
Pipelines : création de pipelines de traitement de données qui gèrent les données en streaming.
Définition : Les expressions de générateur fournissent un moyen concis de créer des générateurs. Ils sont similaires aux compréhensions de listes mais utilisent des parenthèses au lieu de crochets.
Exemple :
gen_exp = (x * x for x in range(5)) for value in gen_exp: print(value)
Sortie :
0 1 4 9 16
Explication : Cette expression génératrice crée un générateur qui produit les carrés des nombres de 0 à 4.
Exemple 1 : Lecture de fichiers volumineux
def read_large_file(file_path): with open(file_path, 'r') as file: for line in file: yield line for line in read_large_file('large_file.txt'): print(line.strip())
Explication : Cette fonction génératrice lit un gros fichier ligne par ligne, produisant une ligne à la fois. Il est économe en mémoire car il ne charge pas l'intégralité du fichier en mémoire.
Exemple 2 : Séquence de Fibonacci
def fibonacci(): a, b = 0, 1 while True: yield a a, b = b, a + b fib = fibonacci() for _ in range(10): print(next(fib))
Sortie :
0 1 1 2 3 5 8 13 21 34
Explication : Cette fonction génératrice produit une séquence infinie de nombres de Fibonacci. Il montre comment les générateurs peuvent être utilisés pour générer des séquences de valeurs potentiellement infinies.
* An iterator is an object that allows you to traverse through all the elements of a collection one at a time, implementing the `__iter__()` and `__next__()` methods.
* A generator is a special type of iterator defined using a function and the `yield` keyword, allowing you to generate values on the fly without storing them all in memory.
* Generators are memory-efficient, as they generate values on the fly. They are useful for processing large datasets, building data pipelines, and working with potentially infinite sequences.
* Generator expressions use parentheses and produce values one at a time, whereas list comprehensions use square brackets and generate the entire list in memory.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!