Imaginez charger un fichier journal de 10 Go dans une liste juste pour trouver les erreurs. Votre programme peut manquer de mémoire avant d’en trouver une. Les générateurs Python résolvent ce problème en produisant des valeurs à la demande, une par une, afin que vous puissiez travailler sur des données volumineuses, voire infinies, avec presque aucune mémoire.

Ce guide montre ce qui se passe réellement lorsqu’un générateur fonctionne, étape par étape. Nous avons exécuté chaque exemple sur Python 3.13 et le résultat provient de cette exécution. Il est utile d’être déjà à l’aise avec les fonctions et les boucles, ce que couvre notre Tutoriel Python pour débutants.

Qu’est-ce qu’un générateur ?

Un générateur est un type spécial d’itérateur que vous créez en écrivant une fonction à l’aide de yield. Toute fonction contenant yield devient automatiquement une fonction génératrice, et son appel vous donne un objet générateur plutôt que d’exécuter le code.

def count_up(limit):
    print("starting")
    n = 1
    while n <= limit:
        yield n
        n += 1
    print("finished")

gen = count_up(2)
print(gen)

# <generator object count_up at 0x...>

Notez que « starting » ne s’est pas imprimé. L’appel de la fonction a uniquement créé le générateur. Rien à l’intérieur n’a encore fonctionné.

Comment fonctionne le rendement, étape par étape

Chaque appel à next() exécute la fonction jusqu’à ce qu’elle atteigne un yield, restitue cette valeur et se fige sur place. L’appel suivant reprend juste après cette ligne, avec chaque variable locale intacte.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Suivez attentivement la sortie. “starting” n’apparaît que sur le premier next(). Au deuxième, l’exécution continue là où elle s’est arrêtée, donc n est toujours disponible et devient 2. Au troisième, la boucle se termine, “terminé” s’imprime, la fonction tombe à la fin et Python lève StopIteration pour signaler qu’il ne reste plus rien.

Vous appelez rarement next() vous-même. Une boucle for le fait pour vous et gère StopIteration tranquillement, tout comme list(), sum() et des fonctions similaires :

print(list(count_up(3)))

# starting
# finished
# [1, 2, 3]

rendement vs rendement

Ce délai est connu sous le nom d’évaluation paresseuse : les valeurs ne sont élaborées qu’en cas de besoin. Un simple return à l’intérieur d’un générateur le termine simplement, ce qui déclenche StopIteration.

La différence de mémoire, mesurée

Nous avons comparé une liste d’un million de carrés avec un générateur équivalent, en utilisant sys.getsizeof :

import sys

squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))

print(sys.getsizeof(squares_list), sys.getsizeof(squares_gen))

# 8448728 200

La propre structure de la liste prenait environ 8,4 Mo, alors que le générateur ne prenait que 200 octets sur notre système. L’écart réel est encore plus grand, car getsizeof ne compte pas les objets entiers dans la liste. La taille du générateur reste également la même pour un milliard d’éléments, puisqu’il stocke uniquement son état actuel et non ses résultats.

Il y a cependant un compromis. Une liste peut être réutilisée, indexée et mesurée avec len(). Un générateur n’offre rien de tout cela. Si vous avez besoin d’un accès aléatoire ou si vous effectuez plusieurs boucles sur une petite quantité de données, une liste est plus simple. Consultez notre guide sur Liste Python vs tuple vs set pour en savoir plus sur ces types.

Expressions génératrices

Pour les cas simples, vous n’avez pas besoin de fonction. Une expression génératrice ressemble à une compréhension de liste avec des parenthèses à la place des carrés :

squares = [n * n for n in range(5)]   # builds a list now
squares = (n * n for n in range(5))   # produces values on demand

print(sum(n * n for n in range(5)))

# 30

Lorsqu’une expression génératrice est le seul argument d’une fonction, comme dans sum(), vous pouvez laisser de côté les crochets supplémentaires. Il s’agit d’une bonne habitude pour les totaux sur des données volumineuses, car aucune liste temporaire n’est créée.

Construire un pipeline de données

C’est là que les générateurs brillent vraiment. Les petits générateurs peuvent être enchaînés afin que chaque élément passe par chaque étape, un à la fois :

def read_lines(lines):
    for line in lines:
        yield line.strip()

def only_errors(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line

def messages(lines):
    for line in lines:
        yield line.split(" ", 1)[1]

log = ["INFO started\n", "ERROR db down\n",
       "ERROR disk full\n", "INFO stopped\n"]

print(list(messages(only_errors(read_lines(log)))))

# ['db down', 'disk full']

Chaque étape effectue un petit travail et peut être testée individuellement. En utilisation réelle, remplacez la liste d’exemples par un fichier ouvert, car les objets fichier peuvent être lus ligne par ligne, comme le montre notre guide sur la gestion des fichiers Python. Même un journal de plusieurs gigaoctets serait alors transmis avec très peu de mémoire.

Séquences infinies

Une liste ne peut pas être infinie, mais un générateur le peut, car il ne calcule que la valeur suivante. Utilisez itertools.islice pour en prendre autant que nécessaire :

import itertools

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(itertools.islice(fibonacci(), 8)))

# [0, 1, 1, 2, 3, 5, 8, 13]

Attention cependant : appeler list(fibonacci()) sans limite s’exécuterait jusqu’à ce que votre mémoire soit épuisée. Le même modèle convient aux générateurs d’ID, aux boucles d’interrogation et aux résultats d’API paginés, où vous récupérez la page suivante uniquement lorsque la page actuelle est épuisée.

rendement et lots

yield from passez à un autre itérable, vous enregistrant une boucle imbriquée :

def chain_all(*groups):
    for group in groups:
        yield from group

print(list(chain_all([1, 2], (3, 4))))

# [1, 2, 3, 4]

Un modèle très pratique consiste à diviser les données en lots de taille fixe, par exemple pour insérer des milliers de lignes à la fois dans une base de données :

def batches(items, size):
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch

print(list(batches(range(7), 3)))

# [[0, 1, 2], [3, 4, 5], [6]]

Le dernier if batch garantit qu’un groupe restant plus petit n’est pas perdu. Python 3.12 et versions ultérieures incluent également itertools.batched, qui fait un travail similaire.

envoyer, fermer et nettoyer

Les générateurs peuvent également recevoir des valeurs. send() reprend le générateur et la valeur devient le résultat de l’expression yield. Vous devez d’abord appeler next() une fois pour atteindre le premier yield :

def running_total():
    total = 0
    while True:
        value = yield total
        total += value

t = running_total()
next(t)
print(t.send(10), t.send(5))

# 10 15

La plupart des gens en ont rarement besoin. Une préoccupation plus courante est le nettoyage. Si vous vous arrêtez tôt, un bloc finally s’exécute toujours lorsque le générateur est fermé :

def tracked():
    try:
        yield 1
        yield 2
    finally:
        print("cleanup ran")

tr = tracked()
next(tr)
tr.close()

# cleanup ran

Pytest utilise cette même idée : un appareil avec yield exécute ensuite son nettoyage, comme le démontre notre tutoriel pytest. De même, le décorateur contextmanager de la bibliothèque standard transforme un générateur en bloc with.

Générateurs en classe

Écrire une méthode __iter__ en tant que générateur est le moyen le plus simple de rendre votre propre classe itérable. Un avantage est que chaque boucle reçoit un nouveau générateur, de sorte que l’objet peut être bouclé encore et encore :

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

c = Countdown(3)
print(list(c), list(c))

# [3, 2, 1] [3, 2, 1]

Quand utiliser un générateur

Un générateur n’est pas toujours globalement plus rapide. Si vous finissez par utiliser chaque valeur, le travail total est similaire et la compréhension d’une liste peut même être plus rapide pour les petites données, car elle entraîne moins de frais généraux par élément. Les principaux avantages sont l’utilisation de la mémoire et l’obtention des premiers résultats plus tôt.

Erreurs courantes

Réutiliser un générateur épuisé

Cela attrape presque tout le monde à un moment donné. Un générateur se souvient qu’il est terminé :

g = count_up(2)
print(list(g), list(g))

# [1, 2] []

Le deuxième appel obtient une liste vide sans aucune erreur. Appelez à nouveau la fonction pour obtenir un nouveau générateur ou utilisez l’approche de classe présentée ci-dessus.

Attendre que le code s’exécute immédiatement

def noisy():
    print("body runs")
    yield 1

n = noisy()        # nothing is printed
print(next(n))     # body runs, then 1

Les vérifications d’arguments en haut d’un générateur ne s’exécutent qu’au premier next(), donc les erreurs peuvent apparaître loin de l’appel qui les a provoquées.

Autres pièges

• Appel de len() ou indexation. Les générateurs ne prennent en charge ni l’un ni l’autre et génèrent un TypeError.
• Fermer un fichier trop tôt. Renvoyer un générateur depuis l’intérieur d’un bloc with peut signifier que le fichier se ferme avant qu’une ligne ne soit lue. Mettez le yield à l’intérieur du bloc with.
• Tout envelopper dans list(). Cela annule l’avantage de la mémoire.
• En utiliser un pour les données minuscules. Une liste simple est souvent plus claire.

Pour conclure

Un générateur est une fonction qui peut faire une pause. Cette idée vous offre une faible utilisation de la mémoire, des séquences infinies et des pipelines propres. Pour le mettre en pratique, trouvez un endroit dans votre code qui crée une grande liste uniquement pour la parcourir une seule fois, et transformez-la en générateur. Essayez ensuite de chaîner deux petits générateurs sur un vrai fichier journal.

Questions fréquentes

Continuez à apprendre