Python Shallow Copy y Deep Copy
copie un objeto en Python
en Python, usamos el operador = para crear una copia de un objeto. Usted puede pensar que esto crea un nuevo objeto; no. Sólo se crea una nueva variable que comparte la referencia del objeto original.
tomemos un ejemplo donde creamos una lista llamada old_list y pasamos una referencia de objeto a new_list usando el operador =.,
ejemplo 1: Copy using = operator
cuando ejecutamos el programa anterior, la salida será:
Old List: , , ]ID of Old List: 140673303268168New List: , , ]ID of New List: 140673303268168
como puede ver en la salida, ambas variables old_list y new_list comparten el mismo id, es decir,140673303268168.
por lo tanto, si desea modificar cualquier valor en new_list o old_list, el cambio es visible en ambos.
esencialmente, a veces es posible que desee tener los valores originales sin cambios y solo modificar los nuevos valores o viceversa., En Python, hay dos formas de crear copias:
- Shallow Copy
- Deep Copy
para hacer que estas copias funcionen, usamos el módulo copy.
Copy Module
utilizamos el módulo copy de Python para operaciones de copia superficiales y profundas. Supongamos que necesita copiar la lista compuesta X. por ejemplo:
import copycopy.copy(x)copy.deepcopy(x)
Aquí, el copy()devuelve una copia superficial de x. del mismo modo,deepcopy() devuelve una copia profunda de x.,
Copia Superficial
Una copia superficial crea un nuevo objeto que almacena la referencia de los elementos originales.
Por lo tanto, una copia superficial no crea una copia de objetos anidados, sino que simplemente copia la referencia de los objetos anidados. Esto significa que un proceso de copia no recurre ni crea copias de objetos anidados.,
Ejemplo 2: Crear una copia con copia superficial
import copyold_list = , , ]new_list = copy.copy(old_list)print("Old list:", old_list)print("New list:", new_list)Cuando se ejecute el programa , la salida será:
Old list: , , ]New list: , , ]
En el programa anterior, hemos creado una lista anidada y, a continuación, copia superficial utilizando copy() método.
esto significa que creará un objeto nuevo e independiente con el mismo contenido. Para verificar esto, imprimimos tanto old_list como new_list.,
Para confirmar que new_list es diferente de old_list, tratamos de añadir nuevo objeto anidado a la original y comprobarlo.
Ejemplo 3: Agregar a old_list, usando shallow copy
cuando ejecutamos el programa, producirá:
Old list: , , , ]New list: , , ]
en el programa anterior, creamos una copia shallow de old_list. New_list contiene referencias a objetos anidados originales almacenados en old_list. Luego agregamos la nueva lista, es decir, en old_list., Esta nueva sublist no se copió en new_list.
sin embargo, cuando cambia cualquier objeto anidado en old_list, los cambios aparecen en new_list.
Ejemplo 4: Agregar un nuevo objeto anidado 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)cuando ejecutamos el programa, producirá:
Old list: , , ]New list: , , ]
Deep Copy
una copia profunda crea un nuevo objeto y agrega recursivamente las copias de los objetos anidados presentes en los elementos originales.
continuemos con el ejemplo 2., Sin embargo, vamos a crear una copia profunda usando la función deepcopy() presente en el módulo copy. La copia profunda crea una copia independiente del objeto original y todos sus objetos anidados.
ejemplo 5: copiando una lista usando deepcopy ()
import copyold_list = , , ]new_list = copy.deepcopy(old_list)print("Old list:", old_list)print("New list:", new_list)cuando ejecutamos el programa, producirá:
Old list: , , ]New list: , , ]
en el programa anterior, usamos la funcióndeepcopy() para crear una copia que se vea similar.,
sin embargo, si realiza cambios en cualquier objeto anidado en la old_list del objeto original, no verá cambios en la nueva lista de copia.
ejemplo 6: Agregar un nuevo objeto anidado en la lista usando Deep copy
cuando ejecutamos el programa, producirá:
Old list: , , ]New list: , , ]
en el programa anterior, cuando asignamos un nuevo valor a old_list, podemos ver que solo se modifica la old_list. Esto significa que tanto la old_list como la new_list son independientes. Esto se debe a que la old_list se copió recursivamente, lo que es cierto para todos sus objetos anidados.
