L'aliasing : un objet, plusieurs noms, un effet à distance Aliasing: one object, many names, action at a distance

Passer un objet à une fonction ne le copie pas : le paramètre devient un second nom sur le même objet. Muter cet objet en place se voit chez l'appelant ; réassigner le nom local, non. Toute la différence entre une fonction qui rend un service et une qui saccage tes données tient dans cette ligne de partage — muter, ou rebind. Passing an object to a function doesn't copy it: the parameter becomes a second name on the same object. Mutating that object in place shows in the caller; rebinding the local name doesn't. The whole difference between a function that helps and one that wrecks your data sits on that dividing line — mutate, or rebind.

Audience
Dev venant d'un langage à passage par valeur ou par référence explicite Dev from a pass-by-value or explicit-reference language
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●○○
Date
Juil 2026 Jul 2026

AliasingRéférencesFonctions

SommaireContents ·
№ 01CadrageFraming3 min

Passer un objet, c'est lui coller un second nom — pas le copier.Passing an object sticks a second name on it — it doesn't copy it.

Le Vol. I a établi qu'un nom lie un objet sans le copier. Le Vol. II en tire la conséquence qui hante le code réel : si l'assignation ne copie pas, alors plusieurs noms tiennent le même objet — et l'événement d'aliasing le plus courant, ce n'est pas b = a, c'est l'appel de fonction. Quand tu passes facture à ajouter_total, le paramètre lignes ne reçoit pas une copie : il devient un alias, un second nom sur la même liste. Muter par ce nom mute l'objet de l'appelant. Aucune ligne avec un = n'a été écrite chez lui, et pourtant sa donnée a changé.Vol. I established that a name binds an object without copying it. Vol. II draws the consequence that haunts real code: if assignment doesn't copy, then several names hold the same object — and the most common aliasing event isn't b = a, it's the function call. When you pass facture to ajouter_total, the parameter lignes doesn't receive a copy: it becomes an alias, a second name on the same list. Mutating through that name mutates the caller's object. No line with an = was written on their side, yet their data changed.

L'appel qui modifie l'appelantThe call that modifies the caller
def ajouter_total(lignes):
    lignes.append("TOTAL")     # on « ajoute juste » au paramètre
    return lignes

facture = ["A", "B"]
ajouter_total(facture)
print(facture)                 # ['A', 'B', 'TOTAL'] — facture a changé, sans =
Un objet, deux noms de part et d'autre de l'appelOne object, two names across the call
facture
chez l'appelantin the caller
lignes
dans la fonctioninside the function
⟶
même objetsame object
['A', 'B', 'TOTAL']
list · 1 objet

L'appel a exécuté, en coulisse, lignes = facture. Deux noms, un objet. lignes.append(...) mute cet objet — et facture, qui le désigne aussi, « voit » l'ajout.The call ran, behind the scenes, lignes = facture. Two names, one object. lignes.append(...) mutates that object — and facture, pointing to it too, "sees" the addition.

Le réflexe du volumeThe volume's reflex

« Qui d'autre tient une référence sur cet objet que je m'apprête à muter ? » Avant chaque .append, .sort(), obj.x = ... sur un paramètre, demande-toi combien de noms — chez l'appelant, dans une liste, ailleurs — pointent le même objet. Chacun verra ta mutation."Who else holds a reference to this object I'm about to mutate?" Before each .append, .sort(), obj.x = ... on a parameter, ask how many names — in the caller, inside a list, elsewhere — point at the same object. Each will see your mutation.

Ni par valeur, ni par référence.Neither by value, nor by reference.

Python ne passe pas l'argument « par valeur » (une copie, comme un int en C) ni « par référence » (un alias du nom, comme un & en C++). Il passe par assignation : le paramètre est lié au même objet que l'argument. On appelle ça call by sharing. Toute la suite du numéro déplie ce que ça implique.Python passes the argument neither 'by value' (a copy, like an int in C) nor 'by reference' (an alias of the name, like a & in C++). It passes by assignment: the parameter is bound to the same object as the argument. This is called call by sharing. The rest of the issue unfolds what it implies.

№ 02La surpriseThe surprise4 min

Deux lignes qui se ressemblent. L'une remonte chez l'appelant, l'autre non.Two lines that look alike. One reaches the caller, the other doesn't.

Voici la ligne de partage de tout le volume, et elle est fine. À l'intérieur d'une fonction, tu peux faire deux choses à un paramètre. Muter l'objet en place — .append, .sort(), lst[0] = ... — agit sur l'objet que l'appelant tient encore : il le verra. Réassigner le nom local — lst = ... — ne touche pas à l'objet : il détache l'étiquette locale et la recolle ailleurs, sans que l'appelant en sache rien. Même variable, même fonction, effets opposés selon que tu écris sur l'objet ou sur le nom.Here is the whole volume's dividing line, and it's thin. Inside a function, you can do two things to a parameter. Mutating the object in place — .append, .sort(), lst[0] = ... — acts on the object the caller still holds: they'll see it. Reassigning the local name — lst = ... — doesn't touch the object: it detaches the local label and re-sticks it elsewhere, with the caller none the wiser. Same variable, same function, opposite effects depending on whether you write to the object or to the name.

Muter l'objet — l'appelant le partageMutate the object — the caller shares it
def travailler(lst):
    lst.append(99)      # MUTER l'objet en place
    print(lst)          # [1, 2, 99]

data = [1, 2]
travailler(data)
print(data)             # [1, 2, 99] — l'appelant voit le changement

lst.append(99) écrit dans l'objet. Or data et lst sont deux noms sur ce même objet : la mutation est un fait du monde, pas du nom. data la voit forcément. Tout ce qui modifie l'objet en place traverse la frontière de la fonction — c'est le canal des effets de bord voulus… et des accidents.lst.append(99) writes into the object. But data and lst are two names on that same object: the mutation is a fact of the world, not of the name. data necessarily sees it. Anything that modifies the object in place crosses the function boundary — the channel for intended side effects… and accidents.

Écrire dans l'objet traverse la fonction. Écrire sur le nom reste dedans. Muter remonte ; rebind ne remonte pas.Writing to the object crosses the function. Writing to the name stays in. Mutating propagates; rebinding doesn't.
№ 03La mécaniqueThe mechanics5 min

« Call by sharing » : l'appel exécute un paramètre = argument caché."Call by sharing": the call runs a hidden parameter = argument.

La mécanique est plus simple que ses trois noms savants. Au moment de l'appel, Python lie chaque paramètre à l'objet de l'argument correspondant — exactement comme une assignation param = arg. Rien n'est copié : à l'entrée de la fonction, param is arg est vrai, les deux noms désignent le même objet, au même id(). À partir de là, tout ce que tu sais du Vol. I s'applique tel quel : muter l'objet se voit partout, rebind le nom ne se voit que localement. « Call by sharing » ne dit rien de plus que ça.The mechanics are simpler than their three learned names. At call time, Python binds each parameter to the corresponding argument's object — exactly like an assignment param = arg. Nothing is copied: on entry, param is arg is true, both names point at the same object, at the same id(). From there, everything you know from Vol. I applies unchanged: mutating the object shows everywhere, rebinding the name shows only locally. 'Call by sharing' says nothing more than that.

param is arg — vrai, avant toute mutationparam is arg — true, before any mutation
def inspecter(lst):
    print(lst is data)      # True — le paramètre EST l'objet de l'appelant
    print(id(lst) == id_ext)

data = [1, 2]
id_ext = id(data)
inspecter(data)             # l'appel a fait, en douce : lst = data

Pas de copie à la frontière : lst is data répond True, et les id() coïncident. Le paramètre n'est pas « une référence au nom data » — c'est un nom neuf lié au même objet. La nuance compte : c'est pourquoi rebind lst laisse data tranquille (chapitre suivant du toggle), alors qu'un vrai passage par référence, lui, propagerait le rebind.No copy at the boundary: lst is data answers True, and the id()s match. The parameter isn't "a reference to the name data" — it's a fresh name bound to the same object. The nuance matters: it's why rebinding lst leaves data alone (next toggle), whereas true pass-by-reference would propagate the rebind.

Le réflexe en une ligneThe reflex in one line

Lis chaque appel f(x) comme un param = x silencieux. Le lien avec l'appelant tient à l'objet partagé — il survit à la mutation, il meurt au rebind.Read every call f(x) as a silent param = x. The link to the caller runs through the shared object — it survives mutation, it dies at rebind.

№ 04Le piègeThe trap4 min

La fonction qui « lit » tes données et les réordonne à ton insu.The function that "reads" your data and reorders it behind your back.

L'effet de bord à distance, c'est quand une fonction modifie un objet que l'appelant croyait seulement lui prêter pour lecture. top3 a l'air pur : donne-moi des scores, je te rends les trois meilleurs. Mais .sort() mute la liste reçue — donc l'aliasing du chapitre 1 fait remonter le tri jusqu'à classement, qui se retrouve réordonné sans qu'on l'ait demandé. Le bug ne se voit pas dans top3 ; il se manifeste dix lignes plus loin, chez un appelant qui utilise classement en le croyant intact.Action at a distance is when a function modifies an object the caller thought they were merely lending for reading. top3 looks pure: give me scores, I'll return the top three. But .sort() mutates the received list — so chapter 1's aliasing carries the sort back to classement, which ends up reordered unasked. The bug doesn't show in top3; it surfaces ten lines later, in a caller who uses classement believing it untouched.

.sort() mute — le tri remonte à l'appelant.sort() mutates — the sort reaches the caller
def top3(scores):
    scores.sort(reverse=True)   # .sort() mute la liste EN PLACE
    return scores[:3]

classement = [40, 10, 90, 30]
meilleurs = top3(classement)
print(meilleurs)                # [90, 40, 30]
print(classement)               # [90, 40, 30, 10] — RÉORDONNÉ à distance !

scores est un alias de classement (chapitre 1). .sort() ne renvoie rien : elle réordonne l'objet en place. Le tri est donc un fait de l'objet partagé — classement le subit. Pire : la fonction paraît innocente car elle retourne une valeur, ce qui masque qu'elle a aussi un effet de bord. Une fonction qui mute son entrée sans le dire est un piège tendu à son propre appelant.scores is an alias of classement (chapter 1). .sort() returns nothing: it reorders the object in place. So the sort is a fact of the shared object — classement suffers it. Worse: the function looks innocent because it returns a value, hiding that it also has a side effect. A function that mutates its input silently is a trap set for its own caller.

Le contre-exempleThe counter-example

Mais muter l'entrée n'est pas toujours un péché. list.sort(), random.shuffle(lst), dict.update(...) existent exprès : muter en place évite d'allouer une copie, parfois cruciale sur de gros volumes. Le partage n'est pas le bug — le bug, c'est le partage tu. Une mutation d'entrée annoncée dans le nom et la doc est un outil ; la même, silencieuse sous une signature qui « rend une valeur », est un traquenard.But mutating the input isn't always a sin. list.sort(), random.shuffle(lst), dict.update(...) exist on purpose: mutating in place avoids allocating a copy, sometimes crucial on large data. Sharing isn't the bug — the bug is the unspoken sharing. An input mutation announced in the name and docs is a tool; the same, silent under a signature that "returns a value", is an ambush.

Copier au bord, ou renvoyer du neuf.Copy at the edge, or return the new.

Deux disciplines suffisent à éteindre presque tous les effets à distance. Soit tu copies l'entrée dès l'arrivée et tu mutes la copie. Soit tu ne mutes rien et tu renvoies un objet neuf. Le coût de cette copie — de surface ou profonde — est précisément le sujet du prochain numéro.Two disciplines put out almost all action-at-a-distance. Either you copy the input on arrival and mutate the copy. Or you mutate nothing and return a fresh object. The cost of that copy — shallow or deep — is exactly the next issue's subject.

Une fonction qui mute son argument sans le nommer écrit dans le passé de son appelant. Le retour de valeur ne l'innocente pas.A function that mutates its argument without naming it writes into its caller's past. Returning a value doesn't clear it.
№ 05Bilan & éditoWrap-up & editorial2 min

Quatre réflexes pour muter sans blesser l'appelant.Four reflexes to mutate without hurting the caller.

Le Vol. I disait « un nom lie un objet ». Le Vol. II ajoute la question qui décide de la sûreté de ton code : qui d'autre tient ce même objet ? L'appel de fonction est la réponse la plus fréquente — le paramètre est un alias de l'argument. Dès lors, tout tient à un choix : écrire dans l'objet (ça remonte) ou sur le nom (ça reste). Nomme ce choix, et l'effet de bord à distance disparaît de ton code.Vol. I said 'a name binds an object'. Vol. II adds the question that decides your code's safety: who else holds that same object? The function call is the most frequent answer — the parameter aliases the argument. From there, everything hinges on one choice: write to the object (it propagates) or to the name (it stays). Name that choice, and action at a distance leaves your code.

Tu veux…You want to…Le gesteThe moveCe que ça coûteWhat it costs
Modifier pour l'appelantModify for the callerMuter en place : lst.append, lst.sort(), d.update(...).Mutate in place: lst.append, lst.sort(), d.update(...).L'effet remonte à TOUS les noms de l'objet. À réserver à un contrat explicite (nom parlant, retour None).The effect reaches ALL names of the object. Reserve for an explicit contract (telling name, None return).
Ne rien changer dehorsChange nothing outsideRebind le nom local, ou renvoie du neuf : x = sorted(x), return [...].Rebind the local name, or return fresh: x = sorted(x), return [...].Une allocation de plus. Presque toujours le bon défaut : une fonction qui ne surprend personne.One extra allocation. Almost always the right default: a function that surprises no one.
Muter une entrée sans fuiteMutate an input without leakCopier à la frontière : x = list(x) en tête de fonction, puis muter la copie.Copy at the boundary: x = list(x) at the top, then mutate the copy.La copie de surface partage encore les éléments internes — vrai/faux abri selon l'imbrication. Vol 2 · №05.A shallow copy still shares inner elements — real/false shelter depending on nesting. Vol 2 · №05.
Savoir si ça remonteKnow if it propagatesDemande : j'écris dans l'objet (remonte) ou sur le nom (local) ? is tranche.Ask: am I writing to the object (propagates) or the name (local)? is settles it.Le piège += : sur un mutable il mute (remonte), sur un immuable il rebind (local). № 02.The += trap: on a mutable it mutates (propagates), on an immutable it rebinds (local). № 02.
Un paramètre n'est pas une copie polie de ton argument. C'est ton argument, sous un autre nom.A parameter isn't a polite copy of your argument. It is your argument, under another name.
Mot de l'éditeurFrom the editor

La frontière d'une fonction ne protège rien.A function's boundary protects nothing.

On aime croire qu'appeler une fonction met nos données à l'abri derrière une paroi : elle travaille sur « sa » version, on récupère un résultat, notre original dort tranquille. En Python, cette paroi n'existe pas. Le paramètre et l'argument sont deux noms sur le même objet, et la seule chose qui décide si l'appel touche ton monde, c'est ce que la fonction fait — muter l'objet, ou rebind son nom. Le langage ne te met aucun garde-fou : il te fait confiance pour savoir ce que tu partages. C'est la même confiance que partout ailleurs — simple en surface, à ta charge au runtime.We like to believe that calling a function puts our data safe behind a wall: it works on 'its' version, we get a result back, our original sleeps soundly. In Python, that wall doesn't exist. The parameter and the argument are two names on the same object, and the only thing deciding whether the call touches your world is what the function does — mutate the object, or rebind its name. The language gives you no guard: it trusts you to know what you're sharing. It's the same trust as everywhere else — simple on the surface, on you at runtime.

Prochain numéro : copier, et ce que ça coûte. Puisque la parade à l'aliasing est souvent « copie d'abord », il faut savoir ce qu'une copie copie vraiment. list(x) et x[:] dupliquent le contenant mais partagent encore les éléments — la copie de surface. copy.deepcopy descend récursivement — cycles compris, grâce à un mémo — mais à un prix. Surface contre profondeur : la deuxième moitié du Vol. II.Next issue: copying, and what it costs. Since the counter to aliasing is often 'copy first', you must know what a copy actually copies. list(x) and x[:] duplicate the container but still share the elements — the shallow copy. copy.deepcopy descends recursively — cycles included, thanks to a memo — but at a price. Shallow versus deep: the second half of Vol. II.