Mutable ou immuable : pourquoi += ment Mutable or immutable: why += lies

Un seul opérateur, deux gestes opposés. x += 1 fabrique un nouvel objet et recolle l'étiquette ; lst += [1] mute la liste sur place. Le signe ne décide de rien — c'est le type de l'objet qui tranche. Et quand un tuple « immuable » contient une liste, la même ligne peut muter l'objet ET lever une exception dans la foulée. One operator, two opposite moves. x += 1 builds a new object and re-sticks the label; lst += [1] mutates the list in place. The sign decides nothing — the object's type does. And when an 'immutable' tuple holds a list, the same line can mutate the object AND raise an exception in one breath.

Audience
Dev qui tient déjà « un nom, un objet » et veut voir où la mutabilité mord Dev who already holds 'one name, one object' and wants to see where mutability bites
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●○○○
Date
Juil 2026 Jul 2026

MutabilitéRéférencestuple

SommaireContents ·
№ 01CadrageFraming3 min

Un seul +=, deux gestes que rien dans le signe ne distingue.One +=, two moves nothing in the sign tells apart.

On tient le réflexe du premier numéro : un nom est une étiquette, pas une boîte. Reste une question que ce réflexe ne tranche pas encore — l'objet visé se laisse-t-il modifier, ou faut-il en fabriquer un neuf ? C'est la mutabilité, et elle n'est pas un détail : c'est une propriété du type, décidée bien avant ta ligne de code. L'opérateur += est l'endroit où elle mord le plus fort, parce qu'il porte les deux comportements sous le même symbole.You hold the first issue's reflex: a name is a label, not a box. One question that reflex doesn't settle yet — does the target object let itself be modified, or must a fresh one be made? That's mutability, and it's no detail: it's a property of the type, decided long before your line of code. The += operator is where it bites hardest, because it carries both behaviors under one symbol.

Le même opérateur, deux issuesThe same operator, two outcomes
s = "ab"
s += "c"        # une NOUVELLE chaîne "abc" — s change de cible
lst = [1]
lst += [2]      # la MÊME liste [1, 2] — mutée sur place
# même opérateur, +=, deux gestes opposés selon le type
La frontière est dans le typeThe line runs through the type
Immuable · un neuf à chaque foisImmutable · a fresh one each time
intfloatboolstrbytestuplefrozensetNone
Mutable · modifié sur placeMutable · modified in place
listdictsetbytearrayla plupart des instances

Un objet immuable ne peut pas changer de valeur : toute « modification » fabrique un objet neuf et recolle le nom. Un objet mutable se laisse changer en place — et tous les noms qui le désignent voient la différence.An immutable object cannot change value: any "modification" builds a fresh object and re-sticks the name. A mutable object lets itself be changed in place — and every name pointing to it sees the difference.

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

Avant d'écrire x += y, x.append(...) ou x[0] = ..., pose la question du type : cet objet est-il mutable ? Si oui, tu modifies une chose que d'autres noms peuvent tenir. Si non, tu n'as fait que déplacer une étiquette — l'ancien objet est intact, quelque part.Before writing x += y, x.append(...) or x[0] = ..., ask the type question: is this object mutable? If yes, you're modifying a thing other names may hold. If no, you only moved a label — the old object is untouched, somewhere.

Pourquoi ce numéro suit le premier.Why this issue follows the first.

Le № 01 a montré que l'assignation ne copie jamais — elle lie un nom. La suite logique : si l'objet visé est partagé, tout dépend de s'il se laisse muter. La mutabilité est la variable cachée de l'aliasing. On la nomme ici, avant de voir au Vol. II qui d'autre tient l'objet.Issue № 01 showed assignment never copies — it binds a name. The logical next step: if the target object is shared, everything hinges on whether it lets itself be mutated. Mutability is aliasing's hidden variable. We name it here, before Vol. II asks who else holds the object.

№ 02La surpriseThe surprise4 min

x += y n'est pas « muter ». C'est peut-être muter, puis toujours rebind.x += y isn't "mutate". It's maybe mutate, then always rebind.

Voici ce que le sucre syntaxique cache. x += y se lit en deux temps : Python cherche d'abord __iadd__ sur l'objet ; s'il existe (les mutables), il modifie l'objet en place et renvoie ce même objet ; sinon (les immuables), il retombe sur x = x + y, qui fabrique un objet neuf. Dans les DEUX cas, la dernière étape est la même : réassigner le nom x. Pour une liste, cette réassignation pointe sur l'objet déjà muté — invisible. La seule façon de voir la différence, c'est id().Here's what the syntactic sugar hides. x += y reads in two beats: Python first looks for __iadd__ on the object; if it exists (mutables), it modifies the object in place and returns that same object; otherwise (immutables), it falls back to x = x + y, which builds a fresh object. In BOTH cases the last step is identical: rebind the name x. For a list, that rebind points at the already-mutated object — invisible. The only way to see the difference is id().

Immuable — l'id change : nouvel objetImmutable — the id changes: new object
s = "ab"
print(id(s))       # 140312...328
s += "c"           # str n'a pas d'__iadd__ : s = s + "c"
print(s, id(s))    # abc 140312...800 — un NOUVEL objet, s rebind

Une str ne propose pas __iadd__. Python retombe donc sur s = s + "c" : il construit la chaîne "abc", un objet neuf, et recolle s dessus. L'id() a changé — la preuve qu'aucune modification en place n'a eu lieu. Sur un immuable, += est un pur rebind déguisé.A str offers no __iadd__. So Python falls back to s = s + "c": it builds the string "abc", a fresh object, and re-sticks s onto it. The id() changed — proof no in-place modification happened. On an immutable, += is a pure rebind in disguise.

+= ne veut pas dire « modifie ». Il veut dire « modifie si tu peux, sinon fabrique — puis, dans tous les cas, réassigne le nom ».+= doesn't mean "modify". It means "modify if you can, otherwise build — then, either way, rebind the name".
№ 03L'immuabilitéImmutability5 min

Le tuple gèle ses cases, pas les objets qu'elles désignent.A tuple freezes its slots, not the objects they point to.

« Un tuple est immuable » — vrai, mais on se trompe sur ce que ça garantit. L'immuabilité du tuple porte sur ses cases : tu ne peux pas réassigner t[0], ni ajouter ou retirer un élément. Elle ne descend pas dans les objets référencés. Un tuple qui contient une liste tient une référence gelée vers une liste, elle, bien mutable. Le contenant est figé ; le contenu peut vivre sa vie.'A tuple is immutable' — true, but we mistake what it guarantees. A tuple's immutability is about its slots: you can't reassign t[0], nor add or remove an element. It doesn't descend into the referenced objects. A tuple holding a list keeps a frozen reference to a list that is itself very much mutable. The container is fixed; the content can live its own life.

Réassigner une case — refuséReassign a slot — refused
t = (1, [2, 3])
t[0] = 99      # TypeError: 'tuple' object does not support item assignment
# le tuple refuse de changer de CASE : ses références sont gelées

t[0] = 99 voudrait faire pointer la première case ailleurs. C'est exactement ce que le tuple interdit : ses cases sont figées à la construction. Même refus pour t.append(...) — la méthode n'existe pas. Ce qui est gelé, ce sont les références que le tuple détient, pas ce qu'il y a au bout.t[0] = 99 would make the first slot point elsewhere. That's exactly what the tuple forbids: its slots are frozen at construction. Same refusal for t.append(...) — the method doesn't exist. What's frozen are the references the tuple holds, not what sits at their end.

La conséquence qui piqueThe consequence that stings

Un tuple n'est hachable que si tout son contenu l'est. hash((1, [2])) lève TypeError: unhashable type: 'list' — donc (1, [2]) ne peut pas être clé de dict ni entrer dans un set. Le tuple emprunte l'immuabilité de ce qu'il contient ; une liste dedans la lui retire. On y revient au Vol. III, № 09, avec le contrat __hash__/__eq__.A tuple is hashable only if all its content is. hash((1, [2])) raises TypeError: unhashable type: 'list' — so (1, [2]) can't be a dict key nor join a set. A tuple borrows the immutability of what it holds; a list inside takes it back. More on this in Vol. III, № 09, with the __hash__/__eq__ contract.

« Gelé » veut dire quoi, au juste.What 'frozen' actually means.

Une case de tuple contient une référence, exactement comme un nom. La geler, c'est interdire de la faire pointer ailleurs — pas d'empêcher l'objet au bout de changer. C'est la même distinction qu'au № 01 : le tuple tient des étiquettes, il ne met pas les objets sous cloche.A tuple slot holds a reference, exactly like a name. Freezing it means forbidding it from pointing elsewhere — not preventing the object at its end from changing. Same distinction as in № 01: the tuple holds labels, it doesn't put the objects under glass.

Un tuple immuable qui contient une liste mutable n'est pas immuable au sens où tu l'espérais. Il fige des références, pas des valeurs.An immutable tuple holding a mutable list is not immutable in the sense you hoped. It freezes references, not values.
№ 04Le piègeThe trap4 min

La ligne qui mute l'objet et lève une exception dans la foulée.The line that mutates the object and raises an exception right after.

Réunis les deux chapitres précédents et tu obtiens le piège le plus déroutant de Python. Un tuple dont le premier élément est une liste. Tu écris t[0] += [2]. Tu reçois une TypeError — logique, un tuple refuse qu'on réassigne ses cases. Sauf que quand tu inspectes le tuple après le crash… la liste a été modifiée. L'opération a échoué et réussi à la fois. Ce n'est pas un bug de l'interpréteur : c'est le désucrage de += du chapitre 2, appliqué à une case immuable.Combine the two previous chapters and you get Python's most disorienting trap. A tuple whose first element is a list. You write t[0] += [2]. You get a TypeError — makes sense, a tuple refuses slot reassignment. Except when you inspect the tuple after the crash… the list was modified. The operation both failed and succeeded. It's no interpreter bug: it's chapter 2's += desugaring, applied to an immutable slot.

Une exception ET une mutationAn exception AND a mutation
t = ([1], "x")
t[0] += [2]      # TypeError: 'tuple' object does not support item assignment
print(t)         # ([1, 2], 'x') — pourtant la liste A ÉTÉ mutée !
# t[0] += [2] se déroule en deux temps :
# 1. tmp = t[0].__iadd__([2])   -> la liste s'étend EN PLACE, devient [1, 2]
# 2. t[0] = tmp                 -> réassigner une case du tuple -> TypeError
# l'étape 1 a déjà eu lieu quand l'étape 2 explose

t[0] += [2] n'est pas atomique. Python évalue d'abord t[0].__iadd__([2]) : la liste, mutable, s'étend en place — elle vaut déjà [1, 2]. Puis il tente t[0] = le résultat, pour honorer le rebind que += impose toujours (chapitre 2). Cette réassignation d'une case de tuple lève la TypeError. La mutation a précédé l'erreur — elle reste acquise.t[0] += [2] isn't atomic. Python first evaluates t[0].__iadd__([2]): the mutable list extends in place — it's already [1, 2]. Then it attempts t[0] = the result, to honor the rebind += always requires (chapter 2). That tuple-slot reassignment raises the TypeError. The mutation came before the error — it stays done.

Ce que le piège prouveWhat the trap proves

Ce cas limite est la preuve, par l'absurde, que x += y contient toujours un x = .... Tant que x est un nom ordinaire, la réassignation passe inaperçue et on croit à une simple mutation. Il faut une cible impossible à réassigner — une case de tuple — pour que le rebind sorte de l'ombre et lève. Le piège ne cache rien de neuf : il rend visible la mécanique du chapitre 2.This edge case proves, by contradiction, that x += y always contains an x = .... As long as x is an ordinary name, the rebind goes unnoticed and we believe in plain mutation. It takes a target that can't be reassigned — a tuple slot — for the rebind to step out of the shadows and raise. The trap hides nothing new: it makes chapter 2's mechanics visible.

La vraie règle à retenir.The rule to actually keep.

Ne mets pas d'objets mutables dans un tuple que tu comptes « augmenter » par case. Si tu as besoin d'un conteneur figé de choses figées, fais-le de bout en bout : tuple de tuples, ou tuple de valeurs immuables. Le tuple à moitié gelé est un mensonge qui attend son heure.Don't put mutable objects in a tuple you plan to 'augment' slot-wise. If you need a frozen container of frozen things, make it so all the way down: tuple of tuples, or tuple of immutable values. The half-frozen tuple is a lie waiting for its moment.

L'exception et la mutation cohabitent parce que += mute d'abord, réassigne ensuite — et n'annule jamais la première étape si la seconde échoue.The exception and the mutation coexist because += mutates first, rebinds second — and never undoes the first step if the second fails.
№ 05Bilan & éditoWrap-up & editorial2 min

Quatre réflexes pour cesser de croire que += « modifie ».Four reflexes to stop believing += "modifies".

La mutabilité n'est pas une nuance : c'est la propriété qui décide si ta ligne fabrique un objet ou en change un que d'autres tiennent. += ne tranche rien tout seul — il exécute muter-ou-fabriquer selon le type, puis rebind toujours. Une fois ça vu, le tuple à moitié gelé et l'exception-qui-mute cessent d'être de la magie noire.Mutability isn't a nuance: it's the property that decides whether your line builds an object or changes one others hold. += settles nothing on its own — it runs mutate-or-build depending on the type, then always rebinds. Once you see that, the half-frozen tuple and the exception-that-mutates stop being black magic.

Tu veux…You want to…Le gesteThe moveCe que ça coûteWhat it costs
Étendre une listeExtend a listExplicite : .append(x) / .extend([x]). += marche aussi, mais réassigne le nom.Explicit: .append(x) / .extend([x]). += works too, but rebinds the name.Le rebind de += reste invisible… jusqu'à une cible qu'on ne peut pas réassigner (case de tuple).The += rebind stays invisible… until a target you can't reassign (a tuple slot).
Savoir si += muteKnow if += mutatesLe type est-il mutable ? Ou : type(x) a-t-il __iadd__ ? Sinon, x = x + y.Is the type mutable? Or: does type(x) have __iadd__? If not, x = x + y.Sur un immuable, += crée un objet neuf et rebind — seul id() révèle qu'aucune mutation n'a eu lieu.On an immutable, += builds a fresh object and rebinds — only id() reveals no mutation happened.
Un conteneur figéA frozen containerUn tuple — mais figé de bout en bout : tuple de valeurs immuables, ou de tuples.A tuple — but frozen all the way down: tuple of immutable values, or of tuples.Le tuple ne gèle que ses cases. Une liste dedans reste mutable — l'immuabilité n'est pas récursive.A tuple only freezes its slots. A list inside stays mutable — immutability isn't recursive.
Une clé de dict / un setA dict key / a setUn objet hachable : str, int, ou tuple d'immuables. Vol 3 · №09.A hashable object: str, int, or tuple of immutables. Vol 3 · №09.Un tuple contenant une liste n'est pas hachable : hash() lève TypeError. L'immuabilité s'emprunte au contenu.A tuple holding a list isn't hashable: hash() raises TypeError. Immutability is borrowed from the content.
+= est le raccourci le plus honnête et le plus menteur de Python. Honnête sur ce qu'il fait, menteur sur ce qu'on croit qu'il fait.+= is Python's most honest and most deceptive shortcut. Honest about what it does, deceptive about what we think it does.
Mot de l'éditeurFrom the editor

Le langage ne te ment pas. Le sucre, si.The language doesn't lie to you. The sugar does.

Python met à ta disposition un opérateur unique, +=, pour deux opérations que d'autres langages séparent soigneusement. C'est confortable — jusqu'au jour où le confort te cache l'étape que tu ne voulais pas déclencher. Le rebind silencieux, l'immuabilité qui ne descend pas, la mutation qui survit à l'exception : rien de tout cela n'est une bizarrerie de l'interpréteur. Ce sont les conséquences, parfaitement cohérentes, d'un modèle où un nom lie un objet et où chaque type décide seul s'il se laisse changer. La facilité, ici, n'a pas supprimé la complexité — elle l'a déplacée sous un symbole de deux caractères.Python hands you a single operator, +=, for two operations other languages carefully keep apart. It's comfortable — until the day comfort hides the step you didn't want to trigger. The silent rebind, immutability that doesn't descend, the mutation that outlives the exception: none of it is an interpreter quirk. They're the perfectly coherent consequences of a model where a name binds an object and each type alone decides whether it lets itself be changed. Convenience here didn't remove complexity — it moved it under a two-character symbol.

Prochain numéro : l'argument par défaut évalué une seule fois. On a croisé def f(x=[]) au premier numéro comme un symptôme ; on va le disséquer comme un mécanisme. Pourquoi le défaut naît à la définition et non à l'appel, ce qu'il partage entre tous les appels, et le sentinelle None qui, précisément parce qu'il est immuable, sert d'antidote.Next issue: the default argument evaluated only once. We met def f(x=[]) in the first issue as a symptom; we'll dissect it as a mechanism. Why the default is born at definition and not at call, what it shares across every call, and the None sentinel that, precisely because it's immutable, serves as the antidote.