# Python - Copier des listes

Bonjour, aspirants programmeurs Python ! Aujourd'hui, nous allons plonger dans le monde fascinant de la copie des listes en Python. En tant que votre enseignant de sciences informatiques amical et de voisinage, je suis là pour vous guider à travers ce voyage avec des explications claires, plein d'exemples et peut-être même un ou deux plaisanteries en cours de route. Alors,commençons !

Copier une liste en Python

Avant de nous lancer dans les différentes méthodes de copie des listes, comprenons d'abord pourquoi nous devons copier des listes en premier lieu. Imaginez que vous avez une liste de courses, et vous voulez la partager avec votre colocataire. Vous pourriez leur donner votre liste originale, mais que faire si ils décident d'ajouter "chocolat" (qui ne le ferait pas) ? Soudain, votre liste de courses soigneusement planifiée et saine est compromise ! C'est là que la copie devient pratique.

En Python, lorsque vous affectez une liste à une nouvelle variable, vous ne créez pas une nouvelle liste. Au lieu de cela, vous créez une nouvelle référence à la même liste. Voyons cela en action :

original_list = [1, 2, 3, 4, 5]
new_list = original_list

print("Liste originale :", original_list)
print("Nouvelle liste :", new_list)

new_list.append(6)

print("Liste originale après modification :", original_list)
print("Nouvelle liste après modification :", new_list)

Sortie :

Liste originale : [1, 2, 3, 4, 5]
Nouvelle liste : [1, 2, 3, 4, 5]
Liste originale après modification : [1, 2, 3, 4, 5, 6]
Nouvelle liste après modification : [1, 2, 3, 4, 5, 6]

Surpris ? Les deux listes ont changé car elles sont en réalité la même liste en mémoire. C'est là que la copie vient à la rescousse !

Copie superficielle sur une liste Python

Une copie superficielle crée un nouvel objet liste, mais les éléments de la nouvelle liste sont des références aux mêmes objets que dans la liste originale. C'est comme faire une photocopie de votre liste de courses - vous avez un nouveau morceau de papier, mais les articles écrits dessus sont les mêmes.

Voyons comment créer une copie superficielle :

import copy

original_list = [1, [2, 3], 4]
shallow_copy = copy.copy(original_list)

print("Liste originale :", original_list)
print("Copie superficielle :", shallow_copy)

shallow_copy[1][0] = 'deux'

print("Liste originale après modification :", original_list)
print("Copie superficielle après modification :", shallow_copy)

Sortie :

Liste originale : [1, [2, 3], 4]
Copie superficielle : [1, [2, 3], 4]
Liste originale après modification : [1, ['deux', 3], 4]
Copie superficielle après modification : [1, ['deux', 3], 4]

Notez comment la modification de la liste imbriquée dans la copie superficielle a également affecté la liste originale ? C'est parce que la liste imbriquée est toujours une référence à l'objet même en mémoire.

Copie profonde sur une liste Python

D'un autre côté, une copie profonde crée une nouvelle liste et ajoute récursivement des copies des objets imbriqués. C'est comme réécrire votre liste de courses entière à la main - tout est nouveau et indépendant.

Voici comment créer une copie profonde :

import copy

original_list = [1, [2, 3], 4]
deep_copy = copy.deepcopy(original_list)

print("Liste originale :", original_list)
print("Copie profonde :", deep_copy)

deep_copy[1][0] = 'deux'

print("Liste originale après modification :", original_list)
print("Copie profonde après modification :", deep_copy)

Sortie :

Liste originale : [1, [2, 3], 4]
Copie profonde : [1, [2, 3], 4]
Liste originale après modification : [1, [2, 3], 4]
Copie profonde après modification : [1, ['deux', 3], 4]

Cette fois, la modification de la copie profonde n'a pas affecté la liste originale. Elle est complètement indépendante !

Copier une liste en utilisant la notation de tranche

Maintenant, examinons d'autres méthodes pour copier des listes. L'une des méthodes les plus faciles est d'utiliser la notation de tranche. C'est comme dire, "Je veux une copie de la liste entière du début à la fin."

original_list = [1, 2, 3, 4, 5]
slice_copy = original_list[:]

print("Liste originale :", original_list)
print("Copie de tranche :", slice_copy)

slice_copy.append(6)

print("Liste originale après modification :", original_list)
print("Copie de tranche après modification :", slice_copy)

Sortie :

Liste originale : [1, 2, 3, 4, 5]
Copie de tranche : [1, 2, 3, 4, 5]
Liste originale après modification : [1, 2, 3, 4, 5]
Copie de tranche après modification : [1, 2, 3, 4, 5, 6]

Cette méthode crée une copie superficielle de la liste, ce qui est généralement suffisant pour les listes d'objets immuables comme les nombres et les chaînes de caractères.

Copier une liste en utilisant la fonction list()

Une autre manière de créer une copie est d'utiliser la fonction list(). C'est comme dire à Python, "Fais-moi une nouvelle liste qui ressemble exactement à celle-ci."

original_list = [1, 2, 3, 4, 5]
list_copy = list(original_list)

print("Liste originale :", original_list)
print("Copie de liste :", list_copy)

list_copy.append(6)

print("Liste originale après modification :", original_list)
print("Copie de liste après modification :", list_copy)

Sortie :

Liste originale : [1, 2, 3, 4, 5]
Copie de liste : [1, 2, 3, 4, 5]
Liste originale après modification : [1, 2, 3, 4, 5]
Copie de liste après modification : [1, 2, 3, 4, 5, 6]

Cette méthode crée également une copie superficielle de la liste.

Copier une liste en utilisant la méthode copy()

Enfin, nous avons la méthode copy(), qui est une méthode intégrée aux listes. C'est comme si la liste disait, "Voici, prends une copie de moi-même !"

original_list = [1, 2, 3, 4, 5]
copy_method = original_list.copy()

print("Liste originale :", original_list)
print("Méthode de copie :", copy_method)

copy_method.append(6)

print("Liste originale après modification :", original_list)
print("Méthode de copie après modification :", copy_method)

Sortie :

Liste originale : [1, 2, 3, 4, 5]
Méthode de copie : [1, 2, 3, 4, 5]
Liste originale après modification : [1, 2, 3, 4, 5]
Méthode de copie après modification : [1, 2, 3, 4, 5, 6]

Cette méthode crée également une copie superficielle de la liste.

Maintenant, résumons toutes ces méthodes dans un tableau pratique :

Méthode	Syntaxe	Type de copie	Remarques
Affectation	new_list = original_list	Référence	Pas une véritable copie
Copie superficielle	copy.copy(original_list)	Superficielle	Nouvelle liste, mêmes références d'objets
Copie profonde	copy.deepcopy(original_list)	Profonde	Nouvelle liste, nouvelles références d'objets
Notation de tranche	original_list[:]	Superficielle	facile et lisible
Fonction list()	list(original_list)	Superficielle	Intention claire
Méthode copy()	original_list.copy()	Superficielle	Méthode intégrée aux listes

N'oubliez pas, le choix de la bonne méthode de copie dépend de vos besoins spécifiques. Si vous traitez des listes simples d'objets immuables, une copie superficielle sera généralement suffisante. Mais si vous avez des listes imbriquées ou des objets mutables, vous pourriez avoir besoin d'une copie profonde pour assurer une indépendance complète.

Et voilà ! Vous êtes maintenant équipé du savoir-faire pour copier des listes comme un pro. La prochaine fois que vous devrez partager votre liste de courses, vous saurez exactement comment faire une copie sans risquer d'ajouts inattendus. Bon codage, et que vos listes soient toujours parfaitement copiées !

Credits: Image by storyset