Le générateur : yield, la fonction qui se suspend The generator: yield, the function that suspends itself

Une fonction qui contient yield ne s'exécute pas quand tu l'appelles : elle retourne un générateur, un itérateur qui n'a encore rien fait. Chaque next() reprend l'exécution exactement où elle s'était arrêtée — variables locales, position de boucle, tout gelé, sans une seule ligne d'attribut d'instance. Le prix : le corps de la fonction ne s'exécute jamais avant qu'on la tire, pas même la validation que tu croyais immédiate. A function containing yield doesn't run when you call it: it returns a generator, an iterator that has done nothing yet. Each next() resumes execution exactly where it stopped — local variables, loop position, everything frozen, without a single instance-attribute line. The price: the function body never runs before you pull it, not even the validation you assumed was immediate.

Audience
Dev qui écrit des classes-itérateurs à la main et se demande s'il y a plus simple Dev hand-writing iterator classes and wondering if there's a simpler way
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●○○
Date
Juil 2026 Jul 2026

GénérateursyieldItérateurs

SommaireContents ·
№ 01CadrageFraming3 min

Appeler une fonction avec yield ne l'exécute pas. Ça fabrique un générateur.Calling a function with yield doesn't run it. It builds a generator.

Le numéro précédent a montré l'itérateur écrit à la main : une classe, un __iter__ qui retourne self, un __next__ qui avance un état stocké dans des attributs. Le générateur est un raccourci syntaxique pour exactement ce patron — mais un raccourci qui cache une mécanique déroutante. compte(3) ne lance rien : aucune ligne du corps ne s'exécute, print("démarrage") ne s'affiche pas. L'appel retourne immédiatement un objet générateur, un itérateur en puissance. Le corps ne commence à tourner qu'au premier next() — et s'arrête, gelé, à chaque yield, pour reprendre exactement là au prochain appel.The previous issue showed the hand-written iterator: a class, an __iter__ returning self, a __next__ advancing state stored in attributes. The generator is syntactic shorthand for exactly that pattern — but a shorthand that hides a disorienting mechanic. compte(3) launches nothing: no line of the body runs, print("démarrage") doesn't print. The call immediately returns a generator object, an iterator waiting to happen. The body only starts running at the first next() — and stops, frozen, at every yield, to resume exactly there on the next call.

Rien ne s'exécute avant le premier next()Nothing runs before the first next()
def compte(fin):
    print("démarrage")          # on s'attend à voir ça tout de suite...
    n = 0
    while n < fin:
        n += 1
        yield n                 # <- suspend ici, renvoie n, attend le prochain next()
    print("terminé")

g = compte(3)
print("g créé")                 # affiché AVANT "démarrage" !
print(next(g))                  # affiche "démarrage", puis 1
print(next(g))                  # 2 — reprend juste après le yield précédent
print(next(g))                  # 3
print(next(g))                  # affiche "terminé", puis StopIteration
Le sous-réflexe du numéroThis issue's sub-reflex

Face à une fonction contenant yield, ne demande jamais « que fait-elle ? » mais « à quel moment, exactement, chaque ligne s'exécute-t-elle ? » L'appel construit ; seul next() avance.Facing a function with yield, never ask "what does it do?" but "exactly when does each line run?" The call builds; only next() advances.

yield n'est pas returnyield isn't return

return quitte la fonction et efface son état. yield le fige : son cadre d'exécution — détaché de la pile pendant la pause —, les variables locales, la position dans la boucle restent en mémoire, prêts à reprendre. C'est une pause, pas une sortie.return exits the function and erases its state. yield freezes it: its frame — detached from the stack while paused —, local variables, position in the loop stay in memory, ready to resume. It's a pause, not an exit.

№ 02La surpriseThe surprise4 min

L'état gelé entre deux next() ne vit dans aucun attribut — il vit dans le cadre d'exécution du générateur.The state frozen between two next() calls lives in no attribute — it lives in the generator's frame.

Compare les deux versions : la classe Compteur du numéro précédent stocke explicitement son état dans self.n — c'est un choix de conception, une variable d'instance qu'il faut déclarer, initialiser, faire avancer à la main. Le générateur compteur fait exactement la même chose sans qu'aucune ligne ne le dise : n est une variable locale ordinaire, et pourtant elle survit entre deux appels de next(). Le secret : quand une fonction contient yield, Python ne l'exécute jamais comme une fonction normale — il lui construit un cadre d'exécution séparé, suspendable, qui garde tout son contexte local en mémoire tant que le générateur existe.Compare the two versions: the previous issue's Compteur class explicitly stores its state in self.n — a design choice, an instance variable you must declare, initialize, advance by hand. The compteur generator does exactly the same thing without a single line saying so: n is an ordinary local variable, and yet it survives between two next() calls. The secret: when a function contains yield, Python never runs it like a normal function — it builds it a separate, suspendable execution frame, which keeps its whole local context in memory for as long as the generator exists.

Le patron du №10 : self.n porte l'état, à la main№10's pattern: self.n carries the state, by hand
class Compteur:                     # le patron du №10, écrit à la main
    def __init__(self, fin):
        self.n, self.fin = 0, fin
    def __iter__(self):
        return self
    def __next__(self):
        if self.n >= self.fin:
            raise StopIteration
        self.n += 1
        return self.n
# 8 lignes, un état porté dans self.n et self.fin, à gérer soi-même

Toute la mécanique du protocole — __iter__, __next__, StopIteration — est là, explicite. C'est correct, et c'est verbeux dès que l'état à porter se complique (plusieurs variables, une boucle imbriquée, une pile).The whole protocol mechanic — __iter__, __next__, StopIteration — is right there, explicit. It's correct, and it's verbose the moment the state to carry gets complicated (several variables, a nested loop, a stack).

Le générateur ne dispense pas du protocole du №10. Il te dispense d'écrire les attributs qui le portaient.The generator doesn't spare you №10's protocol. It spares you writing the attributes that carried it.
№ 03La mécaniqueThe mechanics5 min

La paresse permet l'infini — et la mémoire constante, en échange du temps.Laziness enables the infinite — and constant memory, in exchange for time.

Parce qu'un générateur ne produit qu'une valeur à la fois, sur demande, il peut représenter une séquence qui n'a pas de fin — une liste infinie serait absurde, un générateur infini est ordinaire. C'est la conséquence directe de la suspension du Ch1 : tant que personne n'appelle next(), rien n'est calculé, et rien n'est stocké. Cette paresse existe aussi sous une forme condensée, l'expression génératrice — la même syntaxe qu'une liste en compréhension, mais avec des parenthèses au lieu de crochets, et aucune valeur calculée avant qu'on ne la demande.Because a generator only ever produces one value at a time, on demand, it can represent a sequence with no end — an infinite list would be absurd, an infinite generator is ordinary. That's the direct consequence of Ch1's suspension: as long as nobody calls next(), nothing gets computed, and nothing gets stored. This laziness also comes in a condensed form, the generator expression — the same syntax as a list comprehension, but with parentheses instead of brackets, and no value computed before it's asked for.

Aucune condition d'arrêt : la paresse le permetNo stop condition: laziness allows it
def entiers():                # générateur INFINI — pas de condition d'arrêt
    n = 0
    while True:
        yield n
        n += 1

naturels = entiers()
premiers_5 = [next(naturels) for _ in range(5)]   # [0, 1, 2, 3, 4]
# entiers() ne "contient" jamais tous les entiers : il en produit UN
# à la fois, à la demande. list(entiers()) tournerait pour toujours.

entiers() ne boucle jamais tout seul : c'est toi qui décides combien de next() appeler. La séquence est infinie, la mémoire qu'elle occupe ne l'est pas — un entier à la fois, jamais la totalité. C'est le principe derrière itertools.count().entiers() never loops on its own: you decide how many next() calls to make. The sequence is infinite, the memory it occupies isn't — one integer at a time, never the whole. It's the principle behind itertools.count().

Le compromis, en une ligneThe trade-off, in one line

Une liste paie la mémoire pour offrir la relecture et l'indexation. Un générateur paie l'usage unique pour offrir une mémoire constante — même face à l'infini.A list pays memory to offer replay and indexing. A generator pays single-use to offer constant memory — even in the face of infinity.

№ 04Le piègeThe trap4 min

Le corps d'un générateur ne s'exécute jamais à l'appel — même pas la validation.A generator's body never runs at call time — not even validation.

Le Ch1 a montré que compte(3) ne lance rien. Voici sa conséquence la plus piégeuse : n'importe quelle ligne placée dans le corps d'une fonction avec yield hérite de ce report — y compris un raise, une validation d'argument, une ouverture de ressource que tu croyais immédiate. Une fonction ordinaire valide ses arguments à l'appel ; une fonction génératrice les valide au premier next(), c'est-à-dire souvent dans une boucle for, loin du site d'appel, avec une pile d'erreur qui pointe vers la mauvaise ligne.Ch1 showed that compte(3) launches nothing. Here's its trickiest consequence: any line placed in a yield function's body inherits that deferral — including a raise, an argument check, a resource opened that you assumed was immediate. An ordinary function validates its arguments at call time; a generator function validates them at the first next(), usually inside a for loop, far from the call site, with an error traceback pointing at the wrong line.

Le raise attend le premier next(), pas l'appelThe raise waits for the first next(), not the call
def lire_lignes(chemin):
    if not chemin.endswith(".csv"):
        raise ValueError("il faut un .csv")   # <- on croit que ça valide tout de suite
    with open(chemin) as f:
        for ligne in f:
            yield ligne.strip()

gen = lire_lignes("rapport.txt")   # AUCUNE erreur ici — juste un générateur créé
print("créé sans problème")        # s'affiche : le corps n'a pas encore tourné
for ligne in gen:                  # <- l'erreur explose ICI, loin de l'appel fautif
    ...                             # ValueError: il faut un .csv

Le ValueError est écrit en toute bonne foi juste après la signature — l'œil le lit comme une garde d'entrée classique. Mais aucune ligne du corps ne tourne avant le premier next(), garde comprise. L'erreur explose dans le for, potentiellement des dizaines de lignes plus loin, voire dans une autre fonction qui a juste reçu gen en argument.The ValueError is written in good faith right after the signature — the eye reads it as a classic entry guard. But no line of the body runs before the first next(), guard included. The error explodes inside the for, potentially dozens of lines away, or even in a different function that merely received gen as an argument.

Le contre-emploiThe counter-use

Ne sépare pas systématiquement eager et paresseux « au cas où » — cette gymnastique n'est utile que si la validation a un coût de découverte tardive réel (erreur métier, ressource externe). Une fonction locale, appelée et parcourue au même endroit, n'a rien à y gagner.Don't systematically split eager from lazy "just in case" — this gymnastic is only worth it when late discovery of the error has a real cost (business error, external resource). A local function, called and walked in the same spot, has nothing to gain from it.

Le réflexe en une phraseThe reflex in one sentence

Toute ligne écrite avant le premier yield d'une fonction n'est pas exécutée « au chargement » — elle est exécutée au premier next(), pas avant.Any line written before a function's first yield doesn't run 'on load' — it runs at the first next(), not before.

№ 05Bilan & éditoWrap-up & editorial2 min

La paresse a une syntaxe. yield en est la version la plus lisible.Laziness has a syntax. yield is its most readable form.

Ce numéro a montré comment Python transforme une fonction en itérateur sans qu'on écrive une seule ligne du protocole vu au №10 — yield remplace __iter__/__next__/StopIteration en trois mots-clé et une suspension d'exécution qui gèle tout le contexte local. Le prix : la fonction ne s'exécute jamais quand on l'appelle, seulement quand on la tire — validation comprise, et c'est le piège le plus sournois du numéro.This issue showed how Python turns a function into an iterator without writing a single line of the protocol seen in №10 — yield replaces __iter__/__next__/StopIteration with three keywords and an execution suspension that freezes the whole local context. The price: the function never runs when called, only when pulled — validation included, and that's this issue's sneakiest trap.

NotionConceptCe qu'il faut en retenirWhat to take away
yieldSuspend la fonction, renvoie une valeur, gèle tout le contexte local.Suspends the function, returns a value, freezes the whole local context.
Appel vs next()Call vs next()L'appel construit le générateur ; rien ne s'exécute avant le premier next().The call builds the generator; nothing runs before the first next().
Générateur infiniInfinite generatorPossible car rien n'est stocké — une valeur à la fois, mémoire constante.Possible because nothing is stored — one value at a time, constant memory.
(x for x in …)Version condensée, paresse opt-in — parenthèses au lieu de crochets.Condensed form, opt-in laziness — parentheses instead of brackets.
Un générateur ne fait rien tant qu'on ne le lui demande pas. Même signaler une erreur attend son tour.A generator does nothing until asked. Even raising an error waits its turn.
Mot de l'éditeurFrom the editor

Deux numéros, deux façons de fabriquer un itérateur. Reste une question : que se passe-t-il quand on le consomme mal ?Two issues, two ways to build an iterator. One question remains: what happens when you consume it wrong?

Le №10 a effleuré le piège en passant : sum() qui vide un map() avant que max() ne s'en approche. Le générateur de ce numéro n'y échappe pas — il hérite lui aussi de l'épuisement à usage unique. Le dernier numéro du volume regroupe toutes les vues paresseuses de la bibliothèque standard — map, zip, filter, et les générateurs eux-mêmes — pour établir un seul réflexe qui les couvre toutes : comment savoir si ce que je tiens se relit, et que faire quand ce n'est pas le cas.№10 brushed against the trap in passing: sum() draining a map() before max() gets near it. This issue's generator doesn't escape it either — it too inherits single-use exhaustion. The volume's last issue rounds up every lazy view in the standard library — map, zip, filter, and generators themselves — to establish one reflex that covers them all: how to know whether what you're holding re-reads, and what to do when it doesn't.

Prochain numéro : la vue qui se consomme. map/zip/filter en une seule passe ; réutiliser un générateur épuisé rend « vide » sans erreur ; list() pour matérialiser, et son coût. Dernier numéro du Vol. IV.Next issue: the view that consumes itself. map/zip/filter in a single pass; reusing an exhausted generator returns 'empty' with no error; list() to materialize, and its cost. Vol. IV's closing issue.