问题：如何在Python中创建对象的副本？
我想创建一个对象的副本。我希望新对象拥有旧对象的所有属性（字段的值）。但是我想拥有独立的对象。因此，如果我更改新对象的字段的值，则旧对象不应受此影响。
回答 0
要获得对象的完全独立副本，可以使用copy.deepcopy()函数。
有关浅层复制和深层复制的更多详细信息，请参考该问题的其他答案以及该答案中对相关问题的很好的解释。
回答 1
如何在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对于冻结集，即使它们具有以下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]回答 2
浅复制 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上测试。
回答 3
我相信以下内容应适用于许多行为良好的Python类：
def copy(obj):
return type(obj)(obj)（当然，我在这里不是在谈论“深层副本”，这是一个不同的故事，并且可能不是一个非常清晰的概念-足够深的深度？）
根据我对Python 3的测试，对于不可变的对象（例如元组或字符串），它返回相同的对象（因为不需要对不可变的对象进行浅表复制），但是对于列表或字典，它创建了独立的浅表复制。
当然，此方法仅适用于构造函数具有相应行为的类。可能的用例：制作标准Python容器类的浅表副本。
