I denne artikel lærer du om lav kopi og dyb kopi i Python ved hjælp af eksempler.
Kopier et objekt i Python
I Python bruger vi =operator til at oprette en kopi af et objekt. Du tror måske, at dette skaber et nyt objekt; det gør det ikke. Det opretter kun en ny variabel, der deler referencen for det originale objekt.
Lad os tage et eksempel, hvor vi opretter en liste med navnet old_list og sender en objektreference til new_list ved hjælp af =operator.
Eksempel 1: Kopier ved hjælp af = 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 kører over programmet, vil output være:
Gammel liste: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID for gammel liste: 140673303268168 Ny liste: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID for ny liste: 140673303268168
Som du kan se fra output begge variabler old_list og new_list deler samme id dvs 140673303268168.
Så hvis du vil ændre værdier i new_list eller old_list, er ændringen synlig i begge.
I det væsentlige vil du nogle gange måske have de oprindelige værdier uændrede og kun ændre de nye værdier eller omvendt. I Python er der to måder at oprette kopier på:
- Lav kopi
- Dyb kopi
For at få disse kopier til at fungere bruger vi copymodulet.
Kopier modul
Vi bruger copyPython-modulet til lave og dybe kopieringsoperationer. Antag, at du er nødt til at kopiere sammensatte listen siger x. For eksempel:
importer kopi kopi.kopi (x) kopi.deepkopi (x)
Her copy()returneres en lav kopi af x. Tilsvarende skal du deepcopy()returnere en dyb kopi af x.
Lav kopi
En lav kopi opretter et nyt objekt, der gemmer henvisningen til de originale elementer.
Så en lav kopi opretter ikke en kopi af indlejrede objekter, i stedet kopierer den bare referencen for indlejrede objekter. Dette betyder, at en kopiproces ikke reproducerer eller opretter kopier af indlejrede objekter i sig selv.
Eksempel 2: Opret en kopi ved hjælp af lav kopi
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 kører programmet, vil output 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 ovennævnte program oprettede vi en indlejret liste og kopierede den derefter ved hjælp af copy()metoden.
Dette betyder, at det vil skabe nyt og uafhængigt objekt med samme indhold. For at bekræfte dette udskriver vi både old_list og new_list.
For at bekræfte, at new_list er forskellig fra old_list, prøver vi at tilføje nyt indlejret objekt til originalen og kontrollere det.
Eksempel 3: Tilføjelse (4, 4, 4) til old_list ved hjælp af lav kopi
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 kører programmet, udsendes det:
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 ovenstående program oprettede vi en lav kopi af old_list. Den nye_liste indeholder henvisninger til originale indlejrede objekter, der er gemt i den gamle_liste. Derefter tilføjer vi den nye liste, dvs. (4, 4, 4)i old_list. Denne nye subliste blev ikke kopieret til new_list.
Men når du ændrer indlejrede objekter i old_list, vises ændringerne i new_list.
Eksempel 4: Tilføjelse af nyt indlejret objekt ved hjælp af 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 kører programmet, udsendes det:
Gammel liste: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Ny liste: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
I ovenstående program lavede vi ændringer til old_list ie old_list(1)(1) = 'AA'. Begge underlister til old_list og new_list at index (1)(1)blev ændret. Dette skyldes, at begge lister deler referencen for de samme indlejrede objekter.
Dyb kopi
En dyb kopi opretter et nyt objekt og tilføjer rekursivt kopierne af indlejrede objekter, der findes i de originale elementer.
Lad os fortsætte med eksempel 2. Vi skal dog oprette dyb kopi ved hjælp af deepcopy()funktionen til stede i copymodulet. Den dybe kopi opretter uafhængig kopi af det originale objekt og alle dets indlejrede objekter.
Eksempel 5: Kopiering af en liste ved hjælp af 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)
Når vi kører programmet, udsendes det:
Gammel liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Ny liste: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
I ovenstående program bruger vi deepcopy()funktionen til at oprette en kopi, der ligner hinanden.
Men hvis du foretager ændringer i indlejrede objekter i det originale objekt old_list, ser du ingen ændringer i kopien new_list.
Eksempel 6: Tilføjelse af et nyt indlejret objekt på listen ved hjælp af 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 kører programmet, udsendes det:
Gammel liste: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Ny liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
I ovenstående program, når vi tildeler en ny værdi til old_list, kan vi kun se den old_list er ændret. Dette betyder, at både den gamle liste og den nye liste er uafhængige. Dette skyldes, at den gamle_liste blev kopieret rekursivt, hvilket er sandt for alle dets indlejrede objekter.
