如何在python中复制类实例？

Question

我想在python中复制一个类实例.我试过,copy.deepcopy但我收到错误消息:

RuntimeError:此时只有用户显式创建的变量(图形离开)才支持deepcopy协议

所以假设我有类似的东西:

class C(object):
    def __init__(self,a,b, **kwargs):
        self.a=a
        self.b=b
        for x, v in kwargs.items():
            setattr(self, x, v)

c = C(4,5,'r'=2)
c.a = 11
del c.b

现在我想做一个相同的深层副本c,有一个简单的方法吗？

Answer 1

一种实现方法是通过__copy__在CClass中实现，如下所示：

class A:
    def __init__(self):
        self.var1 = 1
        self.var2 = 2
        self.var3 = 3

class C(A):
    def __init__(self, a=None, b=None, **kwargs):
        super().__init__()
        self.a = a
        self.b = b
        for x, v in kwargs.items():
            setattr(self, x, v)

    def __copy__(self):
        self.normalizeArgs()
        return C(self.a, self.b, kwargs=self.kwargs)

    # THIS IS AN ADDITIONAL GATE-KEEPING METHOD TO ENSURE 
    # THAT EVEN WHEN PROPERTIES ARE DELETED, CLONED OBJECTS
    # STILL GETS DEFAULT VALUES (NONE, IN THIS CASE)
    def normalizeArgs(self):
        if not hasattr(self, "a"):
            self.a      = None
        if not hasattr(self, "b"):
            self.b      = None
        if not hasattr(self, "kwargs"):
            self.kwargs = {}

cMain   = C(a=4, b=5, kwargs={'r':2})

del cMain.b
cClone  = cMain.__copy__()

cMain.a = 11

del  cClone.b
cClone2 = cClone.__copy__()

print(vars(cMain))
print(vars(cClone))
print(vars(cClone2))

Answer 2

是的，您可以使用deepcopy复制类实例的副本：

from copy import deepcopy

c = C(4,5,'r'=2)
d = deepcopy(c)

这将在'd'中创建类实例'c'的副本。

Answer 3

我大部分都想通了。我无法克服的唯一问题是知道__init__所有类的一组可接受的初始化参数（的参数）。所以我必须做出以下两个假设：

1) 我有一组C我称之为argsC. 2) 中的所有对象C都可以用空参数初始化。

在这种情况下，我可以 首先：C从要复制的实例初始化该类的新实例c：

c_copy = c.__class__(**argsC)

第二：遍历所有属性c并将属性设置为属性c_copy的副本c

for att in c.__dict__:
    setattr(c_copy, att, object_copy(getattr(c,att)))

哪里object_copy是我们正在构建的函数的递归应用程序。

最后：删除所有属性，c_copy但不删除c：

for att in c_copy.__dict__:
    if not hasattr(c, att):
        delattr(c_copy, att)

把这一切放在一起，我们有：

import copy

def object_copy(instance, init_args=None):
    if init_args:
        new_obj = instance.__class__(**init_args)
    else:
        new_obj = instance.__class__()
    if hasattr(instance, '__dict__'):
        for k in instance.__dict__ :
            try:
                attr_copy = copy.deepcopy(getattr(instance, k))
            except Exception as e:
                attr_copy = object_copy(getattr(instance, k))
            setattr(new_obj, k, attr_copy)

        new_attrs = list(new_obj.__dict__.keys())
        for k in new_attrs:
            if not hasattr(instance, k):
                delattr(new_obj, k)
        return new_obj
    else:
        return instance

所以把它们放在一起，我们有：

argsC = {'a':1, 'b':1}
c = C(4,5,r=[[1],2,3])
c.a = 11
del c.b
c_copy = object_copy(c, argsC)
c.__dict__

{'a': 11, 'r': [[1], 2, 3]}

c_copy.__dict__

{'a': 11, 'r': [[1], 2, 3]}

c.__dict__

{'a': 11, 'r': [[1, 33], 2, 3]}

c_copy.__dict__

{'a': 11, 'r': [[1], 2, 3]}

这是想要的结果。deepcopy如果可以，它会使用，但对于会引发异常的情况，它可以不使用。