L'argument par défaut évalué une seule fois, à la définition The default argument evaluated once, at definition

Le défaut d'un paramètre n'est pas recalculé à chaque appel : l'expression tourne une seule fois, quand def s'exécute, et le résultat se range sur la fonction. Un défaut mutable devient alors un état partagé qui survit entre les appels — et un def f(t=time.time()) fige l'instant de sa propre naissance. L'antidote tient en un mot immuable : None. A parameter's default isn't recomputed on each call: the expression runs once, when def executes, and the result is stored on the function. A mutable default then becomes shared state surviving across calls — and def f(t=time.time()) freezes the instant of its own birth. The antidote fits in one immutable word: None.

Audience
Dev qui a vu le piège du défaut mutable et veut en comprendre la mécanique Dev who has seen the mutable-default trap and wants its mechanics
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●○○○
Date
Juil 2026 Jul 2026

MutabilitéFonctionsÉtat partagé

SommaireContents ·
№ 01CadrageFraming3 min

Un défaut est évalué à la définition, jamais à l'appel.A default is evaluated at definition, never at the call.

Au premier numéro, on a croisé def f(x=[]) comme un symptôme : la liste qui ne se vide jamais. On va maintenant le disséquer comme un mécanisme — et découvrir que le piège n'a rien à voir avec les listes. Il tient à un seul décalage : en Python, l'expression par défaut d'un paramètre s'exécute quand la ligne def est lue, une fois pour toutes, pas à chaque appel de la fonction. Venu d'un langage typé, on suppose l'inverse : que le défaut est « la valeur utilisée quand l'argument manque », fraîche à chaque fois. Faux.In the first issue we met def f(x=[]) as a symptom: the list that never empties. Now we dissect it as a mechanism — and find the trap has nothing to do with lists. It comes down to one gap: in Python, a parameter's default expression runs when the def line is read, once and for all, not on each call of the function. Coming from a typed language, you assume the opposite: that the default is 'the value used when the argument is missing', fresh each time. Wrong.

Le défaut n'est pas une liste — c'est un instant figéThe default isn't a list — it's a frozen instant
import time

def stamp(t=time.time()):   # time.time() est appelé UNE fois, ici, à la définition
    return t

# ... trois secondes plus tard ...
stamp()   # renvoie l'instant de la DÉFINITION, pas celui de l'appel
stamp()   # ... et le même instant, encore : le défaut ne se recalcule jamais
Deux moments que Python garde séparésTwo moments Python keeps apart
Temps de la définitionDefinition time
def stamp(...)
time.time() → 1 fois
défaut rangé sur la fonction
Temps de l'appelCall time
stamp()
stamp()
le MÊME défaut, réutilisé

La ligne def n'est pas qu'une déclaration : c'est une instruction qui s'exécute. Elle évalue chaque expression par défaut sur-le-champ, et range le résultat sur l'objet-fonction. L'appel, lui, ne fait que relire ce résultat.The def line isn't just a declaration: it's a statement that runs. It evaluates each default expression on the spot, and stores the result on the function object. The call merely re-reads that result.

Le sous-réflexe du numéroThis issue's sub-reflex

Devant un def f(x=EXPR), demande-toi : EXPR est évaluée maintenant, une fois. Si EXPR produit un objet mutable, tous les appels sans argument le partagent. Si EXPR lit l'heure, une config, un compteur — c'est la valeur au moment de la définition qui est gelée, pour toujours.Facing a def f(x=EXPR), ask yourself: EXPR is evaluated now, once. If EXPR yields a mutable object, every argument-less call shares it. If EXPR reads the clock, a config, a counter — the value at definition time is frozen, forever.

Pourquoi ce numéro clôt le Vol. I.Why this issue closes Vol. I.

Le №01 a posé « un nom lie un objet », le №02 « le type décide de la mutabilité ». Le défaut par argument est le premier lieu où ces deux idées se combinent en un bug de production : un objet, lié une fois, mutable, partagé à l'insu de l'appelant. C'est le pont vers le Vol. II, où l'on demandera pour de bon : qui d'autre tient cette référence ?№01 laid down 'a name binds an object', №02 'the type decides mutability'. The default argument is the first place these two ideas combine into a production bug: one object, bound once, mutable, shared without the caller's knowledge. It's the bridge to Vol. II, where we'll ask for real: who else holds this reference?

№ 02La mécaniqueThe mechanics5 min

Le défaut n'est pas une valeur magique. C'est un attribut de la fonction.The default isn't a magic value. It's an attribute of the function.

Voici où le défaut se cache, et pourquoi c'est démontrable en deux lignes. Quand def s'exécute, Python crée un objet-fonction et range les valeurs par défaut dans un tuple accroché à cet objet : func.__defaults__. Ce tuple n'est pas reconstruit aux appels. Donc si un défaut est une liste, elle est joignable, inspectable — et on peut la regarder grossir appel après appel. Le « bug » n'est pas caché : il est exposé sur la fonction, il suffit de savoir où regarder.Here's where the default hides, and why it's provable in two lines. When def runs, Python builds a function object and stores the default values in a tuple attached to it: func.__defaults__. That tuple isn't rebuilt on calls. So if a default is a list, it's reachable, inspectable — and you can watch it grow call after call. The 'bug' isn't hidden: it's exposed on the function, you just need to know where to look.

__defaults__ : le défaut rangé sur la fonction__defaults__: the default stored on the function
def collect(x, acc=[]):
    acc.append(x)
    return acc

collect(1)
print(collect.__defaults__)   # ([1],)     — le défaut vit SUR la fonction
collect(2)
print(collect.__defaults__)   # ([1, 2],)  — le MÊME objet, il enfle

La liste par défaut est collect.__defaults__[0] — un objet unique, né à la lecture du def. Chaque appel sans acc reçoit ce même objet et l'append. Le tuple __defaults__ ne change jamais de contenu (il pointe toujours la même liste) ; c'est la liste qu'il pointe qui enfle. L'état « fuit » parce qu'il a un domicile fixe sur la fonction.The default list is collect.__defaults__[0] — a single object, born when the def was read. Every call without acc gets that same object and appends to it. The __defaults__ tuple never changes its content (it always points to the same list); it's the list it points to that swells. State 'leaks' because it has a fixed home on the function.

Un défaut mutable n'est pas « une valeur qui se souvient ». C'est un objet unique, accroché à la fonction, que chaque appel partage sans le savoir.A mutable default isn't "a value that remembers". It's a single object, pinned to the function, that every call shares unknowingly.
№ 03L'antidoteThe antidote4 min

L'antidote est un défaut immuable : None, testé avec is.The antidote is an immutable default: None, tested with is.

La règle idiomatique tient en une phrase : ne mets jamais un objet mutable en valeur par défaut. Mets un défaut immuable — None — et construis l'objet mutable dans le corps, à chaque appel qui en a besoin. None est un singleton unique dans tout l'interpréteur : il n'y a rien à partager, et on le teste avec is (le réflexe du №01). Mais l'idiome a un angle mort — quand None est lui-même une valeur que l'appelant peut légitimement passer.The idiomatic rule fits in one sentence: never put a mutable object as a default value. Put an immutable default — None — and build the mutable object in the body, on each call that needs it. None is a unique singleton across the whole interpreter: there's nothing to share, and you test it with is (№01's reflex). But the idiom has a blind spot — when None is itself a value the caller may legitimately pass.

acc=None — construire dans le corpsacc=None — build in the body
def collect(x, acc=None):
    if acc is None:          # défaut immuable : rien à partager
        acc = []             # un objet NEUF, à chaque appel qui en a besoin
    acc.append(x)
    return acc

collect(1)   # [1]
collect(2)   # [2] — enfin indépendant

Le défaut est désormais None — immuable, unique, non partageable dans son contenu. La liste naît dans le corps, à chaque appel qui entre dans le if. Le test s'écrit acc is None, jamais == None : un == appellerait __eq__, qu'un objet exotique peut détourner pour se prétendre « égal à None » et faire sauter le garde-fou. Un seul None existe ; rien ne peut se faire passer pour lui via is.The default is now None — immutable, unique, unshareable in its content. The list is born inside the body, on each call that enters the if. The test reads acc is None, never == None: a == would call __eq__, which an exotic object can hijack to claim it's 'equal to None' and break the guard. Only one None exists; nothing can impersonate it through is.

Le réflexe en une ligneThe reflex in one line

Défaut immuable au bord de la fonction, objet mutable construit dans le corps. Le sentinelle marque « rien passé » ; le corps décide quoi en faire.Immutable default at the function's edge, mutable object built in the body. The sentinel marks 'nothing passed'; the body decides what to do with it.

№ 04Le contre-emploiThe counter-use4 min

Le même mécanisme qui piège est parfois exactement l'outil.The very mechanism that traps is sometimes exactly the tool.

« Évalué une fois, à la définition » n'est pas un défaut du langage : c'est un comportement, et il se retourne. Là où il crée un état partagé accidentel, il peut aussi capturer une valeur à point nommé, ou tenir un cache voulu. La ligne de partage n'est pas « mutable = mal » — c'est « ce partage est-il une intention, ou un accident ? ». Deux cas où l'intention est claire : la capture précoce, et le cache assumé.'Evaluated once, at definition' isn't a language flaw: it's a behavior, and it cuts both ways. Where it creates accidental shared state, it can also capture a value at just the right time, or hold a deliberate cache. The dividing line isn't 'mutable = bad' — it's 'is this sharing intent, or accident?'. Two cases where intent is clear: early capture, and the deliberate cache.

i=i : figer la valeur, à la définitioni=i: freeze the value, at definition
# Le piège classique de la closure (on le disséquera au Vol. V) :
fns = [lambda: i for i in range(3)]
print([f() for f in fns])        # [2, 2, 2] — i est lu TARD, à l'appel

# L'antidote exploite l'évaluation PRÉCOCE du défaut :
fns = [lambda i=i: i for i in range(3)]
print([f() for f in fns])        # [0, 1, 2] — i=i fige la valeur, à la définition

Voici le revers lumineux. Une closure capture la variable i, lue tard, à l'appel — d'où [2, 2, 2]. Le défaut, lui, est évalué tôt, à la définition de chaque lambda : i=i photographie la valeur courante de i et la range comme défaut. Même mécanisme qu'au chapitre 1, mais ici il sauve. Le défaut, c'est de la liaison précoce ; la closure, de la liaison tardive. On dissèque la seconde au Vol. V, № 14.Here's the bright flip side. A closure captures the variable i, read late, at call time — hence [2, 2, 2]. The default, though, is evaluated early, at each lambda's definition: i=i snapshots i's current value and stores it as a default. Same mechanism as chapter 1, but here it rescues. A default is early binding; a closure, late binding. We dissect the latter in Vol. V, № 14.

Précoce contre tardifEarly versus late

Retiens l'axe, il traverse la série : une valeur par défaut est gelée à la définition (liaison précoce) ; un nom libre dans une closure est lu à l'appel (liaison tardive). Presque tous les « pourquoi ça ne prend pas la bonne valeur ? » se rangent d'un côté ou de l'autre de cette ligne.Keep the axis, it runs through the series: a default value is frozen at definition (early binding); a free name in a closure is read at call (late binding). Almost every 'why didn't it pick up the right value?' falls on one side or the other of that line.

Le préfixe _ est un aveu, pas un permis.The _ prefix is a confession, not a permit.

Nommer un paramètre _memo ou _cache signale « ne le passe pas, c'est de la tuyauterie ». C'est honnête, mais ça reste un état partagé caché dans une signature. Pour un vrai cache : lru_cache. Pour un vrai état : une classe, une closure explicite, un attribut. Le défaut mutable assumé est l'exception, jamais le premier réflexe.Naming a parameter _memo or _cache signals 'don't pass it, it's plumbing'. That's honest, but it's still shared state hidden in a signature. For a real cache: lru_cache. For real state: a class, an explicit closure, an attribute. The deliberate mutable default is the exception, never the first reflex.

« Évalué une fois » est un piège quand c'est subi, un outil quand c'est choisi. Le mécanisme est neutre ; c'est ton intention qui tranche."Evaluated once" is a trap when suffered, a tool when chosen. The mechanism is neutral; your intent decides.
№ 05Bilan & éditoWrap-up & editorial2 min

Quatre réflexes pour un défaut qui ne te trahit pas.Four reflexes for a default that won't betray you.

Le défaut par argument n'est pas recalculé : il naît à la définition, vit sur la fonction, et se partage tel quel entre les appels. Vu ainsi, le piège se dissout — il ne reste qu'une règle et son antidote. Et ce numéro ferme le Vol. I : un nom lie un objet (№01), le type décide s'il se laisse muter (№02), et voici le premier endroit où un objet lié une fois devient un état partagé à l'insu de tous.A default argument isn't recomputed: it's born at definition, lives on the function, and is shared as-is across calls. Seen this way, the trap dissolves — only a rule and its antidote remain. And this issue closes Vol. I: a name binds an object (№01), the type decides if it lets itself be mutated (№02), and here is the first place an object bound once becomes shared state without anyone's knowledge.

Tu veux…You want to…Le gesteThe moveCe que ça coûteWhat it costs
Un défaut mutableA mutable defaultDéfaut None, construire dans le corps : if x is None: x = [].Default None, build in the body: if x is None: x = [].Oublier l'idiome, et le défaut devient un objet unique partagé par tous les appels.Skip the idiom, and the default becomes one object shared by every call.
Distinguer « absent » de NoneTell 'missing' from NoneUn sentinelle privé : _MISSING = object(), testé par is.A private sentinel: _MISSING = object(), tested with is.None comme sentinelle échoue dès que None est une valeur que l'appelant peut passer.None as a sentinel fails the moment None is a value the caller may pass.
Figer une valeur au bon momentFreeze a value at the right timeLa liaison précoce du défaut : lambda i=i: ... photographie i. Vol 5 · №14.The default's early binding: lambda i=i: ... snapshots i. Vol 5 · №14.C'est un contournement de la liaison tardive des closures — puissant, mais à commenter.It's a workaround for closures' late binding — powerful, but comment it.
Un cache entre appelsA cache across calls@lru_cache plutôt qu'un _memo par défaut : l'intention est nommée.@lru_cache over a default _memo: the intent is named.Le défaut-cache marche, mais repose sur le piège que le prochain lecteur devra deviner.The default-cache works, but rests on the trap the next reader must guess.
La ligne def n'attend pas l'appel pour agir. Elle évalue ses défauts sur-le-champ — et ce qu'elle fabrique là, elle le garde.The def line doesn't wait for the call to act. It evaluates its defaults on the spot — and what it builds there, it keeps.
Mot de l'éditeurFrom the editor

La définition est un moment, pas une étiquette.Definition is a moment, not a label.

Dans un langage typé, une signature est une déclaration inerte : elle décrit, elle ne s'exécute pas. En Python, def est une instruction qui tourne, ligne à ligne, et fabrique un objet vivant — avec ses défauts déjà calculés, rangés, prêts à être partagés. Tout le « piège » du défaut mutable n'est que la conséquence de cette vérité : il n'y a pas de moment neutre où le code se contente d'exister. Chaque expression que tu écris s'exécute quand son tour vient — et le tour du défaut, c'est maintenant, à la définition, pas plus tard.In a typed language, a signature is an inert declaration: it describes, it doesn't run. In Python, def is a statement that runs, line by line, and builds a living object — with its defaults already computed, stored, ready to be shared. The whole 'trap' of the mutable default is just the consequence of this truth: there is no neutral moment where code merely exists. Every expression you write runs when its turn comes — and the default's turn is now, at definition, not later.

Fin du Vol. I. On sait qu'un nom lie un objet, que le type décide de la mutabilité, et qu'un objet lié une fois peut se partager sans qu'on l'ait demandé. La question suivante s'impose d'elle-même — et ouvre le Vol. II : quand je m'apprête à muter un objet, qui d'autre en tient une référence ? Le paramètre qui est un alias de l'argument, l'objet glissé dans une liste, la valeur renvoyée : autant de noms sur la même chose. L'aliasing, en grand.End of Vol. I. We know a name binds an object, that the type decides mutability, and that an object bound once can be shared unasked. The next question imposes itself — and opens Vol. II: when I'm about to mutate an object, who else holds a reference to it? The parameter that aliases the argument, the object slipped into a list, the returned value: so many names on the same thing. Aliasing, at scale.