前言

关于列表的深拷贝和浅拷贝，这是很多人在面试时经常遇到的问题。然而，许多人可能并不清楚它们之间的区别。接下来，我们将详细探讨这两者的差异

Python列表在计算机内存中的存储方式是动态数组，其内容存储在一块连续的内存中。列表变量名存储的是指向该列表的引用地址。

一.浅拷贝

嵌套列表跟没有嵌套的列表是有区别的，以下是两者区别

对于没有嵌套列表的情况，浅拷贝和深拷贝的效果是一样

1.没嵌套的列表

>>> a = [1,2,3,4,5]
>>> b = a #直接赋值，赋值的话，只是把a的引用复制了给b
>>> c= a.copy() #copy函数，直接在内存复制了一份列表
>>> print(id(a),id(b),id(c)) #a,b id是一样的指向同一个内存地址，c是另外一个地址
43545352 43545352 52503688
>>> print(a,b,c)
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
>>> a.append('a') #修改a列表里面的值，b也会跟着变化，c不会有变化
>>> print(a,b,c)
[1, 2, 3, 4, 5, 'a'] [1, 2, 3, 4, 5, 'a'] [1, 2, 3, 4, 5]
>>>

初始列表内存里面的情况

append('a')后内存里面的情况

2.嵌套列表

对于有嵌套列表的情况，浅拷贝和深拷贝的效果就不同

>>> a = [1,2,3,['a','b','c']]
>>> b = a
>>> c = a.copy()
>>> print(a,b,c)
[1, 2, 3, ['a', 'b', 'c']] [1, 2, 3, ['a', 'b', 'c']] [1, 2, 3, ['a', 'b', 'c']]
>>> print(id(a),id(b),id(c))
52573128 52573128 52572296
>>> print(id(a[-1]),id(b[-1]),id(c[-1]))
43548168 43548168 43548168
>>> a.append('x') #在a外层列表添加一个x,结果是，a,b 都加了x,c没变，是跟上面没嵌套列表修改的值是一样的
>>> print(a,b,c)
[1, 2, 3, ['a', 'b', 'c'], 'x'] [1, 2, 3, ['a', 'b', 'c'], 'x'] [1, 2, 3, ['a', 'b', 'c']]
#修改a中内层列表里面的值，b,c内层列表的值也跟变化了
>>> a[-2].append('y')
>>> print(a,b,c)
[1, 2, 3, ['a', 'b', 'c', 'y'], 'x'] [1, 2, 3, ['a', 'b', 'c', 'y'], 'x'] [1, 2, 3, ['a', 'b', 'c', 'y']]
>>>

嵌套列表修改外层列表的值跟没嵌套列表是一样，修改内层里面会引起所有列表内层里面的值变化

对于有嵌套列表的情况，浅拷贝只是复制了最外层的对象，而内部的子对象仍然是引用关系

二.深拷贝

深拷贝需要import copy 模块

1.没嵌套的列表

没有嵌套的列表是跟copy()函数一样的

2.嵌套的列表

>>> import copy
>>> a = [1,2,3,['a','b','c']]
>>> b = copy.copy(a)  #这个copy跟自带的a.copy()是一样的
>>> c = copy.deepcopy(a)
>>> print(a,b,c)
[1, 2, 3, ['a', 'b', 'c']] [1, 2, 3, ['a', 'b', 'c']] [1, 2, 3, ['a', 'b', 'c']]
>>> print(id(a),id(b),id(c)) 
50344840 52625992 43808712
>>> print(id(a[-1]),id(b[-1]),id(c[-1])) 
50327304 50327304 43815752
>>> a[-1].append('x') 
>>> print(a,b,c) #修改a列表后，b列表也跟随变化了，c列表不变
[1, 2, 3, ['a', 'b', 'c', 'x']] [1, 2, 3, ['a', 'b', 'c', 'x']] [1, 2, 3, ['a', 'b', 'c']]
>>>

如下深拷贝与浅拷贝 修改列表后在内存里面的变化

总结

Python中的copy.copy()和copy.deepcopy()都是用于复制对象的函数，但它们之间有一些区别：

1. copy.copy()：浅拷贝，只复制对象本身，而不复制对象内部的子对象。如果对象内部有可变类型（如列表、字典等），则这些子对象仍然会共享同一个引用。
2. copy.deepcopy()：深拷贝，会递归地复制对象及其内部的所有子对象。这样，即使对象内部有可变类型，它们也会被独立地复制，而不是共享同一个引用。
3. copy.copy()适用于简单的对象复制，而copy.deepcopy()适用于需要完全独立的副本的情况。