如何在Python中创建对象的副本？

Question

我想要复制一个对象。我希望新对象能拥有旧对象的所有属性（也就是字段的值）。但是我希望这两个对象是独立的。也就是说，如果我改变新对象的字段值，旧对象就不应该受到影响。

Answer 1

使用 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。

Answer 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'

元组甚至没有 copy 方法，所以我们可以试试用切片：

>>> tuple_copy_attempt = a_tuple[:]

但我们看到它们是同一个对象：

>>> tuple_copy_attempt is a_tuple
True

字符串也是一样：

>>> s = 'abc'
>>> s0 = s[:]
>>> s == s0
True
>>> s is s0
True

对于冻结集合也是如此，尽管它们有一个 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]

Answer 3

要获得一个完全独立的对象副本，你可以使用 copy.deepcopy() 这个函数。

关于浅拷贝和深拷贝的更多细节，可以参考这个问题的其他回答，以及这个相关问题的精彩解释。