Como substituir as operações de cópia / cópia profunda para um objeto Python?

Eu entendo a diferença entre copye deepcopyno módulo de cópia. Usei copy.copye copy.deepcopyantes com sucesso, mas esta é a primeira vez que realmente estou sobrecarregando os métodos __copy__e __deepcopy__. Eu já pesquisei ao redor e olhou através do built-in módulos Python para procurar instâncias do __copy__e __deepcopy__funções (por exemplo sets.py, decimal.pye fractions.py), mas eu ainda não estou 100% de certeza que eu entendi direito.

Aqui está o meu cenário:

Eu tenho um objeto de configuração. Inicialmente, vou instanciar um objeto de configuração com um conjunto padrão de valores. Esta configuração será entregue a vários outros objetos (para garantir que todos os objetos comecem com a mesma configuração). No entanto, uma vez que a interação do usuário começa, cada objeto precisa ajustar suas configurações independentemente, sem afetar as configurações uns dos outros (o que me diz que vou precisar fazer cópias profundas de minha configuração inicial para entregar).

Aqui está um objeto de amostra:

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 

Qual é a maneira correta de implementar os métodos copye deepcopyneste objeto para garantir copy.copye copy.deepcopyfornecer o comportamento adequado?

As recomendações para personalização estão no final da página de documentos :

As classes podem usar as mesmas interfaces para controlar a cópia que usam para controlar a decapagem. Consulte a descrição do módulo pickle para obter informações sobre esses métodos. O módulo de cópia não usa o módulo de registro copy_reg.

Para que uma classe defina sua própria implementação de cópia, ela pode definir métodos especiais __copy__()e __deepcopy__(). O primeiro é chamado para implementar a operação de cópia superficial; nenhum argumento adicional é passado. O último é chamado para implementar a operação de cópia profunda; ele recebe um argumento, o dicionário de memorandos. Se a __deepcopy__() implementação precisar fazer uma cópia detalhada de um componente, ela deve chamar a deepcopy()função com o componente como primeiro argumento e o dicionário de memorando como segundo argumento.

Uma vez que você parece não se importar com a personalização de decapagem, definir __copy__e __deepcopy__definitivamente parece ser o caminho certo para você.

Especificamente, __copy__(a cópia superficial) é muito fácil no seu caso ...:

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

__deepcopy__seria semelhante (aceitando um memoargumento também), mas antes do retorno ele teria que chamar self.foo = deepcopy(self.foo, memo)qualquer atributo self.fooque precise de uma cópia profunda (essencialmente atributos que são contêineres - listas, dicts, objetos não primitivos que contêm outras coisas através de seus __dict__s).

Juntando a resposta de Alex Martelli e o comentário de Rob Young, você obtém o seguinte 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

estampas

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

aqui __deepcopy__preenche o memodicionário para evitar cópias em excesso, caso o próprio objeto seja referenciado a partir de seu membro.

Seguindo a excelente resposta de Peter , para implementar uma deepcopy customizada, com alterações mínimas na implementação padrão (por exemplo, apenas modificando um campo como eu precisava):

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

Não está claro para o seu problema por que você precisa sobrescrever esses métodos, uma vez que você não deseja fazer nenhuma customização nos métodos de cópia.

De qualquer forma, se você quiser personalizar a cópia profunda (por exemplo, compartilhando alguns atributos e copiando outros), aqui está uma solução:

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

Eu posso estar um pouco fora dos detalhes, mas aqui vai;

Dos copydocumentos ;

• Uma cópia superficial constrói um novo objeto composto e, em seguida (na medida do possível), insere nele referências aos objetos encontrados no original.
• Uma cópia profunda constrói um novo objeto composto e então, recursivamente, insere nele cópias dos objetos encontrados no original.

Em outras palavras: copy()irá copiar apenas o elemento superior e deixar o resto como ponteiros na estrutura original. deepcopy()irá copiar recursivamente sobre tudo.

Ou seja, deepcopy()é o que você precisa.

Se você precisa fazer algo realmente específico, pode substituir __copy__()ou __deepcopy__(), conforme descrito no manual. Pessoalmente, eu provavelmente implementaria uma função simples (por exemplo, config.copy_config()ou algo semelhante) para deixar claro que esse não é o comportamento padrão do Python.

O copymódulo usa eventualmente o protocolo__getstate__() / pickling , portanto, esses também são alvos válidos para serem substituídos.__setstate__()

A implementação padrão apenas retorna e define o __dict__da classe, então você não precisa chamar super()e se preocupar com o truque inteligente de Eino Gourdin, acima .

Com base na resposta clara de Antony Hatchkins, aqui está minha versão em que a classe em questão deriva de outra classe personalizada (st precisamos chamar 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