In dit artikel leer je met behulp van voorbeelden over ondiep kopiëren en diep kopiëren in Python.
Kopieer een object in Python
In Python gebruiken we een =operator om een kopie van een object te maken. Je denkt misschien dat hierdoor een nieuw object ontstaat; het niet. Het creëert alleen een nieuwe variabele die de referentie van het oorspronkelijke object deelt.
Laten we een voorbeeld nemen waarin we een lijst maken met de naam old_list en een objectverwijzing doorgeven aan new_list met de =operator.
Voorbeeld 1: Kopiëren met = operator
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))
Wanneer we het bovenstaande programma uitvoeren, is de uitvoer:
Oude lijst: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID van oude lijst: 140673303268168 Nieuwe lijst: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID van nieuwe lijst: 140673303268168
Zoals je kunt zien in de output delen beide variabelen old_list en new_list dezelfde id, dwz 140673303268168.
Dus als u waarden in nieuwe_lijst of oude_lijst wilt wijzigen, is de wijziging zichtbaar in beide.
In wezen wilt u soms dat de oorspronkelijke waarden ongewijzigd blijven en alleen de nieuwe waarden wijzigen of vice versa. In Python zijn er twee manieren om kopieën te maken:
- Oppervlakkige kopie
- Diepe kopie
Om deze kopieën te laten werken, gebruiken we de copymodule.
Kopieer module
We gebruiken de copymodule van Python voor ondiepe en diepe kopieerbewerkingen. Stel dat u de samengestelde lijst moet kopiëren, zeg x. Bijvoorbeeld:
import kopie copy.copy (x) copy.deepcopy (x)
Hier copy()retourneren ze een ondiepe kopie van x. deepcopy()Retourneer op dezelfde manier een diepe kopie van x.
Oppervlakkige kopie
Een ondiepe kopie creëert een nieuw object dat de referentie van de originele elementen opslaat.
Een ondiepe kopie maakt dus geen kopie van geneste objecten, maar kopieert alleen de referentie van geneste objecten. Dit betekent dat een kopieerproces zelf geen kopieën van geneste objecten herneemt of maakt.
Voorbeeld 2: maak een kopie met een ondiepe kopie
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)
Wanneer we het programma uitvoeren, is de uitvoer:
Oude lijst: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Nieuwe lijst: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
In het bovenstaande programma hebben we een geneste lijst gemaakt en deze vervolgens ondiep gekopieerd met behulp van de copy()methode.
Dit betekent dat het een nieuw en onafhankelijk object met dezelfde inhoud zal creëren. Om dit te verifiëren, printen we zowel de oude_lijst als de nieuwe_lijst.
Om te bevestigen dat new_list anders is dan old_list, proberen we een nieuw genest object aan het origineel toe te voegen en het te controleren.
Voorbeeld 3: (4, 4, 4) toevoegen aan old_list, met ondiepe kopie
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)
Wanneer we het programma uitvoeren, zal het uitvoeren:
Oude lijst: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Nieuwe lijst: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
In het bovenstaande programma hebben we een ondiepe kopie gemaakt van old_list. De new_list bevat verwijzingen naar originele geneste objecten die zijn opgeslagen in old_list. Vervolgens voegen we de nieuwe lijst toe, dwz (4, 4, 4)in old_list. Deze nieuwe sublijst is niet gekopieerd in new_list.
Als u echter geneste objecten in old_list wijzigt, verschijnen de wijzigingen in new_list.
Voorbeeld 4: een nieuw genest object toevoegen met behulp van ondiepe kopie
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)
Wanneer we het programma uitvoeren, zal het uitvoeren:
Oude lijst: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Nieuwe lijst: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
In the above program, we made changes to old_list i.e old_list(1)(1) = 'AA'. Both sublists of old_list and new_list at index (1)(1) were modified. This is because, both lists share the reference of same nested objects.
Deep Copy
A deep copy creates a new object and recursively adds the copies of nested objects present in the original elements.
Let’s continue with example 2. However, we are going to create deep copy using deepcopy() function present in copy module. The deep copy creates independent copy of original object and all its nested objects.
Example 5: Copying a list using 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)
When we run the program, it will output:
Old list: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) New list: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
In the above program, we use deepcopy() function to create copy which looks similar.
Als u echter wijzigingen aanbrengt in geneste objecten in het oorspronkelijke object old_list, ziet u geen wijzigingen in de kopie nieuwe_lijst.
Voorbeeld 6: een nieuw genest object aan de lijst toevoegen met behulp van diepe kopie
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)
Wanneer we het programma uitvoeren, zal het uitvoeren:
Oude lijst: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Nieuwe lijst: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Als we in het bovenstaande programma een nieuwe waarde toewijzen aan old_list, kunnen we zien dat alleen de old_list is gewijzigd. Dit betekent dat zowel de oude_lijst als de nieuwe_lijst onafhankelijk zijn. Dit komt doordat de old_list recursief is gekopieerd, wat geldt voor al zijn geneste objecten.
