Copy un objet en Python

En Python, nous utilisons l’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. cela crée seulement 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 en utilisant l’opérateur=.,

exemple 1: Copy using = operator

lorsque nous exécutons le programme ci-dessus, la sortie sera:

Old List: , , ]ID of Old List: 140673303268168New List: , , ]ID of New List: 140673303268168

comme vous pouvez le voir sur la sortie, les variables old_list et new_list partagent le même id, c’est-à-dire140673303268168.

donc, si vous souhaitez modifier des valeurs dans new_list ou old_list, la modification est visible dans les deux.

essentiellement, vous pouvez parfois avoir les valeurs d’origine inchangées et modifier uniquement les nouvelles valeurs ou vice versa., En Python, il existe deux façons de créer des copies:

1. Copie
2. Copie

Pour faire de ces copie de travail, nous utilisons la balise copy module.

Copy Module

Nous utilisons le modulecopy de Python pour les opérations de copie superficielles et profondes. Supposons que vous ayez besoin de copier la liste composée par exemple X. Par exemple:

import copycopy.copy(x)copy.deepcopy(x)

ici, le copy()renvoie une copie superficielle de X. De même, deepcopy() renvoie une copie profonde de X.,

Copie

Une copie 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 d’objets imbriqués, mais copie simplement la référence des objets imbriqués. Cela signifie qu’un processus de copie ne récurse pas ou ne crée pas de copies d’objets imbriqués lui-même.,

Exemple 2: Créer une copie à l’aide de la copie superficielle

import copyold_list = , , ]new_list = copy.copy(old_list)print("Old list:", old_list)print("New list:", new_list)

Quand on lance le programme , la sortie sera:

Old list: , , ]New list: , , ]

Dans le programme ci-dessus, nous avons créé une liste imbriquée et puis la copie superficielle à l’aide de copy() méthode.

cela signifie qu’il va créer 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érente de old_list, nous essayons d’ajouter de nouveaux objets imbriqués à l’origine et à la vérifier.

exemple 3: ajout à old_list, en utilisant une copie superficielle

lorsque nous exécutons le programme, il affichera:

Old list: , , , ]New list: , , ]

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-à-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 D’une copie superficielle

import copyold_list = , , ]new_list = copy.copy(old_list)old_list = 'AA'print("Old list:", old_list)print("New list:", new_list)

lorsque nous exécutons le programme, il affichera:

Old list: , , ]New list: , , ]

copie profonde

Une copie profonde crée un nouvel objet et ajoute récursivement les copies

nous allons continuer avec l’exemple 2., Cependant, nous allons créer une copie profonde en utilisant la fonctiondeepcopy() présente dans le modulecopy. La copie profonde crée une copie indépendante de l’objet original et de tous ses objets imbriqués.

exemple 5: copier une liste en utilisant deepcopy ()

import copyold_list = , , ]new_list = copy.deepcopy(old_list)print("Old list:", old_list)print("New list:", new_list)

lorsque nous exécutons le programme, il affichera:

Old list: , , ]New list: , , ]

dans le programme ci-dessus, nous utilisonsdeepcopy() fonction pour créer une copie qui ressemble.,

cependant, si vous apportez des modifications à des objets imbriqués dans l’objet d’origine old_list, vous ne verrez aucune modification à la copie new_list.

exemple 6: Ajout d’un nouvel objet imbriqué dans la liste en utilisant Deep copy

lorsque nous exécutons le programme, il affichera:

Old list: , , ]New list: , , ]

dans le programme ci-dessus, lorsque nous affectons une nouvelle valeur à old_list, nous pouvons voir que la old_list est modifiée. Cela signifie que l’old_list et la new_list sont indépendantes. En effet, old_list a été copié récursivement, ce qui est vrai pour tous ses objets imbriqués.