Dans cet article, vous en apprendrez davantage sur la copie superficielle et la copie profonde en Python à l'aide d'exemples.
Copier un objet en Python
En Python, nous utilisons un =opérateur pour créer une copie d'un objet. Vous pouvez penser que cela crée un nouvel objet; ce n'est pas le cas. Il crée uniquement une nouvelle variable qui partage la référence de l'objet d'origine.
Prenons un exemple où nous créons une liste nommée old_list et passons une référence d'objet à new_list à l'aide de l' =opérateur.
Exemple 1: Copier avec l'opérateur =
old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 'a')) new_list = old_list new_list(2)(2) = 9 print('Old List:', old_list) print('ID of Old List:', id(old_list)) print('New List:', new_list) print('ID of New List:', id(new_list))
Lorsque nous exécutons le programme ci-dessus, la sortie sera:
Ancienne liste: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID de l'ancienne liste: 140673303268168 Nouvelle liste: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID de la nouvelle liste: 140673303268168
Comme vous pouvez le voir à partir de la sortie, les deux variables old_list et new_list partagent le même id 140673303268168.
Donc, si vous souhaitez modifier des valeurs dans new_list ou old_list, le changement est visible dans les deux.
Essentiellement, vous souhaiterez parfois que les valeurs d'origine restent inchangées et ne modifier que les nouvelles valeurs ou vice versa. En Python, il existe deux façons de créer des copies:
- Copie superficielle
- Copie profonde
Pour faire fonctionner ces copies, nous utilisons le copymodule.
Module de copie
Nous utilisons le copymodule de Python pour les opérations de copie superficielle et profonde. Supposons que vous deviez copier la liste composée, disons x. Par exemple:
import copie copy.copy (x) copy.deepcopy (x)
Ici, le copy()retourne une copie superficielle de x. De même, deepcopy()renvoyez une copie complète de x.
Copie superficielle
Une copie superficielle crée un nouvel objet qui stocke la référence des éléments d'origine.
Ainsi, une copie superficielle ne crée pas une copie des objets imbriqués, mais copie simplement la référence des objets imbriqués. Cela signifie qu'un processus de copie ne récurent pas ou ne crée pas de copies d'objets imbriqués lui-même.
Exemple 2: créer une copie en utilisant une copie superficielle
import copy old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) new_list = copy.copy(old_list) print("Old list:", old_list) print("New list:", new_list)
Lorsque nous exécutons le programme, la sortie sera:
Ancienne liste: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Nouvelle liste: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
Dans le programme ci-dessus, nous avons créé une liste imbriquée, puis nous l'avons copiée superficiellement à l'aide de la copy()méthode.
Cela signifie qu'il créera un nouvel objet indépendant avec le même contenu. Pour vérifier cela, nous imprimons à la fois old_list et new_list.
Pour confirmer que new_list est différent de old_list, nous essayons d'ajouter un nouvel objet imbriqué à l'original et de le vérifier.
Exemple 3: Ajout de (4, 4, 4) à old_list, en utilisant une copie superficielle
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list.append((4, 4, 4)) print("Old list:", old_list) print("New list:", new_list)
Lorsque nous exécutons le programme, il affichera:
Ancienne liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Nouvelle liste: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
Dans le programme ci-dessus, nous avons créé une copie superficielle de old_list. La new_list contient des références aux objets imbriqués d'origine stockés dans old_list. Ensuite, nous ajoutons la nouvelle liste, c'est- (4, 4, 4)à- dire dans old_list. Cette nouvelle sous-liste n'a pas été copiée dans new_list.
Cependant, lorsque vous modifiez des objets imbriqués dans old_list, les modifications apparaissent dans new_list.
Exemple 4: Ajout d'un nouvel objet imbriqué à l'aide de la copie peu profonde
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list(1)(1) = 'AA' print("Old list:", old_list) print("New list:", new_list)
Lorsque nous exécutons le programme, il affichera:
Ancienne liste: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Nouvelle liste: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Dans le programme ci-dessus, nous avons apporté des modifications à old_list ie old_list(1)(1) = 'AA'. Les deux sous-listes de old_list et new_list à index (1)(1)ont été modifiées. En effet, les deux listes partagent la référence des mêmes objets imbriqués.
Copie profonde
Une copie complète crée un nouvel objet et ajoute de manière récursive les copies des objets imbriqués présents dans les éléments d'origine.
Continuons avec l'exemple 2. Cependant, nous allons créer une copie profonde en utilisant la deepcopy()fonction présente dans le copymodule. La copie complète crée une copie indépendante de l'objet d'origine et de tous ses objets imbriqués.
Exemple 5: Copier une liste à l'aide de deepcopy ()
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) print("Old list:", old_list) print("New list:", new_list)
Lorsque nous exécutons le programme, il affichera:
Ancienne liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Nouvelle liste: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
Dans le programme ci-dessus, nous utilisons la deepcopy()fonction pour créer une copie similaire.
Cependant, si vous apportez des modifications à des objets imbriqués dans l'objet d'origine old_list, vous ne verrez aucun changement dans la copie new_list.
Exemple 6: Ajout d'un nouvel objet imbriqué dans la liste à l'aide de Deep Copy
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) old_list(1)(0) = 'BB' print("Old list:", old_list) print("New list:", new_list)
Lorsque nous exécutons le programme, il affichera:
Ancienne liste: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Nouvelle liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Dans le programme ci-dessus, lorsque nous attribuons une nouvelle valeur à old_list, nous pouvons voir que seule la old_list est modifiée. Cela signifie que l'ancienne et la nouvelle liste sont toutes deux indépendantes. En effet, l'ancienne_liste a été copiée récursivement, ce qui est vrai pour tous ses objets imbriqués.
