我想创建一个对象的副本，新对象需要具备旧对象的所有属性（字段的值）。但是我希望它们是独立的对象。因此，如果我更改新对象字段的值，旧对象不应受到影响。
4个回答
303
- Sven Marnach
4
151
如何在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'
元组甚至没有复制方法，因此让我们尝试使用切片：
Tuples 不具备 copy 方法，因此让我们尝试使用 slice：>>> tuple_copy_attempt = a_tuple[:]
但我们看到它是同一个对象：
>>> tuple_copy_attempt is a_tuple
True
同样适用于字符串：
>>> s = 'abc'
>>> s0 = s[:]
>>> s == s0
True
>>> s is s0
True
对于frozenset，即使它们有一个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]
- Russia Must Remove Putin
1
1我对为什么有些对象有一个
copy()方法，同时还有一个完整的copy模块感到困惑。我知道这是一篇旧帖子，但还是谢谢 - 我会保存这个答案，以便将来需要时进行复习。 - Martin24
使用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上进行测试。
- Ciro Santilli OurBigBook.com
-1
我相信以下内容适用于 Python 中许多表现良好的类：
def copy(obj):
return type(obj)(obj)
当然，我这里并不是在谈论“深度拷贝”，那是另一回事，而且可能并不是一个非常清晰的概念--深度到什么程度算深度拷贝呢？
根据我的Python 3测试，对于像元组或字符串这样的不可变对象，它返回相同的对象（因为不需要制作不可变对象的浅拷贝），但对于列表或字典，则创建独立的浅拷贝。
当然，此方法仅适用于其构造函数相应行为的类。可能的用例：对标准Python容器类进行浅拷贝。
- Alexey
7
这很不错，但并没有回答问题，因为您的复制函数无法处理自定义类，而问题是关于对象的。 - Jared Smith
@JaredSmith，问题并没有说明是关于所有对象的。甚至不清楚它是关于深拷贝还是浅拷贝（我会假设通常是浅拷贝，但被接受的答案是关于深拷贝的）。至于自定义类，如果它们是你自己的，你可以在它们的
__init__方法中遵守这种约定。所以，我认为这个方法对于某些目的来说可能已经足够好了。无论如何，我对这个建议有兴趣听取有用的评论。 - Alexey1
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），但并不是答案。 - Jared Smith@JaredSmith，我看到有一个
copy.copy方法用于创建浅拷贝，但是，也许天真地说，我认为这应该是类提供“浅拷贝构造函数”的责任。在这种情况下，为什么不像dict和list一样为其提供相同的接口呢？因此，如果您的类想要负责复制其对象，为什么不在__init__中添加一个if isinstance(arg, type(self))子句呢？ - Alexey2因为你并不总是像定义自己的类那样有控制权来使用它们。它们可能是C程序，也可能有Python绑定（例如GTK，openalpr和部分core）。更不用说，即使你将第三方库中的每个类都添加了复制方法，你要如何将其编入到你的依赖管理中呢？ - Jared Smith
显示剩余2条评论
网页内容由stack overflow 提供, 点击上面的可以查看英文原文，
原文链接
原文链接
deepcopy()函数能复制多少个“深度级别”（它支持多少层嵌套深度）？ - undefined