Renvoie une copie « peu profonde » (shallow copy, en anglais) de la liste courante. Pour comprendre l'intérêt de cette méthode, commençons par considérer les lignes de code suivantes.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 

#!/usr/bin/python3

l = [10, 20, 30, 40, 50]
# Attention : la ligne de code suivante ne duplique pas la liste.
l2 = l          # On a simplement une seconde variable pointant la liste initiale.
l2[2] = 3000    # On modifie donc la liste d'origine.
print(l)        # On affiche [10, 20, 3000, 40, 50]
print(l2)       # On affiche donc aussi [10, 20, 3000, 40, 50]

En fait, dans l'exemple ci-dessus, les deux variables l et l2 contiennent, en interne, un pointeur (une adresse mémoire) vers la même liste. Dans cet exemple, il n'y a donc, en tout et pour tout, qu'une unique liste. Que l'on passe par une variable ou une autre pour modifier la liste, nous constaterons les modifications via les deux variables. D'où la question suivante : comment cloner la liste ?

En fait vous avez plusieurs solutions pour copier une liste. La première consiste à utiliser la méthode copy. Mais vous pouvez aussi utiliser l'opérateur d'extraction de sous-liste, utiliser une compréhension de liste (list comprehension), ou simplement passer par le constructeur de la classe list. Voici un exemple de copie via la méthode copy, ainsi que les autres solutions équivalentes en commentaires.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 

#!/usr/bin/python3
        
l = [10, 20, 30, 40, 50] # La liste d'origine

l2 = l.copy()           # On clone la liste
# l2 = l[:]             # Idem, en passant par l'opérateur d'extraction de sous-liste.
# l2 = [x for x in l]   # Idem, en passant par une compréhension de liste.
# l2 = list(l)          # Idem, en passant par le constructeur de la classe list.

l2[2] = 3000            # On modifie la copie
l.append(60)            # On modifie l'originale

print(l)    # On affiche la première liste
print(l2)   # On affiche la seconde liste

Et voici un exemple d'exécution de ce programme :

[10, 20, 30, 40, 50, 60]
[10, 20, 3000, 40, 50]

Maintenant, il nous faut comprendre l'aspect « peu profond » de la copie (shallow copy). En fait, la copie ne se fait qu'au premier niveau. Si votre liste contient des listes de données, la duplication n'est pas récursive sur les sous-listes :-(
Il est donc de votre responsabilité de cloner les sous-listes. Voici un exemple démontrant cet aspect.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 

#!/usr/bin/python3
     
# On commence par définir une liste de listes.   
m = [[10, 20, 30], [40, 50, 60], [70, 80, 90]]

# On clone la matrice
m2 = m.copy()

# On modifie quelques cellules de la matrice.
m2[1][1] = 5000
m[2][2] = 9000

# On ajoute une ligne que pour m2
m2.append([100, 110, 120])

# Les modifications sont, en partie, constatées via les deux variables. 
print(m)    # On affiche la première matrice
print(m2)   # On affiche la seconde matrice

Et voici un exemple d'exécution de ce programme :

[[10, 20, 30], [40, 5000, 60], [70, 80, 9000]]
[[10, 20, 30], [40, 5000, 60], [70, 80, 9000], [100, 110, 120]]