"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".

In order for a class to define its own copy implementation, it can
define special methods "__copy__()" and "__deepcopy__()".

object.__copy__(self)

   Called to implement the shallow copy operation; no additional
   arguments are passed.

object.__deepcopy__(self, memo)

   Called to implement the deep copy operation; it is passed one
   argument, the *memo* dictionary.  If the "__deepcopy__"
   implementation needs to make a deep copy of a component, it should
   call the "deepcopy()" function with the component as first argument
   and the *memo* dictionary as second argument. The *memo* dictionary
   should be treated as an opaque object.

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.
