"copy" --- Operaciones de copia superficial y profunda
******************************************************

**Source code:** Lib/copy.py

======================================================================

Las declaraciones de asignación en Python no copian objetos, crean
enlaces entre un objetivo y un objeto. Para colecciones que son
mutables o que contienen elementos mutables, a veces se necesita una
copia para que uno pueda cambiar una copia sin cambiar la otra. Este
módulo proporciona operaciones genéricas de copia superficial y
profunda (explicadas a continuación).

Resumen de la interfaz:

copy.copy(x)

   Retorna una copia superficial de *x*.

copy.deepcopy(x[, memo])

   Retorna una copia profunda de *x*.

exception copy.Error

   Levantado para errores específicos del módulo.

La diferencia entre copia superficial y profunda solo es relevante
para objetos compuestos (objetos que contienen otros objetos, como
listas o instancias de clase):

* Una copia superficial (*shallow copy*) construye un nuevo objeto
  compuesto y luego (en la medida de lo posible) inserta *references*
  en él a los objetos encontrados en el original.

* Una copia profunda (*deep copy*) construye un nuevo objeto compuesto
  y luego, recursivamente, inserta *copias* en él de los objetos
  encontrados en el original.

A menudo existen dos problemas con las operaciones de copia profunda
que no existen con las operaciones de copia superficial:

* Los objetos recursivos (objetos compuestos que, directa o
  indirectamente, contienen una referencia a sí mismos) pueden causar
  un bucle recursivo.

* Debido a que la copia profunda copia todo, puede copiar demasiado,
  como los datos que deben compartirse entre copias.

La función "deepcopy()" evita estos problemas al:

* mantener un diccionario "memo" de objetos ya copiados durante la
  pasada de copia actual; y

* dejando que las clases definidas por el usuario anulen la operación
  de copia o el conjunto de componentes copiados.

Este módulo no copia tipos como módulo, método, seguimiento de pila,
marco de pila, archivo, socket, ventana, matriz ni ningún tipo
similar. "Copia" funciones y clases (superficiales y profundas),
retornando el objeto original sin cambios; Esto es compatible con la
forma en que son tratados por el módulo "pickle".

Se pueden hacer copias superficiales de los diccionarios usando
"dict.copy()", y de las listas mediante la asignación de una porción
de la lista completa, por ejemplo, "copied_list = original_list[:]".

Las clases pueden usar las mismas interfaces para controlar la copia
que usan para controlar el *pickling*. Consulte la descripción del
módulo "pickle" para obtener información sobre estos métodos. De
hecho, el módulo "copy" utiliza las funciones de *pickle* registradas
del módulo "copyreg".

Para que una clase defina su propia implementación de copia, puede
definir métodos especiales "__copy__()" y "__deepcopy__()". El primero
se llama para implementar la operación de copia superficial; no se
pasan argumentos adicionales. Este último está llamado a implementar
la operación de copia profunda; se pasa un argumento, el diccionario
"memo". Si la implementación "__deepcopy__()" necesita hacer una copia
profunda de un componente, debe llamar a la función "deepcopy()" con
el componente como primer argumento y el diccionario memo como segundo
argumento.

Ver también:

  Módulo "pickle"
     Discusión de los métodos especiales utilizados para apoyar la
     recuperación y restauración del estado del objeto.
