V tem članku boste s pomočjo primerov spoznali plitvo kopijo in globoko kopijo v Pythonu.
Kopirajte predmet v Python
V Pythonu z =operatorjem ustvarimo kopijo predmeta. Morda mislite, da to ustvarja nov objekt; ne. Ustvari samo novo spremenljivko, ki deli sklic na prvotni objekt.
Vzemimo primer, kjer ustvarimo seznam z imenom old_list in z =operatorjem posredujemo sklic na objekt new_list .
Primer 1: Kopirajte z operatorjem =
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))
Ko zaženemo nad programom, bo rezultat:
Stari seznam: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID starega seznama: 140673303268168 Nov seznam: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID novega seznama: 140673303268168
Kot lahko vidite iz izhoda, imata tako spremenljivki old_list in new_list enak id, tj 140673303268168.
Torej, če želite spremeniti katere koli vrednosti v new_list ali old_list, je sprememba vidna v obeh.
V bistvu boste včasih morda želeli, da bodo prvotne vrednosti nespremenjene in samo spremeniti nove vrednosti ali obratno. V Pythonu lahko na dva načina ustvarite kopije:
- Plitva kopija
- Globoka kopija
Da bi te kopije delovale, uporabljamo copymodul.
Modul za kopiranje
Uporabljamo copymodul Python za plitvo in globoko kopijo poslovanja. Recimo, da morate kopirati sestavljeni seznam, recimo x. Na primer:
uvoz kopija copy.copy (x) copy.deepcopy (x)
Tu copy()vrnemo plitvo kopijo x. Podobno deepcopy()vrnite globoko kopijo x.
Plitva kopija
Plitka kopija ustvari nov predmet, ki shrani sklic na prvotne elemente.
Torej, plitva kopija ne ustvari kopije ugnezdenih predmetov, temveč samo kopira sklic ugnezdenih predmetov. To pomeni, da se postopek kopiranja ne ponovi ali sam ustvari kopij ugnezdenih predmetov.
2. primer: Ustvarite kopijo z uporabo plitke kopije
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)
Ko zaženemo program, bo rezultat:
Stari seznam: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Nov seznam: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
V zgornjem programu smo ustvarili ugnezdeni seznam in ga nato plitko kopirali z copy()metodo.
To pomeni, da bo ustvaril nov in neodvisen predmet z enako vsebino. Da bi to preverili, natisnemo stari in novi.
Da potrdimo, da se new_list razlikuje od old_list, poskušamo dodati nov ugnezdeni objekt v izvirnik in ga preveriti.
Primer 3: Dodajanje (4, 4, 4) na old_list z uporabo plitke kopije
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)
Ko zaženemo program, bo izpisal:
Stari seznam: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Nov seznam: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
V zgornjem programu smo ustvarili plitvo kopijo old_list. New_list vsebuje sklice na izvirne ugnezdene predmete, shranjene v old_list. Nato dodamo nov seznam, tj. (4, 4, 4)V old_list. Ta novi podlist ni bil kopiran na new_list.
Ko pa spremenite ugnezdene predmete v old_list, se spremembe prikažejo v new_list.
Primer 4: Dodajanje novega ugnezdenega predmeta z uporabo Plitke kopije
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)
Ko zaženemo program, bo izpisal:
Stari seznam: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Nov seznam: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
V zgornjem programu smo spremenili old_list tj old_list(1)(1) = 'AA'. Spremenjena sta bila oba podlistka old_list in new_list at index (1)(1). To je zato, ker imata oba seznama sklic na iste ugnezdene predmete.
Globoka kopija
Globoka kopija ustvari nov objekt in rekurzivno doda kopije ugnezdenih predmetov, ki so prisotne v izvirnih elementih.
Nadaljujmo s primerom 2. Vendar bomo ustvarili globoko kopijo z uporabo deepcopy()funkcije, ki je prisotna v copymodulu. Globoka kopija ustvari neodvisno kopijo izvirnega predmeta in vseh njegovih ugnezdenih predmetov.
Primer 5: Kopiranje seznama z uporabo 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)
Ko zaženemo program, bo izpisal:
Stari seznam: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Nov seznam: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
V zgornjem programu s deepcopy()funkcijo ustvarimo kopijo, ki je videti podobno.
Če pa spremenite kateri koli ugnezdeni predmeti na prvotnem predmetu old_list, ne boste videli sprememb na kopiji new_list.
Primer 6: Dodajanje novega ugnezdenega predmeta na seznam s pomočjo globoke kopije
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)
Ko zaženemo program, bo izpisal:
Stari seznam: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Nov seznam: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Ko v zgornjem programu dodamo novo vrednost old_list, lahko vidimo, da je spremenjen le old_list. To pomeni, da sta stari in novi seznam neodvisna. To je zato, ker je bil stari_list rekurzivno kopiran, kar velja za vse njegove ugnezdene predmete.
