La closure capture la variable, pas la valeur The closure captures the variable, not the value

[lambda: i for i in range(3)] fabrique trois fonctions différentes, mais elles impriment toutes 2 quand on les appelle — jamais 0, 1, 2. Une closure ne capture pas un instantané de la valeur au moment où elle est définie : elle capture la variable elle-même, lue au moment où on l'appelle. La boucle a terminé sa course avant le premier appel ; les trois fonctions lisent la même case, à son état final. [lambda: i for i in range(3)] builds three different functions, but they all print 2 when called — never 0, 1, 2. A closure doesn't capture a snapshot of the value at definition time: it captures the variable itself, read at call time. The loop finishes its run before the first call; all three functions read the same slot, at its final state.

Audience
Dev qui a créé des callbacks dans une boucle et vu tous imprimer la même valeur Dev who's built callbacks in a loop and watched them all print the same value
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●●○
Date
Juil 2026 Jul 2026

ClosuresPortéeLiaison tardive

SommaireContents ·
№ 01CadrageFraming3 min

Trois lambdas différentes, un seul nombre. Le piège le plus classique des closures.Three different lambdas, one single number. The classic closure trap.

Le numéro précédent a établi LEGB : un nom lu dans une fonction est cherché en Local, puis Enclosing, puis Global, puis Built-in. Une closure est précisément une fonction qui lit un nom dans sa portée Enclosing — une variable définie dans la fonction (ou la boucle) qui l'englobe. Le piège qui ouvre ce numéro est le plus commenté de tout Python : construire une liste de fonctions dans une boucle, une par itération, en espérant que chacune se souvienne de la valeur de la boucle au moment de sa création. Elles s'en souviennent toutes — mais de la même, la dernière.The previous issue established LEGB: a name read inside a function is looked up in Local, then Enclosing, then Global, then Built-in. A closure is precisely a function that reads a name from its Enclosing scope — a variable defined in the function (or loop) that contains it. The trap opening this issue is the most commented-on in all of Python: building a list of functions inside a loop, one per iteration, hoping each remembers the loop's value at the moment of its creation. They all remember — but the same one, the last.

Trois fonctions, trois moments de création, une seule valeur lueThree functions, three moments of creation, one single value read
fonctions = [lambda: i for i in range(3)]

print(fonctions[0]())     # 2 !
print(fonctions[1]())     # 2 !
print(fonctions[2]())     # 2 — les TROIS lambdas impriment la même chose

# et pourtant : "i" valait 0, puis 1, puis 2, à trois moments différents
# de la boucle. On s'attendait à 0, 1, 2. On obtient 2, 2, 2.
Le sous-réflexe du numéroThis issue's sub-reflex

Face à une fonction créée dans une boucle qui lit une variable de la boucle, demande : cette fonction lit-elle la variable au moment où je la crée, ou au moment où je l'appelle ? La réponse, pour Python, est toujours la seconde.Facing a function created inside a loop that reads the loop's variable, ask: does this function read the variable at the moment I create it, or at the moment I call it? For Python, the answer is always the latter.

Ce n'est pas un bug de lambdaIt's not a lambda bug

Le même piège se produit avec def à l'intérieur d'une boucle, avec un callback passé à un widget, avec une closure retournée par une fabrique de fonctions. lambda n'est qu'une syntaxe compacte pour créer une fonction — le comportement de capture est identique partout.The same trap occurs with def inside a loop, with a callback passed to a widget, with a closure returned by a function factory. lambda is just compact syntax for creating a function — the capture behavior is identical everywhere.

№ 02La surpriseThe surprise4 min

Une closure ne garde pas une photo de la valeur. Elle garde une référence vers la variable.A closure doesn't keep a photo of the value. It keeps a reference to the variable.

L'intuition la plus commune imagine chaque lambda comme un appareil photo, prenant un cliché de i au moment exact de sa création. Ce serait le comportement d'une capture par valeur — copier la valeur actuelle dans la fonction, une fois pour toutes. Ce n'est pas ce que fait Python. Une closure capture la variable elle-même : une case mémoire partagée, une cellule, que toutes les fonctions créées dans la même portée pointent en commun. Modifier i après coup — ou simplement laisser la boucle continuer — change ce que toutes les closures verront, parce qu'elles regardent toutes la même case, pas une copie qui leur serait propre.The most common intuition pictures each lambda as a camera, taking a snapshot of i at the exact moment of its creation. That would be capture-by-value behavior — copying the current value into the function, once and for all. That's not what Python does. A closure captures the variable itself: a shared memory slot, a cell, that every function created in the same scope points to in common. Changing i afterward — or simply letting the loop continue — changes what every closure will see, because they're all looking at the same slot, not a copy of their own.

Ce que l'intuition suppose, à tortWhat intuition wrongly assumes
# CE QU'ON IMAGINE (faux) : chaque lambda "prend une photo" de i à sa création
# lambda #0 se souviendrait de i=0, lambda #1 de i=1, lambda #2 de i=2
# -> ce serait le comportement d'une COPIE DE VALEUR, capturée une fois

# CE QUI SE PASSE réellement : chaque lambda garde une RÉFÉRENCE vers
# la MÊME variable "i" — pas trois cases séparées, une seule, partagée

Cette intuition vient d'autres langages, ou de l'habitude de penser une variable comme une valeur figée plutôt qu'une case qu'on peut relire. Python ne fige jamais rien à la création d'une closure — il ne fait que retenir où regarder plus tard.This intuition comes from other languages, or from the habit of thinking of a variable as a frozen value rather than a slot you can re-read. Python never freezes anything when a closure is created — it only remembers where to look later.

Une closure ne se souvient de rien. Elle sait juste où regarder — et regarde à chaque fois qu'on l'appelle.A closure remembers nothing. It just knows where to look — and looks anew every time it's called.
№ 03La mécaniqueThe mechanics5 min

Pas de nouvelle portée à chaque tour de boucle : une seule variable existe, du début à la fin.No new scope per loop turn: only one variable exists, from start to finish.

Certains langages créent une variable de boucle distincte à chaque itération — c'est ce qui permettrait à chaque closure d'attraper sa propre case. Python ne le fait pas. Une boucle for ne crée aucune portée : i est une variable ordinaire de la fonction (ou du module) qui contient la boucle, assignée et réassignée à chaque tour, exactement comme le décrit le numéro 13 sur LEGB. Il n'y a jamais eu trois i. Il n'y en a eu qu'un, réutilisé trois fois.Some languages create a distinct loop variable on every iteration — that's what would let each closure grab its own slot. Python doesn't. A for loop creates no scope at all: i is an ordinary variable of the function (or module) containing the loop, assigned and reassigned on every turn, exactly as issue 13 described for LEGB. There was never three i's. There was only ever one, reused three times.

La preuve : i survit à la boucleThe proof: i survives the loop
for i in range(3):
    pass
# la boucle est terminée ; "i" existe TOUJOURS, ici, dans la portée englobante
print(i)          # 2

# contrairement à d'autres langages, Python NE CRÉE PAS de nouvelle portée
# à chaque itération d'une boucle for — ni même une portée pour la boucle
# elle-même. "i" est une variable de la fonction (ou du module) qui contient
# la boucle, purement et simplement.

Ce simple fait explique tout. Puisque la boucle ne crée pas de nouvelle case à chaque tour, les trois lambdas n'ont jamais eu le choix : elles pointent forcément vers la seule case qui existe. Reste la seconde moitié de l'explication — le moment de la lecture.This single fact explains everything. Since the loop creates no new slot per turn, the three lambdas never had a choice: they necessarily point to the one slot that exists. What remains is the second half of the explanation — the timing of the read.

Le corps du lambda ne s'exécute qu'à l'appelThe lambda's body only runs at call time
def fabrique():
    fonctions = []
    for i in range(3):
        fonctions.append(lambda: i)   # le corps du lambda n'est PAS exécuté ici
    return fonctions

fs = fabrique()
# à cet instant, la boucle est FINIE depuis longtemps ; "i" vaut 2

fs[0]()   # exécute enfin le corps -> cherche "i" en Enclosing -> lit 2
fs[1]()   # même recherche, même case, même valeur -> 2
fs[2]()   # -> 2

# LEGB (numéro 13) ne dit rien sur QUAND on lit -- seulement OÙ chercher.
# Ici, la recherche a toujours lieu au moment de l'APPEL, jamais avant.
Écrire une lambda ≠ l'exécuterWriting a lambda ≠ running it

lambda: i définit une fonction ; elle ne lit pas i tout de suite, exactement comme le numéro 11 l'a montré pour les générateurs. La recherche LEGB de i n'a lieu qu'au moment de l'appel — bien après que la boucle se soit achevée.lambda: i defines a function; it does not read i right away, exactly as issue 11 showed for generators. The LEGB lookup for i only happens at call time — long after the loop has finished.

№ 04Le piègeThe trap4 min

Le correctif fige la valeur avec un argument par défaut — mais pas toujours : parfois le partage est le but.The fix freezes the value with a default argument — but not always: sometimes sharing is the point.

Puisque le problème est que toutes les closures lisent la même case au moment de l'appel, le correctif consiste à forcer une lecture immédiate, au moment de la création — et à la stocker ailleurs, dans un endroit qui ne changera plus. Un argument par défaut fait exactement ça, pour la même raison qu'il piégeait le numéro 03 avec les listes mutables : il n'est évalué qu'une fois, à la définition de la fonction. Mais ce correctif n'est pas toujours désirable — parfois, la case partagée est précisément ce qu'on veut construire.Since the problem is that every closure reads the same slot at call time, the fix is to force an immediate read, at creation time — and stash it somewhere that won't change again. A default argument does exactly that, for the same reason it trapped issue 03 with mutable defaults: it's only evaluated once, at function-definition time. But this fix isn't always wanted — sometimes the shared slot is exactly what you're trying to build.

Un paramètre par défaut n'est évalué qu'une fois, à la définitionA default parameter is only evaluated once, at definition
# Fix : forcer la lecture MAINTENANT, via un argument par défaut
fonctions = [lambda i=i: i for i in range(3)]

print(fonctions[0]())     # 0
print(fonctions[1]())     # 1
print(fonctions[2]())     # 2 — chacune a bien sa propre valeur

# pourquoi ça marche : un argument par défaut est évalué UNE SEULE FOIS,
# au moment de la définition de la fonction (numéro 03 : le piège des
# défauts mutables reposait sur ce même mécanisme). "i=i" copie la valeur
# ACTUELLE de i dans un nouveau nom local "i", propre à chaque lambda.
Le réflexe à retenirThe reflex to keep

Demande d'abord si la closure doit voir une valeur figée à sa création, ou l'état courant d'une case partagée. La première réponse appelle i=i ou une fabrique ; la seconde — un compteur, un cache, un accumulateur — a besoin de nonlocal, sujet du numéro 15.First ask whether the closure should see a value frozen at creation, or the current state of a shared slot. The first answer calls for i=i or a factory; the second — a counter, a cache, an accumulator — needs nonlocal, the subject of issue 15.

№ 05Bilan & éditoWrap-up & editorial2 min

La closure ne trahit pas la boucle. Elle applique LEGB fidèlement — au mauvais moment, pour ton intuition.The closure isn't betraying the loop. It's applying LEGB faithfully — just at the wrong moment for your intuition.

Ce numéro a suivi une seule idée jusqu'au bout : une closure capture une variable, pas un instantané de sa valeur. Puisque Python ne crée pas de nouvelle portée à chaque tour de boucle, il n'existe qu'une seule case pour i — et toutes les fonctions créées dans la boucle la lisent au moment où on les appelle, jamais avant. Le correctif ne change rien à ce mécanisme ; il force juste une lecture immédiate, ailleurs, via un argument par défaut évalué une seule fois à la définition — exactement le mécanisme qui piégeait le numéro 03 avec les listes mutables.This issue followed one idea to its conclusion: a closure captures a variable, not a snapshot of its value. Since Python creates no new scope per loop turn, there's only ever one slot for i — and every function created in the loop reads it at call time, never before. The fix doesn't change this mechanism; it just forces an immediate read, elsewhere, via a default argument evaluated once at definition — exactly the mechanism that trapped issue 03 with mutable defaults.

NotionConceptCe qu'il faut en retenirWhat to take away
Capture par référenceCapture by referenceUne closure garde une case partagée, pas une copie de la valeur au moment de sa création.A closure keeps a shared slot, not a copy of the value at creation time.
Pas de portée par itérationNo per-iteration scopeUn for ne crée aucune nouvelle portée à chaque tour ; i est une seule variable, réassignée.A for loop creates no new scope per turn; i is a single variable, reassigned each time.
Lecture au moment de l'appelRead at call timeLe corps d'une fonction ne s'exécute — et ne cherche ses noms — qu'à l'appel, jamais à la définition.A function's body only executes — and only looks up its names — at call time, never at definition.
i=iUn argument par défaut fige la valeur à la définition, car il n'est évalué qu'une fois — bridge avec le numéro 03.A default argument freezes the value at definition, since it's only evaluated once — bridges back to issue 03.
La closure ne se trompe jamais de case. C'est notre horloge — création ou appel — qui était mal réglée.The closure never reads the wrong slot. It was our clock — creation or call — that was set wrong.
Mot de l'éditeurFrom the editor

Lire une variable englobante est passif. Reste à savoir : peut-on la modifier depuis l'intérieur ?Reading an enclosing variable is passive. The question left: can you modify it from the inside?

Ce numéro n'a montré que des lectures : une closure qui consulte i, jamais qui le change. Mais le compteur du dernier encart de ce numéro a révélé la vraie question qui referme ce volume : quand une fonction imbriquée veut réassigner un nom qui vit dans sa portée Enclosing, LEGB seul ne suffit plus. Sans mot-clé, cette réassignation crée une variable locale toute neuve — le piège d'UnboundLocalError du numéro 13, rejoué une portée plus loin. Deux mots-clés existent pour lever explicitement cette ambiguïté : global et nonlocal, chacun pointant vers une portée différente.This issue only showed reads: a closure that consults i, never one that changes it. But the counter in this issue's closing sidebar revealed the real question that closes this volume: when a nested function wants to reassign a name living in its Enclosing scope, LEGB alone isn't enough. Without a keyword, that reassignment creates a brand-new local variable — issue 13's UnboundLocalError trap, replayed one scope further out. Two keywords exist to explicitly lift that ambiguity: global and nonlocal, each pointing to a different scope.

Prochain numéro : global et nonlocal, l'explicite contre l'implicite — dernier numéro du volume sur la portée.Next issue: global and nonlocal, the explicit against the implicit — the volume's closing issue on scope.