I denne artikkelen vil du lære om grunne kopier og dype kopier i Python ved hjelp av eksempler.
Kopier et objekt i Python
I Python bruker vi =operator for å lage en kopi av et objekt. Du tror kanskje at dette skaper et nytt objekt; det gjør det ikke. Det oppretter bare en ny variabel som deler referansen til det opprinnelige objektet.
La oss ta et eksempel der vi oppretter en liste med navnet old_list og sender en objektreferanse til new_list ved hjelp av =operator.
Eksempel 1: Kopier med = 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))
Når vi kjører over programmet, vil utgangen være:
Old List: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID of Old List: 140673303268168 New List: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID for ny liste: 140673303268168
Som du kan se fra utgangs begge variablene old_list og new_list deler samme id si 140673303268168.
Så hvis du vil endre verdier i new_list eller old_list, er endringen synlig i begge.
I utgangspunktet kan det være lurt å ha de opprinnelige verdiene uendret og bare endre de nye verdiene eller omvendt. I Python er det to måter å lage kopier på:
- Grunn kopi
- Dyp kopi
For å få disse kopiene til å fungere, bruker vi copymodulen.
Kopimodul
Vi bruker copyPython-modulen for grunne og dype kopieringsoperasjoner. Anta at du må kopiere sammensatt liste si x. For eksempel:
importer kopi kopi.kopi (x) kopi.deepkopi (x)
Her copy()returneres en grunne kopi av x. Tilsvarende, deepcopy()returner en dyp kopi av x.
Grunn kopi
En grunne kopi lager et nytt objekt som lagrer referansen til de originale elementene.
Så, en grunne kopi oppretter ikke en kopi av nestede objekter, men kopierer bare referansen til nestede objekter. Dette betyr at en kopiprosess ikke gjengir eller lager kopier av nestede objekter selv.
Eksempel 2: Lag en kopi ved hjelp av grunne kopier
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)
Når vi kjører programmet, vil utdataene være:
Gammel liste: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Ny liste: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
I ovennevnte program opprettet vi en nestet liste og kopier den deretter med copy()grunngjeng.
Dette betyr at det vil skape et nytt og uavhengig objekt med samme innhold. For å bekrefte dette, skriver vi ut både old_list og new_list.
For å bekrefte at new_list er forskjellig fra old_list, prøver vi å legge til nytt nestet objekt i originalen og sjekke det.
Eksempel 3: Legge til (4, 4, 4) til old_list, ved hjelp av grunne kopier
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)
Når vi kjører programmet, vil det sende ut:
Gammel liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Ny liste: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
I programmet ovenfor opprettet vi en grunne kopi av old_list. Den nye listen inneholder referanser til originale nestede objekter som er lagret i den gamle listen. Deretter legger vi til den nye listen, dvs. (4, 4, 4)i old_list. Denne nye underlisten ble ikke kopiert i den nye listen.
Men når du endrer nestede objekter i old_list, vises endringene i new_list.
Eksempel 4: Legge til nytt nestet objekt ved hjelp av Shallow copy
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)
Når vi kjører programmet, vil det sende ut:
Gammel liste: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Ny liste: ((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.
Imidlertid, hvis du gjør endringer i nestede objekter i originalobjektet old_list, ser du ingen endringer i kopien new_list.
Eksempel 6: Legge til et nytt nestet objekt i listen ved hjelp av 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)
Når vi kjører programmet, vil det sende ut:
Gammel liste: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Ny liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
I det ovennevnte programmet, når vi tildeler en ny verdi til old_list, kan vi se bare old_list er endret. Dette betyr at både den gamle listen og den nye listen er uavhengige. Dette er fordi den gamle_listen ble rekursivt kopiert, noe som gjelder for alle nestede objekter.
