Python Shallow Copy and Deep Copy (Italiano)
Copia un oggetto in Python
In Python, usiamo = operatore per creare una copia di un oggetto. Potresti pensare che questo crei un nuovo oggetto; non lo fa. Crea solo una nuova variabile che condivide il riferimento dell’oggetto originale.
Facciamo un esempio in cui creiamo una lista chiamata old_list e passiamo un riferimento all’oggetto a new_list usando l’operatore=.,
Esempio 1: Copia usando = operatore
Quando eseguiamo sopra il programma, l’output sarà:
Old List: , , ]ID of Old List: 140673303268168New List: , , ]ID of New List: 140673303268168
Come puoi vedere dall’output entrambe le variabili old_list e new_list condividono lo stesso id cioè140673303268168.
Quindi, se vuoi modificare qualsiasi valore in new_list o old_list, la modifica è visibile in entrambi.
In sostanza, a volte potresti voler avere i valori originali invariati e modificare solo i nuovi valori o viceversa., In Python, ci sono due modi per creare copie:
- Copia superficiale
- Copia profonda
Per far funzionare queste copie, usiamo il modulocopy.
Modulo di copia
Usiamo ilcopy modulo di Python per operazioni di copia superficiale e profonda. Supponiamo, è necessario copiare l’elenco composto dire x. Ad esempio:
import copycopy.copy(x)copy.deepcopy(x)
Qui, il copy() restituisce una copia superficiale di x. Allo stesso modo, deepcopy() restituisce una copia profonda di x.,
Copia superficiale
Una copia superficiale crea un nuovo oggetto che memorizza il riferimento degli elementi originali.
Quindi, una copia superficiale non crea una copia di oggetti nidificati, ma copia solo il riferimento di oggetti nidificati. Ciò significa che un processo di copia non ricorre o crea copie di oggetti nidificati stessi.,
Esempio 2: Creare una copia utilizzando una copia superficiale
import copyold_list = , , ]new_list = copy.copy(old_list)print("Old list:", old_list)print("New list:", new_list)Quando si esegue il programma , l’output sarà:
Old list: , , ]New list: , , ]
Nel programma di cui sopra, abbiamo creato un elenco nidificato e poi copia superficiale utilizzando copy() metodo.
Ciò significa che creerà un oggetto nuovo e indipendente con lo stesso contenuto. Per verificare questo, stampiamo sia old_list che new_list.,
Per confermare che new_list è diverso da old_list, proviamo ad aggiungere un nuovo oggetto nidificato all’originale e controllarlo.
Esempio 3: Aggiunta a old_list, usando shallow copy
Quando eseguiamo il programma, produrrà:
Old list: , , , ]New list: , , ]
Nel programma sopra, abbiamo creato una copia superficiale di old_list. new_list contiene riferimenti a oggetti nidificati originali memorizzati in old_list. Quindi aggiungiamo la nuova lista cioè in old_list., Questa nuova sottolista non è stata copiata in new_list.
Tuttavia, quando si modificano oggetti nidificati in old_list, le modifiche vengono visualizzate in new_list.
Esempio 4: Aggiunta di un nuovo oggetto nidificato usando Shallow copy
import copyold_list = , , ]new_list = copy.copy(old_list)old_list = 'AA'print("Old list:", old_list)print("New list:", new_list)Quando eseguiamo il programma, verrà emesso:
Old list: , , ]New list: , , ]
Deep Copy
Una deep copy crea un nuovo oggetto e aggiunge ricorsivamente le copie degli oggetti nidificati presenti negli elementi originali.
Continuiamo con l’esempio 2., Tuttavia, creeremo una copia profonda utilizzando la funzionedeepcopy() presente nel modulocopy. La copia profonda crea una copia indipendente dell’oggetto originale e di tutti i suoi oggetti nidificati.
Esempio 5: Copia di un elenco utilizzando deepcopy ()
import copyold_list = , , ]new_list = copy.deepcopy(old_list)print("Old list:", old_list)print("New list:", new_list)Quando eseguiamo il programma, verrà emesso:
Old list: , , ]New list: , , ]
Nel programma precedente, usiamodeepcopy() funzione per creare copia che sembra simile.,
Tuttavia, se si apportano modifiche a qualsiasi oggetto nidificato nell’oggetto originale old_list, non verranno visualizzate modifiche alla copia new_list.
Esempio 6: Aggiungere un nuovo oggetto annidato nell’elenco usando Deep copy
Quando eseguiamo il programma, verrà emesso:
Old list: , , ]New list: , , ]
Nel programma sopra, quando assegniamo un nuovo valore a old_list, possiamo vedere solo che old_list è modificato. Ciò significa che sia old_list che new_list sono indipendenti. Questo perché old_list è stato copiato ricorsivamente, il che è vero per tutti i suoi oggetti nidificati.
