不确定上面是否提到过，但了解 .copy() 创建对原始对象的引用非常重要。如果您更改复制的对象 - 您也会更改原始对象。.deepcopy() 会创建新对象并将原始对象真正复制到新对象。更改新的深度复制对象不会影响原始对象。

是的，.deepcopy() 递归复制原始对象，而 .copy() 创建对原始对象第一级数据的引用对象。

因此，.copy() 和 .deepcopy() 之间的复制/引用差异非常显著。

>>lst=[1,2,3,4,5]

>>a=lst

>>b=lst[:]

>>> b
[1, 2, 3, 4, 5]

>>> a
[1, 2, 3, 4, 5]

>>> lst is b
False

>>> lst is a
True

>>> id(lst)
46263192

>>> id(a)
46263192 ------>  See here id of a and id of lst is same so its called deep copy and even boolean answer is true

>>> id(b)
46263512 ------>  See here id of b and id of lst is not same so its called shallow copy and even boolean answer is false although output looks same.

您可以使用模块memory_graph：

https://pypi.org/project/memory-graph/

绘制数据图表，轻松查看赋值、浅拷贝和深拷贝之间的区别。这里我们使用嵌套列表“a”作为示例：

import memory_graph # see install instructions at link above
import copy

a = [ [1, 2], ['a', 'b'] ] # a nested list (a list containing other lists)

# three different ways to make a "copy" of 'a':
c1 = a
c2 = copy.copy(a) # equivalent to:   a.copy() a[:] list(a)
c3 = copy.deepcopy(a)

memory_graph.d() # draw graph

• c1 是一个 分配 ，所有数据都是共享的。
• c2是 浅拷贝 ，只复制第一个引用所引用的数据，并且共享底层数据
• c3 是 深层复制 ，所有数据都被复制

的开发者 memory_graph .

类似 Sohaib Farooqi ，但使用的是类。

from copy import deepcopy, copy

class A(object):
    """docstring for A"""
    def __init__(self):
        super().__init__()

class B(object):
    """docstring for B"""
    def __init__(self):
        super().__init__()
        self.myA = A()

a = B()
print("a is", a)
print("a.myA is", a.myA)
print("After copy")
b = copy(a)
print("b is", b)
print("b.myA is", b.myA)
b.myA = A()
print("-- after changing value")
print("a is", a)
print("a.myA is", a.myA)
print("b is", b)
print("b.myA is", b.myA)

print("Resetting")
print("*"*40)
a = B()
print("a is", a)
print("a.myA is", a.myA)
print("After deepcopy")
b = deepcopy(a)
print("b is", b)
print("b.myA is", b.myA)
b.myA = A()
print("-- after changing value")
print("a is", a)
print("a.myA is", a.myA)
print("b is", b)
print("b.myA is", b.myA)

print("Resetting")
print("*"*40)
a = B()
print("a is", a)
print("a.myA is", a.myA)
print("After assignment")
b = a
print("b is", b)
print("b.myA is", b.myA)
b.myA = A()
print("-- after changing value")
print("a is", a)
print("a.myA is", a.myA)
print("b is", b)
print("b.myA is", b.myA)

该代码的输出如下：

a is <__main__.B object at 0x7f1d8ff59760>
a.myA is <__main__.A object at 0x7f1d8fe8f970>
After copy
b is <__main__.B object at 0x7f1d8fe43280>
b.myA is <__main__.A object at 0x7f1d8fe8f970>
-- after changing value
a is <__main__.B object at 0x7f1d8ff59760>
a.myA is <__main__.A object at 0x7f1d8fe8f970>
b is <__main__.B object at 0x7f1d8fe43280>
b.myA is <__main__.A object at 0x7f1d8fe85820>
Resetting
****************************************
a is <__main__.B object at 0x7f1d8fe85370>
a.myA is <__main__.A object at 0x7f1d8fe43310>
After deepcopy
b is <__main__.B object at 0x7f1d8fde3040>
b.myA is <__main__.A object at 0x7f1d8fde30d0>
-- after changing value
a is <__main__.B object at 0x7f1d8fe85370>
a.myA is <__main__.A object at 0x7f1d8fe43310>
b is <__main__.B object at 0x7f1d8fde3040>
b.myA is <__main__.A object at 0x7f1d8fe43280>
Resetting
****************************************
a is <__main__.B object at 0x7f1d8fe432b0>
a.myA is <__main__.A object at 0x7f1d8fe85820>
After assignment
b is <__main__.B object at 0x7f1d8fe432b0>
b.myA is <__main__.A object at 0x7f1d8fe85820>
-- after changing value
a is <__main__.B object at 0x7f1d8fe432b0>
a.myA is <__main__.A object at 0x7f1d8fe85370>
b is <__main__.B object at 0x7f1d8fe432b0>
b.myA is <__main__.A object at 0x7f1d8fe85370>

要点如下：使用“正常赋值”处理浅列表（没有子列表，只有单个元素）会产生“副作用”，当您创建浅列表，然后使用“正常赋值”创建此列表的副本时。此“副作用”是当您更改所创建的副本列表的任何元素时，因为它会自动更改原始列表中的相同元素。这时就 copy 派上用场了，因为在更改复制元素时不会更改原始列表元素。

另一方面， copy 当您有一个包含列表的列表（子列表）并解决它时，也会产生“副作用” deepcopy 。例如，如果您创建一个包含嵌套列表的大列表（子列表），并且创建此大列表（原始列表）的副本。当您修改复制列表的子列表时，就会出现“副作用”，这会自动修改大列表的子列表。有时（在某些项目中）您希望保持大列表（您的原始列表）原样而不进行修改，而您想要的只是复制其元素（子列表）。为此，您的解决方案是使用 deepcopy 可以处理此“副作用”并在不修改原始内容的情况下进行复制的解决方案。

和 copy 的不同行为 deep copy 仅涉及复合对象（即：包含其他对象的对象，例如列表）。

以下是此简单代码示例中说明的差异：

第一的

让我们 copy 通过创建一个原始列表和该列表的副本来检查 (shallow) 的行为：

import copy
original_list = [1, 2, 3, 4, 5, ['a', 'b']]
copy_list = copy.copy(original_list)

现在，让我们运行一些 print 测试，看看原始列表与其复制列表相比的表现如何：

original_list 和 copy_list 有不同的地址

print(hex(id(original_list)), hex(id(copy_list))) # 0x1fb3030 0x1fb3328

original_list 和 copy_list 的元素具有相同的地址

print(hex(id(original_list[1])), hex(id(copy_list[1]))) # 0x537ed440 0x537ed440

original_list 和 copy_list 的子元素具有相同的地址

print(hex(id(original_list[5])), hex(id(copy_list[5]))) # 0x1faef08 0x1faef08

修改 original_list 元素不会修改 copy_list 元素

original_list.append(6)
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b']]

修改 copy_list 元素不会修改 original_list 元素

copy_list.append(7)
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

修改 original_list 子元素 自动修改 copy_list 子元素

original_list[5].append('c')
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 7]

修改 copy_list 子元素 自动修改 original_list 子元素

copy_list[5].append('d')
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 7]

第二

让我们 deepcopy 通过执行与我们所做的相同的操作 copy （创建原始列表和此列表的副本）来检查其行为方式：

import copy
original_list = [1, 2, 3, 4, 5, ['a', 'b']]
copy_list = copy.copy(original_list)

现在，让我们运行一些 print 测试，看看原始列表与其复制列表相比的表现如何：

import copy
original_list = [1, 2, 3, 4, 5, ['a', 'b']]
copy_list = copy.deepcopy(original_list)

original_list 和 copy_list 有不同的地址

print(hex(id(original_list)), hex(id(copy_list))) # 0x1fb3030 0x1fb3328

original_list 和 copy_list 的元素具有相同的地址

print(hex(id(original_list[1])), hex(id(copy_list[1]))) # 0x537ed440 0x537ed440

original_list 和 copy_list 的子元素具有不同的地址

print(hex(id(original_list[5])), hex(id(copy_list[5]))) # 0x24eef08 0x24f3300

修改 original_list 元素不会修改 copy_list 元素

original_list.append(6)
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b']]

修改 copy_list 元素不会修改 original_list 元素

copy_list.append(7)
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

修改 original_list 子元素不会修改 copy_list 子元素

original_list[5].append('c')
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

修改 copy_list 子元素不会修改 original_list 子元素

copy_list[5].append('d')
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'd'], 7]

下面的代码演示了赋值、使用 copy 方法的浅拷贝、使用 (slice) [:] 的浅拷贝和 deepcopy 之间的区别。下面的示例使用嵌套列表，从而使差异更加明显。

from copy import deepcopy

########"List assignment (does not create a copy) ############
l1 = [1,2,3, [4,5,6], [7,8,9]]
l1_assigned = l1

print(l1)
print(l1_assigned)

print(id(l1), id(l1_assigned))
print(id(l1[3]), id(l1_assigned[3]))
print(id(l1[3][0]), id(l1_assigned[3][0]))

l1[3][0] = 100
l1.pop(4)
l1.remove(1)


print(l1)
print(l1_assigned)
print("###################################")

########"List copy using copy method (shallow copy)############

l2 = [1,2,3, [4,5,6], [7,8,9]]
l2_copy = l2.copy()

print(l2)
print(l2_copy)

print(id(l2), id(l2_copy))
print(id(l2[3]), id(l2_copy[3]))
print(id(l2[3][0]), id(l2_copy[3][0]))
l2[3][0] = 100
l2.pop(4)
l2.remove(1)


print(l2)
print(l2_copy)

print("###################################")

########"List copy using slice (shallow copy)############

l3 = [1,2,3, [4,5,6], [7,8,9]]
l3_slice = l3[:]

print(l3)
print(l3_slice)

print(id(l3), id(l3_slice))
print(id(l3[3]), id(l3_slice[3]))
print(id(l3[3][0]), id(l3_slice[3][0]))

l3[3][0] = 100
l3.pop(4)
l3.remove(1)


print(l3)
print(l3_slice)

print("###################################")

########"List copy using deepcopy ############

l4 = [1,2,3, [4,5,6], [7,8,9]]
l4_deep = deepcopy(l4)

print(l4)
print(l4_deep)

print(id(l4), id(l4_deep))
print(id(l4[3]), id(l4_deep[3]))
print(id(l4[3][0]), id(l4_deep[3][0]))

l4[3][0] = 100
l4.pop(4)
l4.remove(1)

print(l4)
print(l4_deep)
print("##########################")
print(l4[2], id(l4[2]))
print(l4_deep[3], id(l4_deep[3]))

print(l4[2][0], id(l4[2][0]))
print(l4_deep[3][0], id(l4_deep[3][0]))

深层复制与嵌套结构相关。如果您有列表列表，则深层复制也会复制嵌套列表，因此它是递归复制。仅使用复制，您就会有一个新的外部列表，但内部列表是引用。赋值不会复制。例如

import copy
spam = [[0, 1, 2, 3], 4, 5]
cheese = copy.copy(spam)
cheese.append(3)
cheese[0].append(3)
print(spam)
print(cheese)

输出

[[0, 1, 2, 3, 3], 4, 5][[0, 1, 2, 3, 3], 4, 5, 3]复制方法将外部列表的内容复制到新列表，但内部列表对于两个列表仍然相同，因此如果您对任何列表的内部列表进行更改，它将影响两个列表。

但是如果使用深度复制，那么它也会为内部列表创建新的实例。

import copy
spam = [[0, 1, 2, 3], 4, 5]
cheese = copy.deepcopy(spam)
cheese.append(3)
cheese[0].append(3)
print(spam)
print(cheese)

输出

[0, 1, 2, 3][[0, 1, 2, 3, 3], 4, 5, 3]

在 Python 中，当我们将列表、元组、字典等对象赋值给另一个对象时（通常使用“=”符号），Python 会 通过引用 。也就是说，假设我们有一个这样的列表：

list1 = [ [ 'a' , 'b' , 'c' ] , [ 'd' , 'e' , 'f' ]  ]

并且我们将另一个列表分配给该列表，例如：

list2 = list1

然后如果我们在 python 终端中打印 list2 我们将得到以下结果：

list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f ']  ]

list1 和 list2 都指向相同的内存位置，对其中任何一个进行更改都会导致两个对象都发生可见的更改，即两个对象都指向相同的内存位置。如果我们像这样更改 list1：

list1[0][0] = 'x’
list1.append( [ 'g'] )

那么 list1 和 list2 都将是：

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g'] ]
list2 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g’ ] ]

现在谈到 浅拷贝 ，当通过浅拷贝复制两个对象时，两个父对象的子对象都引用相同的内存位置，但任何复制对象中的任何进一步新更改都将彼此独立。让我们通过一个小例子来理解这一点。假设我们有这个小代码片段：

import copy

list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f ']  ]      # assigning a list
list2 = copy.copy(list1)       # shallow copy is done using copy function of copy module

list1.append ( [ 'g', 'h', 'i'] )   # appending another list to list1

print list1
list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ]
list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ]

请注意，list2 不受影响，但如果我们对子对象进行如下更改：

list1[0][0] = 'x’

那么 list1 和 list2 都会发生变化：

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ] 
list2 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] ]

现在， 深度复制 有助于创建彼此完全隔离的对象。如果通过深度复制复制两个对象，则父对象及其子对象都将指向不同的内存位置。示例：

import copy

list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f ']  ]         # assigning a list
list2 = deepcopy.copy(list1)       # deep copy is done using deepcopy function of copy module

list1.append ( [ 'g', 'h', 'i'] )   # appending another list to list1

print list1
list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ]
list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ]

请注意，list2 不受影响，但如果我们对子对象进行如下更改：

list1[0][0] = 'x’

那么 list2 也不会受到影响，因为所有子对象和父对象都指向不同的内存位置：

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ] 
list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f  ' ] ]

希望有帮助。

a、b、c、d、a1、b1、c1、d1 是内存中对象的引用，通过它们的 id 唯一标识。

赋值操作获取对内存中对象的引用，并将该引用分配给新名称。 c=[1,2,3,4] 是一个赋值操作，它创建一个包含这四个整数的新列表对象，并将对该对象的引用分配给 c . c1=c 是一个赋值操作，它获取 对同一对象的相同引用 ，并将其分配给 c1 或 c 访问该列表，发生在该列表上的任何事情都是可见的 c1 ，因为它们都引用同一个对象。

c1=copy.copy(c) 是“浅拷贝”，它创建一个新列表，并将对新列表的引用分配给 c1 . c 仍指向原始列表。因此，如果您修改列表 c1 ，则引用的列表 c 不会改变。

复制的概念与整数和字符串等不可变对象无关。由于您无法修改这些对象，因此永远不需要在内存中的不同位置拥有相同值的两个副本。因此，整数和字符串以及一些不适用复制概念的其他对象只是被重新分配。这就是为什么您的示例 a 和 b 导致相同的 ID。

c1=copy.deepcopy(c) 是“深层复制”，但在本例中，其功能与浅层复制相同。深层复制与浅层复制的不同之处在于，浅层复制将创建对象本身的新副本，但 内的 本身不会被复制。在您的示例中，列表内只有整数（它们是不可变的），并且如前所述，无需复制它们。因此，深层复制的“深层”部分不适用。但是，请考虑这个更复杂的列表：

e = [[1, 2],[4, 5, 6],[7, 8, 9]]

这是一个包含其他列表的列表（您也可以将其描述为二维数组）。

如果对 运行“浅拷贝” e ，将其复制到 e1 ，您会发现列表的 id 发生了变化，但是列表的每个副本都包含对相同三个列表的引用——内部包含整数的列表。这意味着如果您执行 e[0].append(3) ，那么 e 将是 [[1, 2, 3],[4, 5, 6],[7, 8, 9]] 。但 e1 也会是 [[1, 2, 3],[4, 5, 6],[7, 8, 9]] 。另一方面，如果您随后执行 ， e.append([10, 11, 12]) , e 将是 [[1, 2, 3],[4, 5, 6],[7, 8, 9],[10, 11, 12]] 。但 e1 。这是因为外部列表是单独的对象，每个对象最初都包含对三个内部列表的三个引用。如果修改内部列表，无论您是通过一个副本还是另一个副本查看它们，都可以看到这些更改。但是如果您按照上述方式修改其中一个外部列表，那么 [[1, 2, 3],[4, 5, 6],[7, 8, 9]] 包含 e 对原始三个列表的三个引用加上对新列表的一个引用。并且 e1 仍然只包含原始的三个引用。

“深层复制”不仅会复制外部列表，还会进入列表内部并复制内部列表，这样两个结果对象就不会包含任何相同的引用（就可变对象而言）。如果内部列表中有其他列表（或其他对象，如字典），它们也会被复制。这就是“深层复制”的“深层”部分。

我建议使用memory_graph (pypi.org/project/memory-graph)作为pythontutor的替代品。它在本地运行，没有限制。

pythontutor.com/visualize.html#mode=edit

让我们通过一个图形示例来看一下以下代码是如何执行的：

import copy

class Foo(object):
    def __init__(self):
        pass


a = [Foo(), Foo()]
shallow = copy.copy(a)
deep = copy.deepcopy(a)

对于不可变对象，创建副本没有多大意义，因为它们不会改变。对于可变对象， assignment , copy 和 deepcopy 的行为不同。让我们通过示例分别讨论它们。

赋值操作只是将源的引用分配给目标，例如：

>>> i = [1,2,3]
>>> j=i
>>> hex(id(i)), hex(id(j))
>>> ('0x10296f908', '0x10296f908') #Both addresses are identical

现在 i 和 j 从技术上来说指的是同一个列表。 i 和 j 都具有相同的内存地址。对其中一个的任何更新都将反映在另一个中，例如：

>>> i.append(4)
>>> j
>>> [1,2,3,4] #Destination is updated

>>> j.append(5)
>>> i
>>> [1,2,3,4,5] #Source is updated

另一方面， copy 创建 deepcopy 变量的新副本。因此，对原始变量的更改现在不会反映在复制变量中，反之亦然。但是， copy （ 浅复制 ）不会创建嵌套对象的副本，而是仅复制对嵌套对象的引用，而 deepcopy （ 深复制 ）会递归复制所有嵌套对象。

和 copy 的行为 deepcopy ：

使用复制的平面列表示例：

>>> import copy
>>> i = [1,2,3]
>>> j = copy.copy(i)
>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are different

>>> i.append(4)
>>> j
>>> [1,2,3] #Update of original list didn't affect the copied variable

使用复制的嵌套列表示例：

>>> import copy
>>> i = [1,2,3,[4,5]]
>>> j = copy.copy(i)

>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are still different

>>> hex(id(i[3])), hex(id(j[3]))
>>> ('0x10296f908', '0x10296f908') #Nested lists have the same address

>>> i[3].append(6)
>>> j
>>> [1,2,3,[4,5,6]] #Update of original nested list updated the copy as well

使用 deepcopy 的平面列表示例：

>>> import copy
>>> i = [1,2,3]
>>> j = copy.deepcopy(i)
>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are different

>>> i.append(4)
>>> j
>>> [1,2,3] #Update of original list didn't affect the copied variable

使用 deepcopy 的嵌套列表示例：

>>> import copy
>>> i = [1,2,3,[4,5]]
>>> j = copy.deepcopy(i)

>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are still different

>>> hex(id(i[3])), hex(id(j[3]))
>>> ('0x10296f908', '0x102b9b7c8') #Nested lists have different addresses

>>> i[3].append(6)
>>> j
>>> [1,2,3,[4,5]] #Update of original nested list didn't affect the copied variable    

@perreal 一个包含引用的不可变对象，可以引用可变或不可变的对象，只有引用是不可变的，而不是它们的字段。

@Khlorghaal，你的意思是说你不能拥有一个具有可变成员的不可变对象吗？这是不正确的，因为例如你可以拥有一个字典元组。元组是不可变的，一旦创建，元组中字典的 ID 就始终相同。我不明白你对这些陈述的判断有什么错误。

@Stallman 你没有在这里更改引用的列表，只是创建一个新列表并将其指定为其中一个副本的第一个项目。尝试执行 list_[0][0] = 7

只需复制，您就会有一个新的外部列表，但内部列表是引用。对于内部列表，复制的列表会受到原始列表的影响吗？我创建了一个列表列表，例如 list_=[[1,2],[3,4]] newlist = list_.copy() list_[0]=[7,8] 并且新列表保持不变，那么内部列表是引用吗？

对于不可变对象，无需复制，因为数据永远不会改变，因此 Python 使用相同的数据；id 始终相同。对于可变对象，由于它们可能会改变，因此 [浅] 复制会创建一个新对象。

深度复制与嵌套结构有关。如果您有列表列表，那么 copies 也会深度复制嵌套列表，因此这是递归复制。仅使用复制，您就会有一个新的外部列表，但内部列表是引用。

赋值不会复制。它只是设置对旧数据的引用。因此，您需要复制才能创建具有相同内容的新列表。

@Neerav：对于不可变对象来说也是如此。对不可变对象的任何更改都会通过两个变量显示出来，因为您无法更改不可变对象 - 对于不可变对象来说，该语句完全正确。