如何覆盖Python对象的复制/深层复制操作？

我了解复制模块copy与vs 之间的区别deepcopy。我已经使用过copy.copy并且copy.deepcopy在成功之前使用过，但这是我第一次真正地重载__copy__and __deepcopy__方法。我已经用谷歌搜索看去，通过内置的Python模块查找的实例__copy__和__deepcopy__功能（例如sets.py，decimal.py和fractions.py），但我仍然不能100％肯定我明白了它的权利。

这是我的情况：

我有一个配置对象。最初，我将使用一组默认值实例化一个配置对象。此配置将移交给其他多个对象（以确保所有对象都以相同的配置开始）。但是，一旦开始用户交互，每个对象都需要独立地调整其配置，而又不影响彼此的配置（对我来说，我需要对初始配置进行深入复制才能进行处理）。

这是一个示例对象：

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 

在此对象上实现copy和deepcopy方法以确保copy.copy并copy.deepcopy提供适当行为的正确方法是什么？

有关自定义的建议位于文档页面的最后：

类可以使用与控制酸洗相同的接口来控制复制。有关这些方法的信息，请参见模块pickle的描述。复制模块不使用copy_reg注册模块。

为了让一个类定义自己的副本实现，它可以定义特殊的方法__copy__()和 __deepcopy__()。前者被称为实现浅拷贝操作；没有传递其他参数。后者被称为实现深度复制操作。它传递了一个参数，即备忘字典。如果__deepcopy__() 实现需要复制组件的深层副本，则应deepcopy()以该组件为第一个参数，并以备注字典为第二个参数来调用该函数。

由于您似乎不关心腌制自定义，因此定义__copy__和__deepcopy__无疑似乎是适合您的正确方法。

具体来说，__copy__（浅表副本）在您的情况下非常容易...：

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

__deepcopy__会类似（也接受memoarg），但是在返回之前，它必须调用self.foo = deepcopy(self.foo, memo)任何self.foo需要深度复制的属性（本质上是容器属性-列表，字典，非原始对象，它们通过__dict__s 保存其他内容）。

将Alex Martelli的答案和Rob Young的评论放在一起，您将获得以下代码：

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

版画

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

在此__deepcopy__填写该格，memo以避免在对象本身从其成员引用的情况下过度复制。

遵循Peter的出色回答，实现自定义深度复制，对默认实现的更改最少（例如，仅修改所需的字段）：

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

从您的问题尚不清楚，您为什么需要覆盖这些方法，因为您不想对复制方法进行任何自定义。

无论如何，如果您确实想自定义深层副本（例如，通过共享某些属性并复制其他属性），则可以采用以下解决方案：

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

我可能在细节上有些偏离，但是这里有：

从copy文档 ;

• 浅表副本将构造一个新的复合对象，然后（在可能的范围内）将对原始对象中找到的对象的引用插入其中。
• 深层副本将构造一个新的复合对象，然后递归地将原始对象中发现的对象的副本插入其中。

换句话说：copy()将仅复制顶部元素，将其余元素作为指针保留到原始结构中。deepcopy()将递归复制所有内容。

那就是deepcopy()你所需要的。

如果您需要做一些真正特定的事情，则可以按照手册中的说明覆盖__copy__()或__deepcopy__()。就个人而言，我可能会实现一个普通函数（例如config.copy_config()，诸如此类）以明确表明它不是Python标准行为。

该copy模块最终使用__getstate__()/ pickling协议，因此这些也是要覆盖的有效目标。__setstate__()

默认实现只是返回并设置__dict__类的，因此您不必调用super()并担心上面的 Eino Gourdin的巧妙技巧。

建立在安东尼·哈奇金斯（Antony Hatchkins）干净答案的基础上，这是我的版本，其中相关类来自另一个自定义类（我们需要调用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