U ovom ćete članku uz primjere naučiti o plitkoj kopiji i dubinskoj kopiji u Pythonu.
Kopirajte objekt u Pythonu
U Pythonu koristimo =
operator za stvaranje kopije objekta. Možda mislite da ovo stvara novi objekt; nije. Stvara samo novu varijablu koja dijeli referencu izvornog objekta.
Uzmimo primjer gdje kreiramo popis s imenom old_list i prenosimo referencu objekta na new_list pomoću =
operatora.
Primjer 1: Kopirajte pomoću = operatora
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))
Kada pokrenemo gornji program, izlaz će biti:
Stari popis: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID starog popisa: 140673303268168 Novi popis: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID novog popisa: 140673303268168
Kao što možete vidjeti iz rezultata, i varijable old_list i new_list dijele isti id, tj 140673303268168
.
Dakle, ako želite izmijeniti bilo koju vrijednost na new_list ili old_list, promjena je vidljiva na oba.
U osnovi, ponekad ćete možda htjeti da izvorne vrijednosti budu nepromijenjene i samo modificirate nove vrijednosti ili obrnuto. U Pythonu postoje dva načina za stvaranje kopija:
- Plitka kopija
- Duboka kopija
Da bi ove kopije funkcionirale, koristimo copy
modul.
Kopiraj modul
Koristimo copy
modul Pythona za operacije plitkog i dubokog kopiranja. Pretpostavimo da morate kopirati složeni popis recimo x. Na primjer:
uvoz kopija copy.copy (x) copy.deepcopy (x)
Ovdje se copy()
vraća plitka kopija x. Slično tome, deepcopy()
vratite dubinsku kopiju x.
Plitka kopija
Plitka kopija stvara novi objekt koji pohranjuje referencu izvornih elemenata.
Dakle, plitka kopija ne stvara kopiju ugniježđenih objekata, već samo kopira referencu ugniježđenih objekata. To znači da se postupak kopiranja ne ponavlja niti stvara sam kopije ugniježđenih objekata.
Primjer 2: Stvorite kopiju pomoću 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)
Kada pokrenemo program, izlaz će biti:
Stari popis: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Novi popis: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
U gornjem programu stvorili smo ugniježđeni popis, a zatim ga površno kopirali copy()
metodom.
To znači da će stvoriti novi i neovisni objekt s istim sadržajem. Da bismo to provjerili, ispisujemo i stari_popis i novi_popis.
Da bismo potvrdili da se new_list razlikuje od old_list, pokušavamo dodati novi ugniježđeni objekt u izvornik i provjeriti ga.
Primjer 3: Dodavanje (4, 4, 4) na stari_popis pomoću 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)
Kada pokrenemo program, on će dati:
Stari popis: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Novi popis: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
U gornjem programu stvorili smo plitku kopiju old_list. New_list sadrži reference na izvorne ugniježđene objekte pohranjene u old_list. Zatim dodajemo novi popis, tj. (4, 4, 4)
U stari_popis. Ovaj novi popis nije kopiran na new_list.
Međutim, kada promijenite ugniježđene objekte u old_list, promjene će se pojaviti u new_list.
Primjer 4: Dodavanje novog ugniježđenog objekta pomoću 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)
Kada pokrenemo program, on će dati:
Stari popis: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Novi popis: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
U gore navedenom programu izvršili smo promjene na old_list tj old_list(1)(1) = 'AA'
. Izmijenjene su i podlistke starog i novog popisa na indeksu (1)(1)
. To je zato što oba popisa dijele referencu istih ugniježđenih objekata.
Duboka kopija
Dubinska kopija stvara novi objekt i rekurzivno dodaje kopije ugniježđenih objekata prisutnih u izvornim elementima.
Nastavimo s primjerom 2. Međutim, stvorit ćemo dubinsku kopiju pomoću deepcopy()
funkcije prisutne u copy
modulu. Dubinska kopija stvara neovisnu kopiju izvornog objekta i svih njegovih ugniježđenih objekata.
Primjer 5: Kopiranje popisa pomoću duboke kopije ()
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)
Kada pokrenemo program, on će dati:
Stari popis: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Novi popis: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
U gore navedenom programu koristimo deepcopy()
funkciju za stvaranje kopije koja izgleda slično.
Međutim, ako napravite promjene na bilo kojem ugniježđenim objektima na izvornom objektu old_list, nećete vidjeti promjene na kopiji new_list.
Primjer 6: Dodavanje novog ugniježđenog objekta na popis pomoću dubinske 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)
Kada pokrenemo program, on će dati:
Stari popis: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Novi popis: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
U gornjem programu, kada dodamo novu vrijednost starom_popisu, možemo vidjeti da je samo izmijenjen stari_popis. To znači da su i stari_popis i novi_popis neovisni. To je zato što je stari_popis rekurzivno kopiran, što vrijedi za sve njegove ugniježđene objekte.