In questo articolo imparerai la copia superficiale e la copia completa in Python con l'aiuto di esempi.
Copia un oggetto in Python
In Python, usiamo =operator per creare una copia di un oggetto. Potresti pensare che questo crei un nuovo oggetto; non è così. Crea solo una nuova variabile che condivide il riferimento dell'oggetto originale.
Facciamo un esempio in cui creiamo un elenco denominato old_list e passiamo un riferimento a un oggetto a new_list utilizzando l' =operatore.
Esempio 1: copiare utilizzando l'operatore =
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))
Quando eseguiamo il programma sopra, l'output sarà:
Vecchia lista: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID della vecchia lista: 140673303268168 Nuova lista: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID del nuovo elenco: 140673303268168
Come puoi vedere dall'output, entrambe le variabili old_list e new_list condividono lo stesso id, ad es 140673303268168.
Quindi, se vuoi modificare qualsiasi valore in new_list o old_list, la modifica è visibile in entrambi.
In sostanza, a volte potresti voler mantenere 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 copymodulo.
Modulo di copia
Usiamo il copymodulo di Python per operazioni di copia superficiale e profonda. Supponi di dover copiare l'elenco dei composti, dire x. Per esempio:
import copy copy.copy (x) copy.deepcopy (x)
Qui, copy()restituisce una copia superficiale di x. Allo stesso modo, deepcopy()restituisci una copia completa 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 semplicemente il riferimento di oggetti nidificati. Ciò significa che un processo di copia non ricorre né crea copie di oggetti annidati.
Esempio 2: creare una copia utilizzando la copia superficiale
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)
Quando eseguiamo il programma, l'output sarà:
Vecchio elenco: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Nuovo elenco: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
Nel programma sopra, abbiamo creato un elenco nidificato e poi lo abbiamo copiato in modo superficiale usando il copy()metodo.
Ciò significa che creerà un oggetto nuovo e indipendente con lo stesso contenuto. Per verificarlo, stampiamo sia old_list che new_list.
Per confermare che new_list è diverso da old_list, proviamo ad aggiungere un nuovo oggetto annidato all'originale e controllarlo.
Esempio 3: aggiunta di (4, 4, 4) a old_list, utilizzando una copia superficiale
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)
Quando eseguiamo il programma, verrà visualizzato:
Vecchio elenco: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Nuovo elenco: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
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è (4, 4, 4)in old_list. Questa nuova sottolista non è stata copiata in new_list.
Tuttavia, quando si modificano gli oggetti nidificati in old_list, le modifiche vengono visualizzate in new_list.
Esempio 4: aggiunta di un nuovo oggetto nidificato utilizzando la copia superficiale
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)
Quando eseguiamo il programma, verrà visualizzato:
Vecchio elenco: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Nuovo elenco: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Nel programma sopra, abbiamo apportato modifiche a old_list ie old_list(1)(1) = 'AA'. Entrambe le sottoliste di old_list e new_list at index (1)(1)sono state modificate. Questo perché entrambi gli elenchi condividono il riferimento degli stessi oggetti nidificati.
Copia profonda
Una copia completa crea un nuovo oggetto e aggiunge in modo ricorsivo le copie degli oggetti nidificati presenti negli elementi originali.
Continuiamo con l'esempio 2. Tuttavia, creeremo una copia completa utilizzando la deepcopy()funzione presente nel copymodulo. La copia completa crea una copia indipendente dell'oggetto originale e di tutti i suoi oggetti annidati.
Esempio 5: copia di un elenco utilizzando 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)
Quando eseguiamo il programma, verrà visualizzato:
Vecchio elenco: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Nuovo elenco: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
Nel programma sopra, usiamo la deepcopy()funzione per creare una copia simile.
Tuttavia, se apporti modifiche a qualsiasi oggetto nidificato nell'oggetto originale old_list, non vedrai modifiche alla copia new_list.
Esempio 6: aggiunta di un nuovo oggetto nidificato nell'elenco utilizzando 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)
Quando eseguiamo il programma, verrà visualizzato:
Vecchio elenco: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Nuovo elenco: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Nel programma sopra, quando assegniamo un nuovo valore a old_list, possiamo vedere che viene modificato solo il old_list. 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.
