Billets d'avion

Un generator est une fonction ou une expression qui renvoie un type particulier d'itérateur appelé un generator iterator. Les Generator-iterators sont paresseux : ils ne stockent pas leurs values en mémoire, mais génèrent leurs valeurs au moment où on en a besoin.

Une fonction génératrice ressemble à n'importe quelle autre fonction, mais elle contient une ou plusieurs expressions yield. Chaque yield suspend l'exécution du code et sauvegarde l'état d'exécution courant (y compris toutes les variables locales et les instructions try). Quand le générateur reprend son exécution, il repart de l'état où il s'était interrompu, contrairement aux fonctions classiques qui sont réinitialisées à chaque appel.

Construis un générateur

On construit les générateurs à peu près comme les autres fonctions itératives ou récursives, mais ils ont besoin d'une expression yield, que l'on verra plus en détail un peu plus loin.

Prenons l'exemple d'une fonction qui renvoie les carrés d'une liste donnée de nombres. Telle qu'elle est écrite actuellement, toutes les entrées doivent être traitées avant qu'une seule valeur puisse être renvoyée :

>>> def squares(list_of_numbers):
...     squares = []
...     for number in list_of_numbers:
...         squares.append(number ** 2)
...     return squares

Tu peux transformer cette fonction en générateur comme ceci :

>>> def squares_generator(list_of_numbers):
...     for number in list_of_numbers:
...         yield number ** 2

L'idée derrière tout ça, c'est qu'on utilise un générateur quand on n'a pas besoin de produire toutes les valeurs d'un seul coup. Cela économise de la mémoire et de la puissance de calcul, puisque seule la valeur sur laquelle on travaille à ce moment-là est calculée.

Utilise un générateur

On peut utiliser les générateurs à la place de la plupart des iterables en Python. Cela inclut les fonctions ou les objets qui attendent un iterable/iterator en argument.

Pour utiliser le générateur squares_generator() :

>>> squared_numbers = squares_generator([1, 2, 3, 4])

>>> for square in squared_numbers:
...     print(square)
...
1
4
9
16

Les valeurs d'un generator peuvent aussi être produites ou récupérées via la fonction next(). next() appelle la méthode __next__() d'un objet générateur-itérateur, ce qui « fait avancer » le code ou l'évalue jusqu'à son expression yield, laquelle « produit » ou renvoie alors une valeur :

>>> squared_numbers = squares_generator([1, 2])

>>> next(squared_numbers)
1
>>> next(squared_numbers)
4

Quand un generator-iterator est entièrement consommé et n'a plus de valeurs à renvoyer, il lève une erreur StopIteration.

>>> next(squared_numbers)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

L'expression yield

L'expression yield est très similaire à l'expression return. Contrairement à l'expression return, yield transmet des valeurs à l'appelant à un moment précis, en suspendant l'évaluation ou le renvoi de toute valeur supplémentaire jusqu'à ce qu'elle soit demandée. Quand yield est évalué, il met en pause l'exécution de la fonction qui le contient et renvoie les valeurs de cette fonction à cet instant précis. La fonction reste alors dans la portée, et quand __next__() est appelé, l'exécution reprend jusqu'à ce que yield soit rencontré à nouveau.

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

>>> lets_try = infinite_sequence()
>>> lets_try.__next__()
0
>>> lets_try.__next__()
1

Pourquoi créer un générateur ?

Les générateurs sont utiles dans de nombreuses applications.

Quand on travaille avec une collection de valeurs potentiellement volumineuse, on n'a pas forcément envie de tout garder en mémoire. Un générateur permet de traiter des données plus importantes morceau par morceau, ce qui économise de la mémoire et améliore les performances.

Les générateurs sont aussi très utiles quand un processus ou un calcul est complexe, coûteux ou infini :

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

Maintenant, chaque fois que __next__() est appelé sur l'objet infinite_sequence, il renvoie le nombre précédent + 1.