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

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

有关浅复制和深复制的更多细节，请参考这个问题的其他答案和这是一个相关问题的答案中的详细解释。

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

因此，如果我改变了新对象的字段值，旧对象不应该受到影响。

你的意思是一个可变对象。

在Python 3中，列表获得copy方法(在Python 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]

我相信下面的代码应该适用于Python中许多行为良好的类:

def copy(obj):
return type(obj)(obj)

(当然，我在这里不是在谈论“深度复制”，这是另一回事，可能不是一个非常明确的概念——多深才算足够深?)

根据我对Python 3的测试，对于不可变对象，比如元组或字符串，它会返回相同的对象(因为不需要对不可变对象进行浅拷贝)，但对于列表或字典，它会创建一个独立的浅拷贝。

当然，此方法仅适用于构造函数具有相应行为的类。可能的用例:制作标准Python容器类的浅拷贝。

浅拷贝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上测试。