En este artículo, aprenderá sobre la copia superficial y la copia profunda en Python con la ayuda de ejemplos.
Copiar un objeto en Python
En Python, usamos el =operador para crear una copia de un objeto. Puede pensar que esto crea un nuevo objeto; no es así. Solo 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: Copiar usando = operador
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))
Cuando ejecutamos el programa anterior, la salida será:
Lista anterior: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID de la lista anterior: 140673303268168 Lista nueva: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID de la nueva lista: 140673303268168
Como puede ver en la salida, ambas variables old_list y new_list comparten la misma identificación, es decir 140673303268168.
Entonces, si desea modificar cualquier valor en new_list o old_list, el cambio es visible en ambos.
Esencialmente, a veces es posible que desee mantener los valores originales sin cambios y solo modificar los nuevos valores o viceversa. En Python, hay dos formas de crear copias:
- Copia superficial
- Copia profunda
Para hacer que estas copias funcionen, usamos el copymódulo.
Módulo de copia
Usamos el copymódulo de Python para operaciones de copia superficial y profunda. Suponga que necesita copiar la lista compuesta, digamos x. Por ejemplo:
importar copiar copiar copiar (x) copiar.deepcopy (x)
Aquí, copy()devuelve una copia superficial de x. Del mismo modo, deepcopy()devuelva 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 los objetos anidados, sino que simplemente copia la referencia de los objetos anidados. Esto significa que un proceso de copia no se repite ni crea copias de los objetos anidados en sí.
Ejemplo 2: crear una copia con copia 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)
Cuando ejecutamos el programa, la salida será:
Lista antigua: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Lista nueva: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
En el programa anterior, creamos una lista anidada y luego la copiamos superficialmente usando el 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, intentamos agregar un nuevo objeto anidado al original y verificarlo.
Ejemplo 3: Agregar (4, 4, 4) a old_list, usando una copia 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)
Cuando ejecutamos el programa, saldrá:
Lista antigua: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Nueva lista: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
En el programa anterior, creamos una copia superficial de old_list. New_list contiene referencias a objetos anidados originales almacenados en old_list. Luego agregamos la nueva lista, es decir, (4, 4, 4)en old_list. Esta nueva sublista 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 una copia superficial
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)
Cuando ejecutamos el programa, saldrá:
Lista antigua: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Lista nueva: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
En el programa anterior, hicimos cambios en old_list, es decir old_list(1)(1) = 'AA'. (1)(1)Se modificaron ambas sublistas de old_list y new_list en el índice . Esto se debe a que ambas listas comparten la referencia de los mismos objetos anidados.
Copia profunda
Una copia profunda crea un nuevo objeto y agrega de forma recursiva 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 deepcopy()función presente en el copymódulo. La copia profunda crea una copia independiente del objeto original y todos sus objetos anidados.
Ejemplo 5: Copiar una lista usando 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)
Cuando ejecutamos el programa, saldrá:
Lista antigua: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Lista nueva: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
En el programa anterior, usamos la deepcopy()función para crear una copia que se ve similar.
Sin embargo, si realiza cambios en cualquier objeto anidado en el objeto original old_list, no verá cambios en la copia new_list.
Ejemplo 6: Agregar un nuevo objeto anidado en la lista usando Copia profunda
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)
Cuando ejecutamos el programa, saldrá:
Lista antigua: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Lista nueva: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
En el programa anterior, cuando asignamos un nuevo valor a old_list, podemos ver que solo se modifica old_list. Esto significa que tanto old_list como new_list son independientes. Esto se debe a que old_list se copió de forma recursiva, lo que es cierto para todos sus objetos anidados.
