Saltearse al contenido

Copias

Si el capítulo anterior explica por qué dos nombres pueden apuntar al mismo objeto, este explica cómo separarlos. La respuesta corta es que hay dos tipos de copia y elegir el equivocado produce bugs que aparecen semanas después. La respuesta larga cabe en una frase: copiar el contenedor no copia el contenido.

Una copia superficial duplica la caja; una copia profunda duplica también lo que hay dentro de la caja.

Crea un contenedor nuevo y copia las referencias, no los objetos apuntados.

Después de una copia superficial
[1, 2, [3, 4]] contenedor nuevo, id distinto [1, 2, [3, 4]] contenedor nuevo, id distinto original superficial

Las dos cajas son distintas, pero las flechas de dentro apuntan a los mismos objetos. Añadir o quitar elementos en una no afecta a la otra; mutar un elemento interno sí.

import copy
original = [1, 2, [3, 4]]
superficial = original[:] # también list(original) o copy.copy(original)
superficial is original # False
superficial.append(5) # sólo afecta a la copia
original # [1, 2, [3, 4]]
superficial[2].append(9) # el elemento interno es el mismo objeto
original # [1, 2, [3, 4, 9]] ← cambió

Las tres formas equivalentes de copiar superficialmente una lista: l[:], list(l) y copy.copy(l). En un diccionario, d.copy() o dict(d). En un conjunto, set(s) o s.copy().

Recorre el grafo completo y copia cada objeto que encuentra, incluidos los que están dentro de los que están dentro.

Después de una copia profunda
[1, 2, [3, 4]] contenedor y contenido originales [1, 2, [3, 4]] contenedor y contenido nuevos original profunda

Aquí no queda ninguna flecha compartida: mutar cualquier nivel de la copia deja intacto el original.

profunda = copy.deepcopy(original)
profunda[2].append(9)
original # [1, 2, [3, 4]] ← intacto

deepcopy mantiene un registro de los objetos ya copiados, así que soporta estructuras circulares (una lista que se contiene a sí misma) sin entrar en recursión infinita. Los objetos que necesitan un comportamiento especial definen __deepcopy__.

Copiar una estructura de 1 000 filas × 10 columnas
Operación Coste Qué recorre
copy.copy 1.6 µs la lista exterior: 1 000 punteros
copy.deepcopy 3 590 µs 1 000 listas internas y sus 10 000 enteros

python mediciones/01-03-05-referencias.py

Más de dos mil veces más lento, y con razón: hace mil veces más trabajo. El número exacto varía entre ejecuciones y máquinas; el orden de magnitud, no. La regla no es «usa siempre profunda por seguridad», es saber qué nivel necesitas aislar. Si sólo vas a añadir o quitar filas, la superficial basta. Si vas a mutar celdas, necesitas la profunda.

Y hay una tercera opción que suele ganar a las dos: no copiar. Reconstruir el dato desde su fuente ([fila[:] for fila in filas], o un dataclass nuevo) es a menudo más claro y más rápido que deepcopy, porque sabes exactamente qué se duplica.

Expresión Contenedor nuevo Contenido nuevo
b = a No No
a[:], list(a) Sí No
copy.copy(a) Sí No
dict(a), a.copy() Sí No
set(a) Sí No
copy.deepcopy(a) Sí Sí
copy.copy(tupla) No (mismo objeto) —

La última fila es la única que sorprende: copiar un objeto inmutable devuelve el mismo objeto, porque una copia no aportaría nada. copy.copy((1, 2)) is (1, 2) da True, y lo mismo con str y frozenset.

copy no sabe nada de tus clases: por defecto copia el __dict__ y devuelve una instancia nueva del mismo tipo. Eso suele ser correcto para un objeto de datos y suele ser incorrecto para un objeto con recursos.

Si necesitas control, el protocolo son dos métodos:

class Conexion:
def __copy__(self):
# una copia superficial no puede duplicar el socket:
# devuelve un objeto que comparte la conexión
...
def __deepcopy__(self, memo):
# una copia profunda tampoco debería abrir otra conexión
# sin saberlo el llamador
...

El detalle importante es memo: deepcopy lo pasa a cada objeto para recordar qué ya copió, y es lo que evita la recursión infinita en estructuras circulares. Un __deepcopy__ que lo ignore puede colgarse con un grafo que se apunta a sí mismo.

Para objetos de datos, la alternativa a copiar es reemplazar: dataclasses.replace(fila, precio=9.99) construye una instancia nueva con un campo cambiado y el resto compartido. Es más explícito que deepcopy y más barato, porque sabes exactamente qué se duplica.

  • Con inmutables, copiar es ruido: copy.deepcopy(una_tupla_de_ints) devuelve el mismo objeto.
  • En bucles cerrados, deepcopy domina el tiempo. Si el perfil muestra copia en el hot path, el diseño tiene un problema anterior.
  • Cuando el contrato es de solo lectura, documenta que la función no muta su argumento y ahorra la copia. Es lo que hacen las funciones de la biblioteca estándar: sorted(x) no copia antes de ordenar, ordena una copia.

Tienes config = {"hosts": ["a", "b"], "puerto": 8080}. Escribe una función con_host(config, nuevo) que devuelva una configuración con el host añadido sin modificar la original, y explica qué tipo de copia necesita y por qué.

Solución
import copy
def con_host(config, nuevo):
nueva = copy.deepcopy(config)
nueva["hosts"].append(nuevo)
return nueva

Una copia superficial no basta: config.copy() crearía un diccionario nuevo, pero nueva["hosts"] seguiría siendo la misma lista, y el append modificaría la original.

Hay una alternativa más barata y más explícita, que no necesita deepcopy porque sólo se toca un nivel:

def con_host(config, nuevo):
return {**config, "hosts": [*config["hosts"], nuevo]}

Duplica lo justo: crea un diccionario nuevo y una lista nueva para hosts, y reutiliza todo lo demás. Es la opción que suele preferirse en producción: copia dirigida en lugar de copia indiscriminada.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 6: copias superficial y profunda.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Receta 5.5: Making shallow and deep copies of objects.
  • Mediciones: mediciones/01-03-05-referencias.py.
  • 03 · Nombres, no variables: el alias que la copia intenta romper.
  • 04 · Mutabilidad: sin objetos mutables, copiar sería innecesario.
  • 06 · Argumentos: dónde decidir si se copia al entrar a una función.