Python ondiepe kopie en diepe kopie
Kopieer een Object in Python
In Python gebruiken we= operator om een kopie van een object te maken. Je denkt misschien dat dit een nieuw object creëert, maar dat doet het niet. het creëert alleen een nieuwe variabele die de referentie van het oorspronkelijke object deelt.
laten we een voorbeeld nemen waar we een lijst maken met de naam old_list en een objectverwijzing doorgeven aan new_list met behulp van = operator.,
Voorbeeld 1: kopiëren met behulp van = operator
wanneer we bovenstaand programma uitvoeren, zal de uitvoer zijn:
Old List: , , ]ID of Old List: 140673303268168New List: , , ]ID of New List: 140673303268168
zoals u kunt zien aan de uitvoer delen beide variabelen old_list en new_list dezelfde id dat wil zeggen 140673303268168.
dus, als u waarden in new_list of old_list wilt wijzigen, is de verandering zichtbaar in beide.
in wezen wilt u soms de oorspronkelijke waarden ongewijzigd laten en alleen de nieuwe waarden wijzigen of omgekeerd., In Python zijn er twee manieren om kopieën te maken:
- ondiepe kopie
- diepe kopie
om deze kopie te laten werken, gebruiken we de copy module.
Kopieermodule
we gebruiken de copy module van Python voor ondiepe en diepe kopieeroperaties. Stel dat u de samengestelde lijst moet kopiëren, zeg x. bijvoorbeeld:
import copycopy.copy(x)copy.deepcopy(x)
Hier geeft de copy() een ondiepe kopie van x terug. evenzo geeft deepcopy() een diepe kopie van x terug.,
ondiepe kopie
een ondiepe kopie maakt een nieuw object aan dat de referentie van de oorspronkelijke elementen opslaat.
dus, een ondiepe kopie maakt geen kopie van geneste objecten, in plaats daarvan kopieert het alleen de referentie van geneste objecten. Dit betekent dat een kopieerproces zelf geen kopieën van geneste objecten recurseert of maakt.,
Voorbeeld 2: Maak een kopie met behulp van shallow copy
import copyold_list = , , ]new_list = copy.copy(old_list)print("Old list:", old_list)print("New list:", new_list)wanneer we het programma uitvoeren , zal de uitvoer zijn:
Old list: , , ]New list: , , ]
in het bovenstaande programma hebben we een geneste lijst gemaakt en vervolgens ondiep kopiëren met behulp van copy() methode.
Dit betekent dat het een nieuw en onafhankelijk object met dezelfde inhoud zal aanmaken. Om dit te verifiëren, printen we zowel de old_list als de new_list.,
om te bevestigen dat new_list verschilt van old_list, proberen we een nieuw genest object aan het origineel toe te voegen en dit te controleren.
Voorbeeld 3: toevoegen aan old_list, met behulp van ondiepe kopie
wanneer we het programma uitvoeren, zal het uitvoeren:
Old list: , , , ]New list: , , ]
in het bovenstaande programma hebben we een ondiepe kopie van old_list gemaakt. De new_list bevat verwijzingen naar originele geneste objecten opgeslagen in old_list. Vervolgens voegen we de nieuwe lijst toe, namelijk in old_list., Deze nieuwe sublijst is niet gekopieerd in new_list.
echter, wanneer u geneste objecten in old_list wijzigt, verschijnen de wijzigingen in new_list.
Voorbeeld 4: nieuw genest object toevoegen met behulp van ondiepe kopie
import copyold_list = , , ]new_list = copy.copy(old_list)old_list = 'AA'print("Old list:", old_list)print("New list:", new_list)wanneer we het programma uitvoeren, zal het uitvoeren:
Old list: , , ]New list: , , ]
Deep Copy
een diepe kopie maakt een nieuw object en voegt recursief de kopieën toe van geneste objecten die aanwezig zijn in de originele elementen.
laten we doorgaan met voorbeeld 2., Echter, we gaan diepe kopie maken met behulp van deepcopy()functie aanwezig in copy module. De diepe kopie maakt een onafhankelijke kopie van het originele object en al zijn geneste objecten.
Voorbeeld 5: een lijst kopiëren met behulp van deepcopy()
wanneer we het programma uitvoeren, zal het uitvoeren:
Old list: , , ]New list: , , ]
in het bovenstaande programma gebruiken we deepcopy() functie om een kopie te maken die er vergelijkbaar uitziet.,
echter, als u wijzigingen aanbrengt in geneste objecten in originele object old_list, zult u geen wijzigingen zien in de kopie new_list.
Voorbeeld 6: Het toevoegen van een nieuw genest object in de lijst met behulp van Deep copy
wanneer we het programma uitvoeren, zal het uitvoeren:
Old list: , , ]New list: , , ]
in het bovenstaande programma, wanneer we een nieuwe waarde toewijzen aan old_list, kunnen we zien dat alleen de old_list wordt gewijzigd. Dit betekent dat zowel de old_list als de new_list onafhankelijk zijn. Dit komt omdat de old_list recursief werd gekopieerd, wat geldt voor alle geneste objecten.
