Copier des listes

Les listes Python sont mutables, ce qui signifie qu'assigner une liste à une nouvelle variable ne crée pas de copie — les deux noms pointent vers le même objet. Cette page explique toutes les façons fiables de copier une liste, la différence entre une copie superficielle et une copie profonde, et quand chaque approche est le bon choix.

Le piège de l'assignation

Une erreur courante consiste à utiliser l'opérateur = en s'attendant à ce qu'il produise une copie indépendante :

Pourquoi l'opérateur = ne copie pas une liste

original et alias pointent tous les deux vers exactement le même objet liste en mémoire. Toute modification effectuée via l'un des noms est immédiatement visible via l'autre.

Pour obtenir une vraie copie indépendante, utilisez l'une des méthodes ci-dessous.

Méthodes de copie superficielle

Une copie superficielle crée un nouvel objet liste, mais les éléments à l'intérieur de la nouvelle liste sont toujours des références vers les mêmes objets que ceux de l'original. Pour une liste plate (une liste contenant uniquement des valeurs immuables comme des nombres et des chaînes), une copie superficielle se comporte comme une copie complètement indépendante.

Utiliser la méthode copy()

La méthode copy() est l'approche la plus explicite et la plus lisible :

Copier une liste avec la méthode copy()

original = ["apple", "banana", "cherry"]
copy_of = original.copy()

copy_of.append("date")
print(original)   # Output: ['apple', 'banana', 'cherry']
print(copy_of)    # Output: ['apple', 'banana', 'cherry', 'date']

Les deux listes sont maintenant indépendantes : ajouter un élément à copy_of n'affecte pas original.

Utiliser la notation de slice [:]

La notation de slice est un raccourci Pythonique pour copier l'intégralité de la liste :

Copier une liste avec la notation de slice

original = [10, 20, 30, 40]
copy_of = original[:]

copy_of[0] = 99
print(original)   # Output: [10, 20, 30, 40]
print(copy_of)    # Output: [99, 20, 30, 40]

[:] se lit comme « prendre chaque élément du début à la fin », ce qui produit une nouvelle liste contenant ces éléments.

Utiliser le constructeur list()

Passer une liste existante à list() crée également une copie superficielle :

Copier une liste avec le constructeur list()

original = [1, 2, 3]
copy_of = list(original)

copy_of.append(4)
print(original)   # Output: [1, 2, 3]
print(copy_of)    # Output: [1, 2, 3, 4]

C'est particulièrement utile pour convertir un autre itérable (comme un tuple) en liste en même temps.

Quand les copies superficielles ne suffisent pas

Une copie superficielle ne copie que la structure de premier niveau. Si la liste contient des objets mutables tels que d'autres listes ou des dictionnaires, ces objets imbriqués sont encore partagés entre l'original et la copie.

Copie superficielle avec une liste imbriquée

Les deux listes partagent les mêmes objets de liste interne [1, 2] et [3, 4]. Modifier original[0][0] modifie cette liste interne partagée, de sorte que la modification apparaît également dans shallow.

Copie profonde

Une copie profonde copie récursivement chaque objet à l'intérieur de la liste, produisant une structure complètement indépendante de l'original. Utilisez copy.deepcopy() du module standard copy :

Copie profonde d'une liste imbriquée avec copy.deepcopy()

import copy

original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

original[0][0] = 99       # Mutate the nested list

print(original)   # Output: [[99, 2], [3, 4]]
print(deep)       # Output: [[1, 2], [3, 4]]  <- unchanged

deep possède ses propres copies des listes internes, de sorte que les modifications apportées à original ne l'affectent pas du tout.

Copie superficielle vs copie profonde en un coup d'œil

Exemples pratiques

Combiner toutes les méthodes de copie superficielle

original = [1, 2, 3]

a = original.copy()    # method
b = original[:]        # slice
c = list(original)     # constructor

original.append(4)

print(a)  # Output: [1, 2, 3]
print(b)  # Output: [1, 2, 3]
print(c)  # Output: [1, 2, 3]

Les trois produisent des copies indépendantes — aucune ne reflète le append(4) ultérieur.

Copier une liste de dictionnaires

Les dictionnaires sont des objets mutables. Une copie superficielle d'une liste de dictionnaires partage ces objets dict :

import copy

records = [{"name": "Alice", "score": 90}, {"name": "Bob", "score": 85}]
shallow = records.copy()
deep    = copy.deepcopy(records)

records[0]["score"] = 0

print(shallow[0])   # Output: {'name': 'Alice', 'score': 0}   <- shared dict
print(deep[0])      # Output: {'name': 'Alice', 'score': 90}  <- independent copy

Lorsque les éléments sont des objets mutables et que vous avez besoin d'une indépendance totale, utilisez toujours deepcopy().

Conclusion

Les listes Python sont mutables, donc l'opérateur = crée un alias, pas une copie. Pour les listes plates, l'une ou l'autre des méthodes de copie superficielle — copy(), [:] ou list() — fonctionne aussi bien. Lorsque les listes contiennent des objets mutables imbriqués, utilisez copy.deepcopy() pour garantir une indépendance totale.

Pour explorer les opérations connexes sur les listes, consultez Méthodes de liste, Ajouter des éléments à une liste et Supprimer des éléments d'une liste. Pour la copie de dictionnaires, la même distinction superficielle/profonde s'applique — consultez Copier des dictionnaires.

Entraînement