"copy" --- Shallow and deep copy operations
*******************************************

**Código fuente:** 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
  aprobación de copia actual; y

* permitiendo 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,  o cualquier tipo similar.
Sí "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, "lista_copiada =
lista_original[:]".

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 pueda definir 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. El segundo es llamado para
implementar la operación de copia profunda; se le pasa un argumento,
el diccionario "memo". Si la implementación de "__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. El diccionario de notas debe
tratarse como un objeto opcional.

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.
