b = a ne copie rien, il colle une seconde étiquette b = a copies nothing, it sticks a second label

Un signe égal — = — et deux noms sur un objet. Qui le mute ?One equals sign — = — and two names on one object. Who mutates it?

Quatre lignes que tout le monde écrit le premier jour. Le programme tourne, n'affiche pas ce qu'on attend, et pourtant rien n'a planté. Ce n'est pas un bug de append : c'est le modèle objet entier de Python qui tient dans un seul =. Assigner un nom est trivial ; comprendre ce que le nom désigne est tout le sujet.Four lines everyone writes on day one. The program runs, prints not what you expected, and yet nothing crashed. It's no append bug: it's all of Python's object model fitting inside a single =. Binding a name is trivial; understanding what the name points to is the whole point.

a = [1, 2, 3]
b = a                 # on croit copier la liste
b.append(4)           # on ne touche « que » b
print(a)              # [1, 2, 3, 4] — a a changé aussi

L'assignation ne copie jamais. C'est muter ou rebind.Assignment never copies. It's mutate or rebind.

« Mais avec un nombre, ça marche ! » — et c'est là que le modèle se dérobe. On croit que l'assignation copie parfois (les nombres) et parfois non (les listes). Faux : elle ne copie jamais. La vraie différence est ailleurs — entre un objet qu'on mute en place et un nom qu'on rebind sur un objet neuf. L'opérateur +=, le même signe, fait les deux selon le type.'But with a number, it works!' — and that's where the model slips away. You think assignment sometimes copies (numbers) and sometimes doesn't (lists). Wrong: it never copies. The real difference is elsewhere — between mutating an object in place and rebinding a name to a fresh object. The += operator, one sign, does both depending on the type.

a = 1
b = a          # b pointe le même int 1
b += 1         # b += 1 NE mute pas 1 : il rebind b sur un NOUVEL objet 2
print(a, b)    # 1 2 — a n'a pas bougé

Un int est immuable : on ne peut pas changer la valeur 1. Donc b += 1 ne touche pas l'objet — il crée l'objet 2 et recolle l'étiquette b dessus. a tient toujours le 1 d'origine. Rien n'a été copié : un nom a simplement changé de cible.An int is immutable: you can't change the value 1. So b += 1 doesn't touch the object — it creates the object 2 and re-sticks the label b onto it. a still holds the original 1. Nothing was copied: a name simply changed target.

Deux questions, deux opérateurs : même valeur, ou même objet ?Two questions, two operators: same value, or same object?

Pour raisonner sur les alias, il faut distinguer deux questions que le langage garde séparées. == demande « ces deux objets ont-ils la même valeur ? ». is demande « ces deux noms désignent-ils le même objet ? ». Confondre les deux, c'est le bug qui attend au tournant — surtout quand on écrit is par habitude d'un autre langage.To reason about aliases, you must split two questions the language keeps apart. == asks 'do these two objects have the same value?'. is asks 'do these two names point to the same object?'. Confusing them is the bug waiting around the corner — especially when you write is out of another language's habit.

x = [1, 2]
y = [1, 2]      # même contenu, construit séparément
print(x == y)   # True  — égalité : mêmes valeurs
print(x is y)   # False — identité : deux objets distincts

x et y ont le même contenu — == répond True. Mais ce sont deux listes construites séparément : deux objets, deux adresses. is répond False. == appelle __eq__ et peut être coûteux ; is ne compare que l'identité (id()), instantané. Presque toujours, ce que tu veux, c'est ==.x and y have the same content — == answers True. But they're two lists built separately: two objects, two addresses. is answers False. == calls __eq__ and can be costly; is only compares identity (id()), instant. Almost always, what you want is ==.

Le défaut mutable : un objet évalué une fois, partagé à jamais.The mutable default: an object evaluated once, shared forever.

On tient maintenant le réflexe « un nom, un objet ». Voici où il se paie le plus cher, dans le piège le plus célèbre de Python. La valeur par défaut d'un paramètre est un objet comme un autre — et il est créé une seule fois, quand def s'exécute, pas à chaque appel. Un défaut mutable devient un état caché qui survit entre les appels.You now hold the 'one name, one object' reflex. Here's where it costs the most, in Python's most famous trap. A parameter's default value is an object like any other — and it's created once, when def runs, not on each call. A mutable default becomes hidden state that survives across calls.

def ajouter(item, panier=[]):   # le [] est créé UNE fois, à la définition
    panier.append(item)
    return panier

print(ajouter("a"))   # ['a']
print(ajouter("b"))   # ['a', 'b'] — le même panier, d'un appel à l'autre !
print(ajouter("c"))   # ['a', 'b', 'c'] — il ne se vide jamais

Le [] n'est pas ré-évalué à chaque appel : il est construit une fois, à la lecture du def, et rangé sur la fonction (ajouter.__defaults__). Chaque appel sans argument reçoit ce même objet, qu'il mute. Le résultat s'accumule, silencieusement, entre des appels qui se croient indépendants. Ce n'est pas un crash — c'est un état qui fuit.The [] isn't re-evaluated on each call: it's built once, when the def is read, and stored on the function (ajouter.__defaults__). Every call without an argument gets that same object, and mutates it. The result piles up, silently, across calls that believe they're independent. It's not a crash — it's leaking state.