Problème :Si vous affectez un objet liste à une nouvelle variable en utilisant new_list = old_list , toute modification de new_list change old_list . Quelle en est la raison et comment pouvez-vous cloner ou copier la liste pour éviter ce problème ?
Exemple :Considérons l'exemple suivant.
old_list = ['Alice', 'Bob', 'Carl'] new_list = old_list new_list.append(42) print(old_list) # ['Alice', 'Bob', 'Carl', 42]
Ajouter un élément au new_list modifie également la liste d'origine old_list . Ainsi, old_list a maintenant quatre éléments, même si vous ne l'avez pas modifié directement.
Explication
Ce problème de modification simultanée de "deux" listes se pose car vous n'avez pas deux listes mais une seule.
En Python, tout est un objet. Vous créez un nouvel objet de liste ['Alice', 'Bob', 'Carl'] qui réside dans la mémoire de votre machine. Les deux noms de variables new_list et old_list pointe vers le même objet en mémoire—si vous en modifiez un, vous modifiez également l'autre !
L'outil interactif suivant visualise la mémoire utilisée par l'interpréteur Python lors de l'exécution de cet extrait de code :
Exercice :Visualisez l'origine du problème en cliquant sur « Suivant ».
Comprenez-vous la source du problème ? Super, plongeons dans les solutions en commençant par un bref aperçu !
Présentation de la solution
Vous pouvez voir les trois solutions abordées dans ce didacticiel dans notre shell Python interactif :
Exercice :Modifier la liste d'origine. Les trois méthodes produisent-elles toujours le même résultat ?
Ensuite, vous découvrirez chaque méthode plus en détail !
Méthode 1 :Découpage
Le moyen le plus simple de créer une copie superficielle d'une liste Python consiste à découper :
# Method 1: Slicing old_list = ['Alice', 'Bob', 'Carl'] new_list = old_list[:] new_list.append(42) print(new_list) # ['Alice', 'Bob', 'Carl']
L'opération de découpage old_list[:] crée une nouvelle liste, donc les variables new_list et old_list pointent maintenant vers différents objets en mémoire. Si vous en changez un, l'autre ne change pas.
C'est la voie avec le moins de caractères et de nombreux codeurs Python la considéreraient comme la plus pythonique. Si vous souhaitez en savoir plus sur le découpage en tranches, regardez la vidéo suivante et plongez dans le didacticiel détaillé du blog.
Tutoriel associé :Introduction au découpage en Python
Méthode 2 :Copier
Une alternative consiste à utiliser le list.copy() méthode qui crée une copie superficielle de la liste.
# Method 2: Copy old_list = ['Alice', 'Bob', 'Carl'] new_list = old_list.copy() new_list.append(42) print(old_list) # ['Alice', 'Bob', 'Carl']
Le list.copy() la méthode copie tous les list éléments dans une nouvelle liste. La nouvelle liste est la valeur de retour de la méthode. Il s'agit d'une copie superficielle :vous ne copiez que les références d'objet aux éléments de la liste et non les objets eux-mêmes.
Le résultat est le même que la méthode de découpage :vous avez deux variables pointant vers deux objets de liste différents en mémoire.
Vous pouvez en savoir plus sur le list.copy() méthode dans mon tutoriel de blog détaillé et la vidéo suivante :
Tutoriel associé : Python list.copy() [Guide ultime]
Méthode 3 :Compréhension de la liste
Une troisième façon de résoudre le problème de deux listes pointant vers le même objet en mémoire est la méthode de compréhension de liste pour créer de nouvelles listes.
# Method 3: List Comprehension old_list = ['Alice', 'Bob', 'Carl'] new_list = [x for x in old_list] new_list.append(42) print(old_list) # ['Alice', 'Bob', 'Carl']
La compréhension de liste est une manière compacte de créer des listes. La formule simple est [expression + context] .
- Expression : Que faire de chaque élément de la liste ?
- Contexte : Quels éléments sélectionner ? Le contexte consiste en un nombre arbitraire de
foretifdéclarations.
Vous pouvez regarder la vidéo du didacticiel et lire l'article de blog associé pour en savoir plus !
Tutoriel associé : Une introduction à la compréhension de liste
