Accéder au contenu principal

Copier une liste en Python : l’essentiel à connaître

Comprenez comment copier des listes en Python. Apprenez à utiliser les fonctions copy() et list(). Découvrez la différence entre copies superficielles et profondes.
· 7 min lire

Explorez l'IA

Les listes Python sont des structures de données puissantes qui permettent de stocker un ensemble d’éléments. La copie de liste est essentielle lorsque vous manipulez des données, car elle préserve la liste d’origine tout en vous laissant travailler sur un duplicata. Dans ce tutoriel, je vous présente les techniques de base et avancées pour copier des listes, avec des exemples concrets.

Avant d’explorer les différents exemples, je vous recommande le cours Introduction to Python de DataCamp pour maîtriser les fondamentaux de Python, notamment les différentes structures de données Python. Le Python Cheat Sheet for Beginners vous sera également utile pour retrouver rapidement les fonctions et méthodes.

Python utilisant une photocopieuse

« Python utilisant une photocopieuse. » Image par Dall-E.

Réponse rapide : comment copier une liste en Python

L’exemple ci-dessous montre comment copier une liste en Python avec la méthode copy(). Remarquez que la liste d’origine reste intacte même si l’on modifie la liste copiée. Le code affiche [1, 2, 3].

# Define the original list
original_list = [1, 2, 3]

# Create a shallow copy of the original list
copied_list = original_list.copy()

# Modify the first element of the copied list
copied_list[0] = 99

print(original_list)
[1, 2, 3]

Autres techniques pour copier une liste en Python

Avant de voir les différentes techniques de copie, expliquons pourquoi on n’utilise pas l’opérateur d’affectation =. Avec =, on ne crée pas une copie de la liste : on crée seulement une référence vers celle-ci.

Dans l’exemple suivant, original_list et reference_to_original_list pointent vers la même liste après l’affectation.

# Create a list called original_list
original_list = [1, 2, 3]

# Create a new reference copied_list that points to the same list as original_list
reference_to_original_list = original_list

Ici, toute modification apportée à la liste « dupliquée » affecte la liste d’origine, et inversement. Cela se produit car les deux listes partagent la même zone mémoire. Voyons maintenant les différentes manières de réellement copier une liste.

Utiliser la méthode copy()

La méthode intégrée copy() crée une copie superficielle (shallow copy) de la liste. Elle est disponible à partir de Python 3.3. Cette méthode ne recopie que la structure de premier niveau. Sa syntaxe est la suivante.

new_list = original_list.copy()

Dans l’exemple ci-dessous, le code affiche [1, 2, 3, 4].

# Original list with nested structure
original_list = [1, 2, 3, 4]

# Create a shallow copy using the copy() method
shallow_copied_list = original_list.copy()

print(shallow_copied_list)
[1, 2, 3, 4]

Utiliser le constructeur list()

Le constructeur list() permet de créer un nouvel objet liste à partir d’une liste existante en incluant tous ses éléments. Cette technique est utile pour obtenir une nouvelle liste indépendante : les modifications de la copie n’affecteront pas la liste d’origine. Le code suivant affiche [1, 2, 3].

# Create a list called original_list
original_list = [1, 2, 3]

# Create a shallow copy of original_list using the list() function
copied_list = list(original_list)

# Modify the first element of copied_list
copied_list[0] = 99

print(original_list)
[1, 2, 3]

Utiliser le slicing avec [:]

Le slicing [:] offre un moyen concis de créer une copie superficielle d’une liste. Cette méthode est efficace car elle est implémentée à bas niveau dans Python. Sa syntaxe est la suivante.

new_list = original_list[:]

Le code ci-dessous affiche [1, 2, 3].

# Create a list called original_list
original_list = [1, 2, 3]

# Create a shallow copy of original_list using list slicing
copied_list = original_list[:]

# Modify the first element of copied_list
copied_list[0] = 99

print(original_list)
[1, 2, 3]

Ici, nous utilisons le slicing pour inclure l’intégralité de la liste, mais dans d’autres contextes, il permet aussi de créer des sous-listes en précisant les indices de début et de fin.

Copie superficielle vs copie profonde en Python

Comprendre la différence entre copie superficielle et copie profonde est crucial pour éviter des modifications de données non souhaitées.

  • Une copie superficielle recopie uniquement les éléments de premier niveau de la liste et n’isole pas les listes imbriquées ni les objets mutables référencés. Les modifications apportées à ces objets mutables affecteront à la fois la liste d’origine et la liste copiée.
  • Une copie profonde recopie récursivement tous les éléments, y compris les listes imbriquées et les objets mutables, en créant des copies indépendantes. Les modifications faites aux objets imbriqués dans la copie n’affectent pas la liste d’origine.

Je vous recommande d’utiliser la fonction copy.copy() pour les copies superficielles et copy.deepcopy() pour les copies profondes.

Méthode

Copie superficielle

Copie profonde

copy()

✓

✗

Constructeur list()

✓

✗

Slicing de liste [:]

✓

✗

copy.copy()

✓

✗

copy.deepcopy()

✗

✓

Comment copier une liste imbriquée en Python

Pour des listes imbriquées ou des structures plus complexes, il faut des méthodes de copie plus adaptées. Voyons les techniques à privilégier avec des listes imbriquées.

Utiliser copy.copy()

Le module copy fournit la fonction copy() qui crée une copie superficielle d’une liste. Cette approche est plus explicite que le constructeur list() ou le slicing [:]. Utilisez-la quand vous souhaitez souligner qu’il s’agit d’une copie superficielle pour améliorer la lisibilité.

L’exemple ci-dessous montre la copie superficielle d’une liste imbriquée. Le code affiche [1, 2, [99, 4]] car la liste imbriquée reste le même objet.

# Import the copy module to access the copy.copy() function
import copy

# Original list with nested structure
original_list = [1, 2, [3, 4]]

# Create a shallow copy using copy.copy()
shallow_copied_list = copy.copy(original_list)

# Modifying the nested list in the copied list
shallow_copied_list[2][0] = 99

print(original_list)
[1, 2, [99, 4]]

Utiliser copy.deepcopy()

La fonction deepcopy() est également disponible dans le module copy. Elle crée une copie profonde : elle duplique la liste et tous les objets imbriqués. deepcopy() est indispensable avec des objets mutables à l’intérieur des listes, car elle garantit que les modifications de la copie n’affectent pas l’originale.

Le code ci-dessous affiche [1, 2, [3, 4]].

# Import the copy module to access the copy.deepcopy() function
import copy

# Original list with nested structure
original_list = [1, 2, [3, 4]]

# Create a deep copy using copy.deepcopy()
deep_copied_list = copy.deepcopy(original_list)

# Modifying the nested list in the copied list
deep_copied_list[2][0] = 99

print(original_list)
[1, 2, [3, 4]]

Conclusion

Savoir copier des listes en Python est essentiel pour manipuler les données efficacement. Dans ce tutoriel, nous avons passé en revue plusieurs méthodes de copie de listes en Python et clarifié les différences entre copies superficielles et profondes. En tant qu’analyste de données, il est important de choisir la technique la plus adaptée à votre cas d’usage. Je vous invite à pratiquer ces méthodes pour bien en maîtriser les scénarios d’application.

Suivez le parcours de compétences Python Programming de DataCamp pour perfectionner vos techniques. Découvrez aussi nos parcours carrière Python Developer et Data Analyst with Python pour continuer à développer des compétences pratiques, recherchées sur le marché.

Allan Ouko

Auteur

Allan Ouko

LinkedIn
Je crée des articles qui simplifient la science des données et l'analyse, en les rendant faciles à comprendre et accessibles.

Foire aux questions

Quelle est la différence entre copie superficielle et copie profonde ?

La copie superficielle crée une nouvelle liste qui référence les mêmes valeurs que la liste d’origine, de sorte que les modifications apportées aux objets mutables de la liste copiée affectent la liste d’origine. La copie profonde crée une nouvelle liste et y insère récursivement les valeurs de la liste d’origine, de sorte que les modifications des objets imbriqués dans la liste copiée n’affectent pas la liste d’origine.

Quelles sont les méthodes pour créer une copie superficielle en Python ?

Vous pouvez créer une copie superficielle d’une liste avec la méthode copy(), le slicing [:], le constructeur list() ou la fonction copy() du module copy.

Comment créer une copie profonde d’une liste en Python ?

Vous pouvez créer une copie profonde d’une liste avec la fonction deepcopy() du module copy.

Sujets

PythonAnalyse des données

Contenus associés

Voir plus →