Le slicing copie le contenant, jamais le contenu Slicing copies the container, never the content

sous = grille[:] a tout d'une copie franche : le crochet vide dit « tout, en neuf ». C'en est une — d'un seul niveau. Sur une liste de listes, les lignes restent partagées, et un sous[0].append() rejaillit sur l'original. Pire, [[0]*3]*3 fabrique trois noms sur une même ligne. Et l'affectation de tranche a[:] = X ne copie rien : elle mute l'objet en place, sous tous ses alias. sub = grid[:] looks every bit an honest copy: the empty bracket says 'all of it, fresh'. It is one — of a single level. On a list of lists, the rows stay shared, and a sub[0].append() splashes back onto the original. Worse, [[0]*3]*3 makes three names for one row. And slice assignment a[:] = X copies nothing: it mutates the object in place, under all its aliases.

Audience
Dev qui manipule des listes de listes, grilles et matrices Dev handling lists of lists, grids and matrices
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●○○
Date
Juil 2026 Jul 2026

SlicingCopiesAliasing

SommaireContents ·
№ 01CadrageFraming3 min

Le crochet vide dit « tout ». Il ne copie qu'un étage.The empty bracket says "everything". It copies one floor.

Le numéro précédent a établi qu'une copie a une profondeur. Voici l'idiome qui le fait oublier le plus vite : grille[:]. Le crochet vide se lit « la grille entière, en neuf » — il donne une telle impression de totalité qu'on ne pense pas à la profondeur. Or slicing une liste produit une copie de surface, exactement comme list(x) : un contenant neuf, les mêmes éléments. Sur une liste de listes, les lignes ne sont pas dupliquées — elles sont partagées. Le [:] a l'air du geste le plus franc de Python ; c'est l'un des plus trompeurs.The previous issue established that a copy has a depth. Here's the idiom that makes you forget it fastest: grid[:]. The empty bracket reads 'the whole grid, fresh' — it gives such an impression of totality that depth never comes to mind. Yet slicing a list produces a shallow copy, exactly like list(x): a fresh container, the same elements. On a list of lists, the rows aren't duplicated — they're shared. The [:] looks like Python's most honest move; it's one of its most deceptive.

La « copie » qui laisse fuir les lignesThe 'copy' that lets the rows leak
grille = [[1, 2], [3, 4]]
sous = grille[:]           # « une copie complète de la grille » — vraiment ?
sous[0].append(99)         # je mute une ligne de la copie
print(grille)              # [[1, 2, 99], [3, 4]] — la grille d'origine a changé
Deux contenants, des lignes en communTwo containers, rows in common
grille
sous = grille[:]
⟶
contenants distinctsdistinct containers
[1, 2, 99] ← partagée
[3, 4] ← partagée

grille[:] a bien créé une nouvelle liste externe — mais elle range dedans les mêmes lignes. sous[0] et grille[0] sont un seul objet ; l'append sur l'un se lit sur l'autre.grille[:] did create a new outer list — but it stores the same rows inside. sous[0] and grille[0] are one object; the append on one reads on the other.

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

Ne lis jamais [:] comme « copie profonde ». Lis-le comme « nouveau contenant, mêmes éléments ». Sur une liste plate d'immuables, c'est une vraie copie ; dès qu'il y a un niveau mutable dessous — lignes, dicts, objets — [:] ne protège que la coquille.Never read [:] as "deep copy". Read it as "new container, same elements". On a flat list of immutables it's a real copy; as soon as there's a mutable level underneath — rows, dicts, objects — [:] protects only the shell.

Le numéro qui ferme le Vol. II.The issue that closes Vol. II.

Trois numéros, une seule idée déclinée : l'aliasing (№04, un objet plusieurs noms), la copie et sa profondeur (№05), et ici la forme la plus familière de copie de surface. Le slicing cache aussi une seconde vie — l'affectation de tranche — qui, elle, ne copie pas du tout mais mute en place. On y arrive au chapitre 3.Three issues, one idea in variations: aliasing (№04, one object many names), copying and its depth (№05), and here the most familiar form of shallow copy. Slicing also hides a second life — slice assignment — which copies nothing at all but mutates in place. We reach it in chapter 3.

№ 02La surpriseThe surprise4 min

La tranche partage ses éléments. La multiplication, elle, les fond en un seul.The slice shares its elements. Multiplication fuses them into one.

Deux gestes de séquence, deux façons de se faire piéger par le partage. Le slicing d'abord : grille[:] comme grille[0:1] renvoie un contenant neuf rempli des mêmes références — la copie de surface, déjà vue, mais qu'on oublie derrière la syntaxe des crochets. Puis la répétition : [ligne] * 3 ne fabrique pas trois lignes, il range trois fois la même référence. [[0]*3]*3 n'est donc pas une grille 3×3 : c'est une seule ligne, vue par trois cases. Muter l'une les mute toutes.Two sequence moves, two ways to get trapped by sharing. Slicing first: grid[:] like grid[0:1] returns a fresh container filled with the same references — the shallow copy, already seen, but forgotten behind the bracket syntax. Then repetition: [row] * 3 doesn't make three rows, it stores the same reference three times. [[0]*3]*3 is therefore not a 3×3 grid: it's a single row, seen through three slots. Mutate one, you mutate them all.

Toute tranche partage ses élémentsAny slice shares its elements
grille = [[1, 2], [3, 4]]
sous = grille[:]
print(sous is grille)          # False — nouveau contenant externe
print(sous[0] is grille[0])    # True  — MÊME première ligne

partiel = grille[0:1]          # une tranche partielle ne change rien à l'affaire
print(partiel[0] is grille[0]) # True  — elle partage aussi ses éléments

Le contenant est neuf — sous is grille est False — mais chaque case pointe l'objet d'origine : sous[0] is grille[0] est True. Une tranche partielle, grille[0:1], obéit à la même règle : elle recopie des références, jamais les objets au bout. Slicer, c'est choisir des cases et les copier ; ça n'a jamais rien dit de leur contenu.The container is fresh — sous is grille is False — but each slot points at the original object: sous[0] is grille[0] is True. A partial slice, grille[0:1], obeys the same rule: it copies references, never the objects at their end. Slicing is picking slots and copying them; it never said a thing about their content.

Slicer copie des cases ; multiplier duplique une référence. Ni l'un ni l'autre ne touche à ce qui vit au bout.Slicing copies slots; multiplying duplicates a reference. Neither touches what lives at the end.
№ 03La mécaniqueThe mechanics5 min

Le même [:] : à droite il copie, à gauche il mute en place.The same [:]: on the right it copies, on the left it mutates in place.

Le slicing mène une double vie, selon le côté du signe égal. À droite — b = a[:] — c'est une lecture : il produit une copie de surface, un objet neuf. À gauche — a[:] = [9, 8] — c'est une affectation de tranche : il ne crée rien, il remplace le contenu de la liste existante, sur place. La distinction est exactement celle du №04, muter contre rebind, mais glissée dans une seule syntaxe. a[:] = X mute l'objet (tous ses alias le voient) ; a = X rebind le nom (personne d'autre ne bouge).Slicing leads a double life, depending on the side of the equals sign. On the right — b = a[:] — it's a read: it produces a shallow copy, a fresh object. On the left — a[:] = [9, 8] — it's a slice assignment: it creates nothing, it replaces the contents of the existing list, in place. The distinction is exactly №04's, mutate versus rebind, but slipped into one syntax. a[:] = X mutates the object (all its aliases see it); a = X rebinds the name (nobody else moves).

Lecture — un objet neuf, l'original tranquilleRead — a fresh object, the original left alone
a = [1, 2, 3]
b = a[:]             # à DROITE du =, [:] LIT : une copie de surface
print(b is a)        # False — b est un nouvel objet
b.append(4)
print(a)             # [1, 2, 3] — a intact

À droite du =, a[:] évalue une expression : il construit une nouvelle liste avec les mêmes éléments. b is a est False, et b.append(4) ne touche pas a. C'est la copie de surface des chapitres précédents, écrite avec des crochets. Rien de neuf ici — sauf qu'on va voir le même symbole faire l'inverse.On the right of the =, a[:] evaluates an expression: it builds a new list with the same elements. b is a is False, and b.append(4) doesn't touch a. It's the previous chapters' shallow copy, written with brackets. Nothing new here — except we're about to see the same symbol do the opposite.

Le réflexe en une ligneThe reflex in one line

a[:] à droite d'un = fabrique une copie ; a[:] à gauche vide et remplit l'objet en place. Regarde de quel côté du signe se trouve la tranche.a[:] on the right of an = builds a copy; a[:] on the left empties and refills the object in place. Look at which side of the sign the slice is on.

№ 04Le piègeThe trap4 min

La grille : deux façons de la rater, une compréhension pour la réussir.The grid: two ways to get it wrong, one comprehension to get it right.

Les deux pièges du numéro se rejoignent sur l'objet le plus courant : la grille, la matrice, la liste de listes. On la « copie » avec grille[:] et les lignes fuient ; on la « construit » avec [[0]*3]*3 et les lignes sont fusionnées. Même racine — le partage d'un niveau imbriqué — et même remède : produire une ligne neuve pour chaque position, ce que fait une compréhension de liste. row[:] pour copier, [0]*3 dans un for pour construire. La compréhension itère, donc elle réévalue, donc chaque ligne est un objet distinct.The issue's two traps meet on the most common object: the grid, the matrix, the list of lists. You 'copy' it with grid[:] and the rows leak; you 'build' it with [[0]*3]*3 and the rows are fused. Same root — sharing a nested level — and same cure: produce a fresh row for each position, which a list comprehension does. row[:] to copy, [0]*3 inside a for to build. The comprehension iterates, so it re-evaluates, so each row is a distinct object.

Deux idiomes, un même partage de lignesTwo idioms, the same shared rows
# Faux abri n°1 : « copier » une grille avec une tranche
grille = [[1, 2], [3, 4]]
sous = grille[:]                 # lignes partagées — piège du ch.1
sous[0].append(99)
print(grille)                    # [[1, 2, 99], [3, 4]] — pas isolée

# Faux abri n°2 : « construire » une grille par multiplication
zeros = [[0] * 3] * 3            # une seule ligne, trois noms — piège du ch.2
zeros[0][0] = 1
print(zeros)                     # [[1,0,0],[1,0,0],[1,0,0]]

Les deux échouent pour la même raison : ils opèrent au niveau du contenant et laissent les lignes en commun. grille[:] copie les références des lignes ; [ligne] * 3 répète une référence de ligne. Dans les deux cas, il n'existe qu'un seul jeu d'objets-lignes, et toute mutation d'une ligne traverse toutes ses vues.Both fail for the same reason: they operate at the container level and leave the rows in common. grille[:] copies the rows' references; [row] * 3 repeats a row reference. In both cases, there's only one set of row objects, and any mutation of a row crosses all its views.

Le contre-exemple : l'immuableThe counter-example: the immutable

Slicer un immuable ne copie même pas. En CPython, t[:] sur un tuple et s[:] sur une str renvoient le même objet — pas un clone : à quoi bon dupliquer ce qui ne peut pas changer ? C'est le pendant exact du réflexe du № 05 : l'immuabilité rend la copie inutile. Si tes lignes n'ont pas à muter, une grille en tuple de tuples supprime la question du partage d'un coup.Slicing an immutable doesn't even copy. In CPython, t[:] on a tuple and s[:] on a str return the same object — not a clone: why duplicate what can't change? It's the exact mirror of № 05's reflex: immutability makes copying pointless. If your rows needn't mutate, a grid as a tuple of tuples removes the sharing question at a stroke.

La compréhension n'est pas qu'un raccourci.The comprehension isn't just shorthand.

On la vend comme une boucle for compacte. C'est surtout une garantie de fraîcheur : son corps s'exécute à chaque tour, donc tout objet qu'il construit est neuf. Là où * répète et [:] copie en surface, la compréhension fabrique. Pour toute structure imbriquée à isoler, c'est le premier réflexe avant deepcopy.It's sold as a compact for loop. It's mostly a freshness guarantee: its body runs every turn, so any object it builds is new. Where * repeats and [:] copies shallowly, the comprehension fabricates. For any nested structure to isolate, it's the first reflex before deepcopy.

Contre le partage, * et [:] sont impuissants — ils recopient des références. Seule la réévaluation fabrique du neuf.Against sharing, * and [:] are powerless — they copy references. Only re-evaluation makes something new.
№ 05Bilan & éditoWrap-up & editorial2 min

Quatre visages du [:], et la fin d'un volume.Four faces of [:], and the end of a volume.

Le slicing paraissait anodin : un raccourci pour « prendre une partie ». Il cache une copie de surface qui laisse fuir le contenu, une affectation qui mute en place, et un cousin — la multiplication — qui fond les lignes en une. Rien de tout cela n'est une exception : c'est le modèle du Vol. II appliqué aux crochets. Un objet, plusieurs noms ; copier a une profondeur ; muter n'est pas rebind. Le [:] ne fait que rejouer ces trois vérités.Slicing seemed harmless: a shortcut for 'take a part'. It hides a shallow copy that leaks content, an assignment that mutates in place, and a cousin — multiplication — that fuses rows into one. None of it is an exception: it's Vol. II's model applied to brackets. One object, many names; copying has a depth; mutating isn't rebinding. The [:] merely replays those three truths.

Le gesteThe moveCe qu'il fait vraimentWhat it really doesLe piègeThe trap
b = a[:]Copie de surface : contenant neuf, mêmes éléments.Shallow copy: fresh container, same elements.Les niveaux imbriqués restent partagés. Vraie copie seulement si plat + immuable.Nested levels stay shared. A real copy only if flat + immutable.
a[:] = XAffectation de tranche : remplace le contenu EN PLACE.Slice assignment: replaces the content IN PLACE.Ne rebind pas — tous les alias de a voient le nouveau contenu (№04).Doesn't rebind — all of a's aliases see the new content (№04).
[x] * nRépète UNE référence n fois : un seul objet, n noms.Repeats ONE reference n times: one object, n names.[[0]*3]*3 fusionne les lignes. Muter l'une les mute toutes.[[0]*3]*3 fuses the rows. Mutating one mutates them all.
[f(x) for x in xs]Réévalue le corps à chaque tour : objets neufs garantis.Re-evaluates the body each turn: fresh objects guaranteed.Le bon outil pour copier/construire une grille. Sinon, deepcopy (№05).The right tool to copy/build a grid. Otherwise, deepcopy (№05).
Le [:] n'est jamais « la grille entière ». C'est « une boîte neuve autour des mêmes objets ».The [:] is never "the whole grid". It's "a fresh box around the same objects".
Mot de l'éditeurFrom the editor

Deux volumes pour une seule question : qui tient l'objet ?Two volumes for a single question: who holds the object?

Le Vol. I a appris à lire un nom comme une étiquette ; le Vol. II a appris à compter les étiquettes. Aliasing, copies, slicing : à chaque fois, la seule chose qui décidait du comportement, c'était le nombre de noms sur un même objet et la profondeur à laquelle ce partage descendait. On a cessé de demander « quelle est la valeur ? » pour demander « quel objet, et qui d'autre le tient ? ». C'est le socle. Tout ce qui suit — les protocoles, l'itération, les attributs — suppose acquis ce réflexe d'identité.Vol. I taught you to read a name as a label; Vol. II taught you to count the labels. Aliasing, copies, slicing: each time, the only thing deciding the behavior was the number of names on one object and how deep that sharing ran. We stopped asking 'what is the value?' and started asking 'which object, and who else holds it?'. That's the foundation. Everything that follows — protocols, iteration, attributes — assumes that identity reflex is in place.

Nouveau volume, changement d'axe. Jusqu'ici on regardait qui tient l'objet ; le Vol. III demande ce que l'objet sait faire. En Python, un objet « est » ce qu'il répond, pas ce dont il hérite : implémente les bonnes méthodes, et tu satisfais un protocole sans rien déclarer. Prochain numéro : le duck typing — « if it quacks » — et pourquoi une fonction devrait exiger un comportement, jamais un type. On quitte l'identité pour l'interface.New volume, new axis. So far we watched who holds the object; Vol. III asks what the object can do. In Python, an object 'is' what it answers, not what it inherits: implement the right methods, and you satisfy a protocol without declaring anything. Next issue: duck typing — 'if it quacks' — and why a function should demand a behavior, never a type. We leave identity for the interface.