copy contre deepcopy : ce qu'une copie copie vraiment copy versus deepcopy: what a copy actually copies

« Copie d'abord » est la parade à l'aliasing — encore faut-il savoir ce qu'on duplique. list(x), x[:], dict(x) clonent le contenant mais partagent encore les éléments : la copie de surface. copy.deepcopy descend récursivement et isole tout, à un prix — et souvent pour rien. Entre les deux, la juste dose se choisit, elle ne se subit pas. 'Copy first' is the counter to aliasing — provided you know what you're duplicating. list(x), x[:], dict(x) clone the container but still share the elements: the shallow copy. copy.deepcopy descends recursively and isolates everything, at a price — often for nothing. Between the two, the right dose is chosen, not suffered.

Audience
Dev qui a vu l'aliasing et cherche à isoler ses données proprement Dev who has seen aliasing and wants to isolate data cleanly
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●○○
Date
Juil 2026 Jul 2026

CopiesAliasingdeepcopy

SommaireContents ·
№ 01CadrageFraming3 min

Une copie a deux niveaux. Presque tous n'en clonent qu'un.A copy has two levels. Almost all of them clone only one.

Au numéro précédent, la parade à l'aliasing était « copie avant de muter ». Bonne règle — mais elle rouvre aussitôt une question qu'on croyait réglée : quand tu écris list(grille), qu'est-ce qui est copié, au juste ? Le contenant, oui : tu obtiens une nouvelle liste, indépendante à son niveau. Mais ses éléments — ici les sous-listes — ne sont pas clonés : la copie pointe les mêmes objets internes que l'original. Copier n'est pas un geste atomique. C'est une profondeur, et par défaut cette profondeur vaut un.In the previous issue, the counter to aliasing was 'copy before you mutate'. Good rule — but it reopens a question we thought settled: when you write list(grille), what exactly gets copied? The container, yes: you get a new list, independent at its level. But its elements — here the sub-lists — aren't cloned: the copy points at the same inner objects as the original. Copying isn't an atomic act. It's a depth, and by default that depth is one.

La copie qui ne protège pas l'intérieurThe copy that doesn't protect the inside
grille = [[1, 2], [3, 4]]
copie = list(grille)      # « je copie la grille » — un nouveau contenant
copie[0].append(99)       # je ne touche « que » la copie
print(grille)             # [[1, 2, 99], [3, 4]] — l'original a changé aussi
Deux niveaux, une seule frontière clonéeTwo levels, only one boundary cloned
grille
copie
⟶
contenants distinctsdistinct containers
[1, 2] ← partagé
[3, 4] ← partagé

grille et copie sont deux listes différentes — mais elles pointent les mêmes sous-listes. Muter une sous-liste par l'une se voit par l'autre. La copie a dédoublé le premier étage, pas le second.grille and copie are two different lists — but they point at the same sub-lists. Mutating a sub-list through one shows through the other. The copy duplicated the first floor, not the second.

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

Avant de te fier à une copie, demande : jusqu'où descend-elle ? Si tu ne mutes que le contenant (ajouter/retirer un élément), une copie de surface suffit. Si tu mutes ce qu'il y a dedans, la copie de surface est un abri en carton — l'original le sentira.Before trusting a copy, ask: how deep does it go? If you only mutate the container (add/remove an element), a shallow copy is enough. If you mutate what's inside, the shallow copy is a cardboard shelter — the original will feel it.

Où l'on en est dans le Vol. II.Where we are in Vol. II.

Le №04 a nommé l'aliasing : un objet, plusieurs noms. Ce numéro outille la parade — copier — et en montre la vraie forme : une profondeur à choisir. Le №06 refermera le volume sur le cas le plus piégeux de copie de surface, le slicing d'une grille.№04 named aliasing: one object, many names. This issue tools the counter — copying — and shows its true shape: a depth to choose. №06 will close the volume on the trickiest shallow-copy case, slicing a grid.

№ 02La surpriseThe surprise4 min

La copie de surface : indépendante dessus, complice dessous.The shallow copy: independent on top, complicit underneath.

Tous les gestes de copie « simples » de Python — list(x), x[:], x.copy(), dict(x), set(x) — font la même chose : une copie de surface. Ils allouent un nouveau contenant et y rangent les mêmes références que l'original. Résultat en deux temps. Au premier niveau, tu es libre : ajouter, retirer, réordonner dans la copie ne touche pas l'original. Au second, tu es piégé : chaque élément est un objet partagé, et le muter se voit des deux côtés. La copie de surface protège le contenant, jamais le contenu.Every 'simple' copy move in Python — list(x), x[:], x.copy(), dict(x), set(x) — does the same thing: a shallow copy. They allocate a new container and store the same references as the original. A two-part result. At the first level, you're free: adding, removing, reordering in the copy doesn't touch the original. At the second, you're trapped: each element is a shared object, and mutating it shows on both sides. The shallow copy protects the container, never the content.

Muter le contenant — l'original ne bouge pasMutate the container — the original stays put
old = [1, 2, 3]
new = list(old)          # ou old[:], ou old.copy()
new.append(4)            # on touche le CONTENANT de new
print(old)               # [1, 2, 3] — old intact
print(new is old)        # False — deux listes bien distinctes

new.append(4) agit sur le contenant de new, qui est bien distinct : new is old est False. Ajouter, retirer, trier new laisse old tranquille. Pour une liste plate d'immuables (int, str), la copie de surface est une vraie copie — parce qu'il n'y a rien de mutable à partager en dessous.new.append(4) acts on new's container, which is genuinely distinct: new is old is False. Adding, removing, sorting new leaves old alone. For a flat list of immutables (int, str), the shallow copy is a real copy — because there's nothing mutable to share underneath.

Une copie de surface duplique la boîte, jamais ce qu'elle contient. Ses éléments restent des alias de l'original.A shallow copy duplicates the box, never what it holds. Its elements stay aliases of the original.
№ 03La mécaniqueThe mechanics5 min

deepcopy descend jusqu'au fond — et se souvient de ce qu'il a déjà cloné.deepcopy descends all the way — and remembers what it already cloned.

Le module copy nomme les deux profondeurs. copy.copy fait une copie de surface — le même résultat que list(x) ou x[:], un seul niveau. copy.deepcopy fait une copie profonde : il clone le contenant, puis chacun de ses éléments, puis les éléments de ceux-ci, récursivement, jusqu'aux objets immuables du fond. Le résultat est un arbre entièrement neuf, sans aucune référence commune avec l'original. Et il est plus malin qu'une simple récursion : un mémo interne retient chaque objet déjà copié, pour préserver le partage voulu et ne pas boucler sur les cycles.The copy module names both depths. copy.copy makes a shallow copy — the same result as list(x) or x[:], a single level. copy.deepcopy makes a deep copy: it clones the container, then each of its elements, then those elements' elements, recursively, down to the immutable objects at the bottom. The result is an entirely fresh tree, with no reference in common with the original. And it's smarter than plain recursion: an internal memo remembers each already-copied object, to preserve intended sharing and avoid looping on cycles.

copy.copy — le même demi-abri qu'au chapitre 2copy.copy — the same half-shelter as chapter 2
import copy
old = [[1], [2]]
new = copy.copy(old)       # copie de surface, exactement comme list(old)
print(new[0] is old[0])    # True — un seul niveau cloné

copy.copy(old) n'apporte rien de plus que list(old) : un contenant neuf, les mêmes éléments. new[0] is old[0] reste True. Son intérêt est d'être générique — il marche sur n'importe quel type, là où x[:] est propre aux séquences. Mais la profondeur, elle, est toujours de un.copy.copy(old) brings nothing more than list(old): a fresh container, the same elements. new[0] is old[0] stays True. Its value is being generic — it works on any type, where x[:] is specific to sequences. But the depth is still one.

Le réflexe en une ligneThe reflex in one line

Surface = un étage cloné, le reste partagé. Profondeur = tout l'arbre recloné, rien de partagé avec l'original. La bonne copie est celle dont la profondeur épouse ce que tu vas muter.Shallow = one floor cloned, the rest shared. Deep = the whole tree re-cloned, nothing shared with the original. The right copy is the one whose depth matches what you'll mutate.

№ 04Le réflexe de tropOne reflex too far4 min

deepcopy par réflexe : tu paies tout l'arbre pour muter une feuille.deepcopy by reflex: you pay for the whole tree to mutate one leaf.

deepcopy résout si bien le problème du chapitre 2 qu'il devient un réflexe — et c'est là qu'il se retourne. Il recopie tout ce qui est atteignable depuis l'objet : sur une grosse structure, c'est un million d'allocations pour se protéger d'une mutation qui n'en concernait qu'une poignée. Pire, il clone aussi ce que tu partageais exprès — un cache, un objet de config commun — et rompt des liens que tu croyais tenir. Et sur des objets à ressource (fichier ouvert, verrou, connexion), la copie profonde n'a souvent aucun sens, quand elle ne casse pas. « Isoler à fond » n'est pas gratuit ; c'est même rarement ce dont tu as besoin.deepcopy solves chapter 2's problem so well that it becomes a reflex — and that's where it backfires. It re-copies everything reachable from the object: on a large structure, that's a million allocations to guard against a mutation touching only a handful. Worse, it also clones what you shared on purpose — a cache, a common config object — and breaks links you thought you held. And on resource-bearing objects (open file, lock, connection), a deep copy often makes no sense, when it doesn't break. 'Isolate fully' isn't free; it's rarely even what you need.

Tout recopier — coûteux, et parfois fauxRe-copy everything — costly, sometimes wrong
import copy

# 1) Le prix : deepcopy recopie CHAQUE objet atteignable, récursivement
gros = [list(range(1000)) for _ in range(1000)]   # 1 000 000 d'entiers
_ = copy.deepcopy(gros)     # alloue un million d'objets — lent, gourmand

# 2) La surprise : il clone aussi ce qu'on ne voulait pas dupliquer
noeud = {"parent": None, "cache_partage": gros}
copie = copy.deepcopy(noeud)      # le cache « partagé » ne l'est plus
print(copie["cache_partage"] is gros)   # False — lien commun rompu

Deux prix, distincts. Le premier est le temps et la mémoire : deepcopy est proportionnel à la taille totale du graphe, pas à ce que tu comptes muter. Le second est sémantique : en clonant tout, il détruit le partage volontaire — deux noms qui devaient rester sur le même objet se retrouvent sur deux copies. deepcopy ne connaît pas ton intention ; il isole aveuglément.Two distinct prices. The first is time and memory: deepcopy is proportional to the total graph size, not to what you plan to mutate. The second is semantic: by cloning everything, it destroys intended sharing — two names meant to stay on one object end up on two copies. deepcopy doesn't know your intent; it isolates blindly.

Éviter la copie tout courtAvoiding the copy entirely

La meilleure copie est parfois celle qu'on n'écrit pas. Si une structure n'a pas à changer, rends-la immuable — tuple, frozenset, @dataclass(frozen=True) — et le problème du partage disparaît : plus rien à isoler, puisque plus rien ne mute. L'immuabilité est la copie gratuite.The best copy is sometimes the one you don't write. If a structure needn't change, make it immutable — tuple, frozenset, @dataclass(frozen=True) — and the sharing problem vanishes: nothing to isolate, since nothing mutates. Immutability is the free copy.

deepcopy est un aveu d'imbrication mutable.deepcopy is a confession of mutable nesting.

Si tu te surprends à écrire deepcopy « pour être tranquille », demande-toi pourquoi ta structure est à la fois profonde et mutable partout. Souvent, la vraie réponse n'est pas une copie plus grosse : c'est une frontière d'immuabilité au bon endroit, ou une fonction qui renvoie du neuf plutôt que de muter.If you catch yourself writing deepcopy 'just to be safe', ask why your structure is both deep and mutable all the way down. Often the real answer isn't a bigger copy: it's an immutability boundary in the right place, or a function that returns new instead of mutating.

La bonne copie n'est ni la plus superficielle ni la plus profonde. C'est celle dont la profondeur s'arrête exactement où s'arrête ta mutation.The right copy is neither the shallowest nor the deepest. It's the one whose depth stops exactly where your mutation stops.
№ 05Bilan & éditoWrap-up & editorial2 min

Quatre profondeurs de copie, une seule bonne à chaque fois.Four copy depths, only one right each time.

Copier n'est pas un bouton on/off, c'est un curseur. La copie de surface duplique le contenant et partage le contenu ; la copie profonde clone tout l'arbre, à son prix. Entre les deux, la copie ciblée — un niveau de plus, là où tu mutes — est presque toujours la juste réponse, et l'immuabilité rend la question sans objet. Choisis la profondeur ; ne la subis pas.Copying isn't an on/off switch, it's a dial. The shallow copy duplicates the container and shares the content; the deep copy clones the whole tree, at its price. Between them, the targeted copy — one level more, where you mutate — is almost always the right answer, and immutability makes the question moot. Choose the depth; don't suffer it.

Ce que tu mutes…What you mutate…La copie justeThe right copyCe que ça coûte / le piègeCost / the trap
Le contenant seulThe container onlyCopie de surface : list(x), x[:], dict(x), copy.copy(x).Shallow copy: list(x), x[:], dict(x), copy.copy(x).Les éléments restent partagés. Sûr seulement si le contenu est immuable ou qu'on n'y touche pas.Elements stay shared. Safe only if the content is immutable or untouched.
Un niveau imbriqué précisA specific nested levelCopie ciblée : [row[:] for row in grille] — un étage de plus, bon marché.Targeted copy: [row[:] for row in grille] — one floor more, cheap.Il faut savoir jusqu'où tu mutes. En échange, tu ne paies que ce niveau, pas tout l'arbre.You must know how deep you mutate. In return, you pay only that level, not the whole tree.
Tout l'arbre, à toute profondeurThe whole tree, any depthcopy.deepcopy(x) — clone récursif, partage interne préservé, cycles gérés.copy.deepcopy(x) — recursive clone, internal sharing preserved, cycles handled.Coûteux (proportionnel au graphe entier) et aveugle : il casse le partage voulu et bute sur les ressources.Costly (proportional to the whole graph) and blind: it breaks intended sharing and chokes on resources.
Rien — ça ne doit pas changerNothing — it mustn't changeRends-le immuable : tuple, frozenset, @dataclass(frozen=True).Make it immutable: tuple, frozenset, @dataclass(frozen=True).Zéro copie, zéro aliasing dangereux. L'immuabilité est la copie gratuite (№ 02).Zero copy, zero dangerous aliasing. Immutability is the free copy (№ 02).
« Je copie » n'est pas une phrase complète. La vraie question, c'est « jusqu'où ? » — et la réponse, c'est « jusqu'où je mute »."I'll copy it" is not a complete sentence. The real question is "how deep?" — and the answer is "as deep as I mutate".
Mot de l'éditeurFrom the editor

Copier, c'est déjà répondre à « qui doit voir quoi ».To copy is already to answer "who should see what".

On croit copier pour « se protéger », comme on mettrait un objet sous verre. Mais une copie n'est pas neutre : chaque niveau qu'elle clone est un lien qu'elle coupe, et chaque niveau qu'elle partage est un lien qu'elle garde. Décider de la profondeur d'une copie, c'est décider qui, dans ton programme, verra les futures mutations, et qui en sera épargné. deepcopy n'est pas « la copie sûre » : c'est le choix de tout couper, y compris ce que tu voulais garder ensemble. Le langage ne tranche pas à ta place — il te donne un curseur et te fait confiance pour savoir jusqu'où descendre.We think we copy to 'protect ourselves', like putting an object under glass. But a copy isn't neutral: each level it clones is a link it cuts, and each level it shares is a link it keeps. Deciding a copy's depth is deciding who, in your program, will see future mutations, and who will be spared them. deepcopy isn't 'the safe copy': it's the choice to cut everything, including what you wanted to keep together. The language won't decide for you — it hands you a dial and trusts you to know how deep to go.

Prochain numéro, on ferme le Vol. II sur le cas de copie de surface le plus traître : le slicing. sous = grille[:] a l'air d'une copie franche, et c'en est une — d'un seul niveau. Sur une grille, une matrice, une liste de listes, ce [:] rassure à tort : les lignes restent partagées, et un sous[0].append() rejaillit sur la grille d'origine. Le slicing copie le contenant, jamais le contenu.Next issue closes Vol. II on the most treacherous shallow-copy case: slicing. sub = grid[:] looks like an honest copy, and it is one — of a single level. On a grid, a matrix, a list of lists, that [:] falsely reassures: the rows stay shared, and a sub[0].append() splashes back onto the original grid. Slicing copies the container, never the content.