În acest articol, veți afla despre copierea superficială și copia profundă în Python cu ajutorul exemplelor.
Copiați un obiect în Python
În Python, folosim =operatorul pentru a crea o copie a unui obiect. S-ar putea să credeți că acest lucru creează un obiect nou; nu. Creează doar o nouă variabilă care împărtășește referința obiectului original.
Să luăm un exemplu în care creăm o listă numită listă_vechi și trecem o referință de obiect la listă_nou folosind =operatorul.
Exemplul 1: Copiați folosind = 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))
Când rulăm deasupra programului, ieșirea va fi:
Lista veche: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID-ul listei vechi: 140673303268168 Lista nouă: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID-ul listei noi: 140673303268168
După cum puteți vedea din ieșire, ambele variabile old_list și new_list au același id, adică 140673303268168.
Deci, dacă doriți să modificați orice valori din lista_ nouă sau lista_vechi, modificarea este vizibilă în ambele.
În esență, uneori poate doriți să aveți valorile originale neschimbate și să modificați doar valorile noi sau invers. În Python, există două moduri de a crea copii:
- Copie superficială
- Deep Copy
Pentru ca aceste copii să funcționeze, folosim copymodulul.
Modul de copiere
Folosim copymodulul Python pentru operații de copiere superficială și profundă. Să presupunem că trebuie să copiați lista compusă spuneți x. De exemplu:
import copie copy.copy (x) copy.deepcopy (x)
Aici, copy()returnează o copie superficială a lui x. În mod similar, deepcopy()returnați o copie profundă a lui x.
Copie superficială
O copie superficială creează un nou obiect care stochează referința elementelor originale.
Deci, o copie superficială nu creează o copie a obiectelor imbricate, ci doar copiază referința obiectelor imbricate. Aceasta înseamnă că un proces de copiere nu recurge sau creează în sine copii ale obiectelor imbricate.
Exemplul 2: Creați o copie utilizând o copie superficială
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)
Când rulăm programul, ieșirea va fi:
Lista veche: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Lista nouă: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
În programul de mai sus, am creat o listă imbricată și apoi o copiem superficial folosind copy()metoda.
Aceasta înseamnă că va crea un obiect nou și independent cu același conținut. Pentru a verifica acest lucru, imprimăm atât lista_vechi, cât și lista_ nouă.
Pentru a confirma că noua_listă este diferită de vechea_listă, încercăm să adăugăm un nou obiect imbricat în original și să-l verificăm.
Exemplul 3: Adăugarea (4, 4, 4) la lista_vechi, folosind o copie superficială
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)
Când rulăm programul, acesta va genera:
Lista veche: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Lista nouă: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
În programul de mai sus, am creat o copie superficială a listei_vechi. New_list conține referințe la obiecte originale imbricate stocate în old_list. Apoi adăugăm noua listă, adică (4, 4, 4)în lista_vechi. Această nouă sublistă nu a fost copiată în lista_nouă.
Cu toate acestea, atunci când modificați orice obiecte imbricate în lista_vechi, modificările apar în lista_nouă.
Exemplul 4: Adăugarea unui nou obiect imbricat utilizând copierea Shallow
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)
Când rulăm programul, acesta va genera:
Lista veche: ((1, 1, 1), (2, „AA”, 2), (3, 3, 3)) Lista nouă: ((1, 1, 1), (2, „AA”, 2 ), (3, 3, 3))
În programul de mai sus, am făcut modificări la vechea_listă, adică old_list(1)(1) = 'AA'. Ambele subliste de listă_vechi și listă_nouă la index (1)(1)au fost modificate. Acest lucru se datorează faptului că ambele liste împărtășesc referința acelorași obiecte imbricate.
Deep Copy
O copie profundă creează un obiect nou și adaugă recursiv copiile obiectelor imbricate prezente în elementele originale.
Să continuăm cu exemplul 2. Cu toate acestea, vom crea o copie profundă folosind deepcopy()funcția prezentă în copymodul. Copia profundă creează o copie independentă a obiectului original și a tuturor obiectelor sale imbricate.
Exemplul 5: Copierea unei liste folosind 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)
Când rulăm programul, acesta va genera:
Lista veche: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Lista nouă: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
În programul de mai sus, folosim deepcopy()funcția pentru a crea o copie care arată similar.
Cu toate acestea, dacă faceți modificări la orice obiecte imbricate în obiectul original old_list, nu veți vedea nicio modificare a copiei new_list.
Exemplul 6: Adăugarea unui nou obiect imbricat în listă folosind 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)
Când rulăm programul, acesta va genera:
Lista veche: ((1, 1, 1), („BB”, 2, 2), (3, 3, 3)) Lista nouă: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
În programul de mai sus, când atribuim o nouă valoare listei_vechi, putem vedea doar modificarea listei_vechi. Aceasta înseamnă că atât lista_vechi, cât și lista_ nouă sunt independente. Acest lucru se datorează faptului că vechea listă a fost copiată recursiv, ceea ce este adevărat pentru toate obiectele sale imbricate.
