¿Cómo anular las operaciones de copia / copia profunda para un objeto Python?

Entiendo la diferencia entre copyvs. deepcopyen el módulo de copia. He usado copy.copyy copy.deepcopyantes con éxito, pero esta es la primera vez que sobrecargo los métodos __copy__y __deepcopy__. Ya he buscado en Google y miré a través de la incorporada en los módulos de Python para buscar instancias de la __copy__y __deepcopy__funciones (por ejemplo sets.py, decimal.pyy fractions.py), pero todavía no estoy 100% seguro de que tengo derecho.

Aquí está mi escenario:

Tengo un objeto de configuración. Inicialmente, voy a crear una instancia de un objeto de configuración con un conjunto de valores predeterminado. Esta configuración se transferirá a varios otros objetos (para garantizar que todos los objetos comiencen con la misma configuración). Sin embargo, una vez que comienza la interacción del usuario, cada objeto debe modificar sus configuraciones de forma independiente sin afectar las configuraciones de los demás (lo que me dice que tendré que hacer copias en profundidad de mi configuración inicial para entregar).

Aquí hay un objeto de muestra:

class ChartConfig(object):

    def __init__(self):

        #Drawing properties (Booleans/strings)
        self.antialiased = None
        self.plot_style = None
        self.plot_title = None
        self.autoscale = None

        #X axis properties (strings/ints)
        self.xaxis_title = None
        self.xaxis_tick_rotation = None
        self.xaxis_tick_align = None

        #Y axis properties (strings/ints)
        self.yaxis_title = None
        self.yaxis_tick_rotation = None
        self.yaxis_tick_align = None

        #A list of non-primitive objects
        self.trace_configs = []

    def __copy__(self):
        pass

    def __deepcopy__(self, memo):
        pass 

¿Cuál es la forma correcta de implementar los métodos copyy deepcopyen este objeto para garantizar copy.copyy copy.deepcopydarme el comportamiento adecuado?

Las recomendaciones para la personalización se encuentran al final de la página de documentos :

Las clases pueden usar las mismas interfaces para controlar la copia que usan para controlar el decapado. Consulte la descripción del módulo pickle para obtener información sobre estos métodos. El módulo de copia no utiliza el módulo de registro copy_reg.

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 __deepcopy__() implementación necesita hacer una copia profunda de un componente, debe llamar a la deepcopy()función con el componente como primer argumento y el diccionario memo como segundo argumento.

Dado que parece que no le importa la personalización del decapado, definir __copy__y __deepcopy__definitivamente parece ser el camino correcto para usted.

Específicamente, __copy__(la copia superficial) es bastante fácil en su caso ...:

def __copy__(self):
  newone = type(self)()
  newone.__dict__.update(self.__dict__)
  return newone

__deepcopy__sería similar (aceptando un memoarg también) pero antes de la devolución tendría que solicitar self.foo = deepcopy(self.foo, memo)cualquier atributo self.fooque necesite copia profunda (esencialmente atributos que son contenedores: listas, dictados, objetos no primitivos que contienen otras cosas a través de sus __dict__s).

Al juntar la respuesta de Alex Martelli y el comentario de Rob Young, se obtiene el siguiente código:

from copy import copy, deepcopy

class A(object):
    def __init__(self):
        print 'init'
        self.v = 10
        self.z = [2,3,4]

    def __copy__(self):
        cls = self.__class__
        result = cls.__new__(cls)
        result.__dict__.update(self.__dict__)
        return result

    def __deepcopy__(self, memo):
        cls = self.__class__
        result = cls.__new__(cls)
        memo[id(self)] = result
        for k, v in self.__dict__.items():
            setattr(result, k, deepcopy(v, memo))
        return result

a = A()
a.v = 11
b1, b2 = copy(a), deepcopy(a)
a.v = 12
a.z.append(5)
print b1.v, b1.z
print b2.v, b2.z

huellas dactilares

init
11 [2, 3, 4, 5]
11 [2, 3, 4]

aquí se completa __deepcopy__el memodict para evitar el exceso de copias en caso de que el objeto en sí sea referenciado desde su miembro.

Siguiendo la excelente respuesta de Peter , para implementar una copia profunda personalizada, con una alteración mínima a la implementación predeterminada (por ejemplo, simplemente modificando un campo como yo necesitaba):

class Foo(object):
    def __deepcopy__(self, memo):
        deepcopy_method = self.__deepcopy__
        self.__deepcopy__ = None
        cp = deepcopy(self, memo)
        self.__deepcopy__ = deepcopy_method
        cp.__deepcopy__ = deepcopy_method

        # custom treatments
        # for instance: cp.id = None

        return cp

Su problema no deja claro por qué necesita anular estos métodos, ya que no desea personalizar los métodos de copia.

De todos modos, si desea personalizar la copia profunda (por ejemplo, compartiendo algunos atributos y copiando otros), aquí tiene una solución:

from copy import deepcopy


def deepcopy_with_sharing(obj, shared_attribute_names, memo=None):
    '''
    Deepcopy an object, except for a given list of attributes, which should
    be shared between the original object and its copy.

    obj is some object
    shared_attribute_names: A list of strings identifying the attributes that
        should be shared between the original and its copy.
    memo is the dictionary passed into __deepcopy__.  Ignore this argument if
        not calling from within __deepcopy__.
    '''
    assert isinstance(shared_attribute_names, (list, tuple))
    shared_attributes = {k: getattr(obj, k) for k in shared_attribute_names}

    if hasattr(obj, '__deepcopy__'):
        # Do hack to prevent infinite recursion in call to deepcopy
        deepcopy_method = obj.__deepcopy__
        obj.__deepcopy__ = None

    for attr in shared_attribute_names:
        del obj.__dict__[attr]

    clone = deepcopy(obj)

    for attr, val in shared_attributes.iteritems():
        setattr(obj, attr, val)
        setattr(clone, attr, val)

    if hasattr(obj, '__deepcopy__'):
        # Undo hack
        obj.__deepcopy__ = deepcopy_method
        del clone.__deepcopy__

    return clone



class A(object):

    def __init__(self):
        self.copy_me = []
        self.share_me = []

    def __deepcopy__(self, memo):
        return deepcopy_with_sharing(self, shared_attribute_names = ['share_me'], memo=memo)

a = A()
b = deepcopy(a)
assert a.copy_me is not b.copy_me
assert a.share_me is b.share_me

c = deepcopy(b)
assert c.copy_me is not b.copy_me
assert c.share_me is b.share_me

Puede que esté un poco fuera de lugar en los detalles, pero aquí va;

De los copydocumentos ;

• Una copia superficial construye un nuevo objeto compuesto y luego (en la medida de lo posible) inserta en él referencias a los objetos encontrados en el original.
• Una copia profunda construye un nuevo objeto compuesto y luego, de forma recursiva, inserta copias en él de los objetos encontrados en el original.

En otras palabras: copy()copiará solo el elemento superior y dejará el resto como punteros en la estructura original. deepcopy()copiará de forma recursiva sobre todo.

Es decir, deepcopy()es lo que necesitas.

Si necesita hacer algo realmente específico, puede anular __copy__()o __deepcopy__(), como se describe en el manual. Personalmente, probablemente implementaría una función simple (por ejemplo, config.copy_config()o tal) para dejar claro que no es el comportamiento estándar de Python.

El copymódulo usa eventualmente el protocolo__getstate__() / pickling , por lo que estos también son objetivos válidos para anular.__setstate__()

La implementación predeterminada simplemente regresa y establece el __dict__de la clase, por lo que no tiene que llamar super()ni preocuparse por el ingenioso truco de Eino Gourdin, arriba .

Sobre la base de la respuesta limpia de Antony Hatchkins, aquí está mi versión en la que la clase en cuestión deriva de otra clase personalizada (a la que debemos llamar super):

class Foo(FooBase):
    def __init__(self, param1, param2):
        self._base_params = [param1, param2]
        super(Foo, result).__init__(*self._base_params)

    def __copy__(self):
        cls = self.__class__
        result = cls.__new__(cls)
        result.__dict__.update(self.__dict__)
        super(Foo, result).__init__(*self._base_params)
        return result

    def __deepcopy__(self, memo):
        cls = self.__class__
        result = cls.__new__(cls)
        memo[id(self)] = result
        for k, v in self.__dict__.items():
            setattr(result, k, copy.deepcopy(v, memo))
        super(Foo, result).__init__(*self._base_params)
        return result