如何在 Python 中创建对象的副本?
Posted
技术标签:
【中文标题】如何在 Python 中创建对象的副本?【英文标题】:How can I create a copy of an object in Python? 【发布时间】:2011-06-15 05:17:32 【问题描述】:我想创建一个对象的副本。我希望新对象拥有旧对象的所有属性(字段的值)。但我想拥有独立的对象。因此,如果我更改新对象的字段值,旧对象不应该受到影响。
【问题讨论】:
【参考方案1】:要获得对象的完全独立副本,您可以使用copy.deepcopy()
函数。
有关浅拷贝和深拷贝的更多详细信息,请参阅此问题的其他答案以及this answer to a related question 中的精彩解释。
【讨论】:
此答案被标记为“不是答案”,已删除且未删除 - 元讨论在这里:meta.***.com/questions/377844/… @AaronHall 感谢您告诉我!这当然不是我写的最好的答案,但我有点同意不应该强行删除它的决定。我会稍微梳理一下,但由于已经有了所有细节的答案(尤其是你的),我会保持简短。【参考方案2】:如何在 Python 中创建对象的副本?
所以,如果我更改新对象的字段值,旧对象不应该受到影响。
那么你的意思是一个可变对象。
在 Python 3 中,列表获得 copy
方法(在 2 中,您将使用切片来制作副本):
>>> a_list = list('abc')
>>> a_copy_of_a_list = a_list.copy()
>>> a_copy_of_a_list is a_list
False
>>> a_copy_of_a_list == a_list
True
浅拷贝
浅拷贝只是最外层容器的拷贝。
list.copy
是浅拷贝:
>>> list_of_dict_of_set = ['foo': set('abc')]
>>> lodos_copy = list_of_dict_of_set.copy()
>>> lodos_copy[0]['foo'].pop()
'c'
>>> lodos_copy
['foo': 'b', 'a']
>>> list_of_dict_of_set
['foo': 'b', 'a']
您不会得到内部对象的副本。它们是同一个对象 - 所以当它们发生变异时,变化会显示在两个容器中。
深拷贝
深拷贝是每个内部对象的递归拷贝。
>>> lodos_deep_copy = copy.deepcopy(list_of_dict_of_set)
>>> lodos_deep_copy[0]['foo'].add('c')
>>> lodos_deep_copy
['foo': 'c', 'b', 'a']
>>> list_of_dict_of_set
['foo': 'b', 'a']
更改不会反映在原件中,只会反映在副本中。
不可变对象
不可变对象通常不需要复制。事实上,如果你尝试这样做,Python 只会给你原始对象:
>>> a_tuple = tuple('abc')
>>> tuple_copy_attempt = a_tuple.copy()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'copy'
元组甚至没有复制方法,所以我们用切片试试:
>>> tuple_copy_attempt = a_tuple[:]
但我们看到它是同一个对象:
>>> tuple_copy_attempt is a_tuple
True
字符串也一样:
>>> s = 'abc'
>>> s0 = s[:]
>>> s == s0
True
>>> s is s0
True
对于frozensets,即使它们有copy
方法:
>>> a_frozenset = frozenset('abc')
>>> frozenset_copy_attempt = a_frozenset.copy()
>>> frozenset_copy_attempt is a_frozenset
True
何时复制不可变对象
如果您需要复制可变的内部对象,应该复制不可变对象。
>>> tuple_of_list = [],
>>> copy_of_tuple_of_list = tuple_of_list[:]
>>> copy_of_tuple_of_list[0].append('a')
>>> copy_of_tuple_of_list
(['a'],)
>>> tuple_of_list
(['a'],)
>>> deepcopy_of_tuple_of_list = copy.deepcopy(tuple_of_list)
>>> deepcopy_of_tuple_of_list[0].append('b')
>>> deepcopy_of_tuple_of_list
(['a', 'b'],)
>>> tuple_of_list
(['a'],)
正如我们所见,当副本的内部对象发生变异时,原来的不会改变。
自定义对象
自定义对象通常将数据存储在__dict__
属性或__slots__
(类似元组的内存结构)中。
要制作可复制对象,请定义__copy__
(用于浅拷贝)和/或__deepcopy__
(用于深拷贝)。
from copy import copy, deepcopy
class Copyable:
__slots__ = 'a', '__dict__'
def __init__(self, a, b):
self.a, self.b = a, b
def __copy__(self):
return type(self)(self.a, self.b)
def __deepcopy__(self, memo): # memo is a dict of id's to copies
id_self = id(self) # memoization avoids unnecesary recursion
_copy = memo.get(id_self)
if _copy is None:
_copy = type(self)(
deepcopy(self.a, memo),
deepcopy(self.b, memo))
memo[id_self] = _copy
return _copy
请注意,deepcopy
会保留一份 id(original)
(或身份号码)的备忘录字典以供复制。要享受递归数据结构的良好行为,请确保您尚未制作副本,如果有,请将其返回。
那么让我们创建一个对象:
>>> c1 = Copyable(1, [2])
而copy
做了一个浅拷贝:
>>> c2 = copy(c1)
>>> c1 is c2
False
>>> c2.b.append(3)
>>> c1.b
[2, 3]
deepcopy
现在制作了一个深拷贝:
>>> c3 = deepcopy(c1)
>>> c3.b.append(4)
>>> c1.b
[2, 3]
【讨论】:
【参考方案3】:浅拷贝copy.copy()
#!/usr/bin/env python3
import copy
class C():
def __init__(self):
self.x = [1]
self.y = [2]
# It copies.
c = C()
d = copy.copy(c)
d.x = [3]
assert c.x == [1]
assert d.x == [3]
# It's shallow.
c = C()
d = copy.copy(c)
d.x[0] = 3
assert c.x == [3]
assert d.x == [3]
深拷贝copy.deepcopy()
#!/usr/bin/env python3
import copy
class C():
def __init__(self):
self.x = [1]
self.y = [2]
c = C()
d = copy.deepcopy(c)
d.x[0] = 3
assert c.x == [1]
assert d.x == [3]
文档:https://docs.python.org/3/library/copy.html
在 Python 3.6.5 上测试。
【讨论】:
【参考方案4】:我相信以下内容应该适用于 Python 中许多表现良好的类:
def copy(obj):
return type(obj)(obj)
(当然,我这里说的不是“深拷贝”,这是一个不同的故事,也可能不是一个很清晰的概念——有多深才足够深?)
根据我对 Python 3 的测试,对于不可变对象,如元组或字符串,它返回相同的对象(因为不需要制作不可变对象的浅表副本),但对于列表或字典,它会创建一个独立的浅拷贝。
当然,此方法仅适用于构造函数行为相应的类。可能的用例:制作标准 Python 容器类的浅拷贝。
【讨论】:
这很简洁,但没有回答问题,因为自定义类的复制功能失败并且问题是关于 objects。 @JaredSmith,没有说明问题是关于 all 对象的。甚至不清楚它是关于深拷贝还是浅拷贝(我会假设通常是浅拷贝,但公认的答案是关于深拷贝)。至于自定义类,如果它们是你的,你可以在他们的__init__
方法中尊重这种约定。所以,我认为这种方法对于某些目的可能已经足够好了。无论如何,我会对有关此建议的信息丰富的 cmets 感兴趣。
考虑class Foo(object): def __init__(self, arg): super(Foo, self).__init__() self.arg = arg
基本。如果我这样做 foo = Foo(3) bar = copy(foo) print(foo.arg) # 3 print(bar.arg) # <__main__.Foo object at ...>
意味着您的 copy
函数即使是最基本的类也被破坏了。同样,这是一个巧妙的技巧(因此没有 DV),但不是答案。
@JaredSmith,我看到有 copy.copy
方法用于制作浅拷贝,但是,也许天真地,在我看来,提供“浅拷贝构造函数”应该是该类的责任。”在这种情况下,为什么不提供与dict
和list
相同的接口呢?所以,如果你的类想要负责复制它的对象,为什么不在__init__
中添加一个if isinstance(arg, type(self))
子句?
因为您并不总是可以按照您定义的方式控制您使用的类。例如,它们可能是具有 Python 绑定的 C 程序(例如 GTK、openalpr、核心部分)。更不用说即使你使用了第三方库并为每个类添加了复制方法,你打算如何将它编织到你的依赖管理中?以上是关于如何在 Python 中创建对象的副本?的主要内容,如果未能解决你的问题,请参考以下文章