《Python》：深拷贝、浅拷贝、赋值之间的关系（附可变与不可变）【用图文讲清楚！】

背景

想必大家面试或者平时学习经常遇到问python的深拷贝、浅拷贝和赋值之间的区别了吧？看网上的文章很多写的比较抽象，小白接收的难度有点大，于是乎也想自己整个文章出来供参考

可变与不可变

讲深拷贝和浅拷贝之前想讲讲什么是可变数据类型和不可变数据类型

这里有点绕，大概就是：

可变指的是值变化后，变量的id地址没变（同一块地址，值是可以变得）
不可变指的是值变化后，变量的id地址也变了（同一块地址，只能有一个值）

可变的数据类型有：列表（list）、字典（dict）、集合（set）

不可变数据类型有：整型（int）、浮点数（float）、字符串（string）、元组（tuple）、布尔（bool）

什么是不可变数据类型？

不可变具体怎么体现呢，以整形为例：

python中所有的整形都已经有自己的地址了，我们将整形赋值给变量的过程其实是变量的地址指向整形的地址

print(id(1))                                     # 140721648427816
a = 1
# a的id地址和1是一样的
print(id(a))                                     # 140721648427816
print(id(999999999999999999))                    # 2210500291920
b = 999999999999999999
print(id(b))                                     # 2210500291920
c = 1
# c也指向了1的地址，所以a和c的地址是一样的
print(id(a)==id(c))                              # True

同样的，如果将a的值修改为2，那么a的地址就会指向2的id地址。

print(id(1))                                     # 140721648427816
a = 1
# a的id地址和1是一样的
print(id(a))                                     # 140721648427816
a = 2
print(id(a))                                     # 140721573258056

所以，其实可变和不可变是对于id来说的，一个id地址只能指向一个值的数据类型，就是不可变数据类型（换句话就是值变了，地址也变了）

什么是可变数据类型？

直接上代码！

l1 = [1,2,3]
print(id(l1))     # 2259540475456
# 修改变量的值
l1.append(4)
print(id(l1))     # 2259540475456
# 重新给列表赋值
l1 = [3,4,5]
print(id(l1))     # 2259540541952
# 给其他列表赋同样的值
l2 = [3,4,5]
print(id(l2))     # 2259540475456

可以看到，我们修改了列表的值，但是变量的id地址没有发生变化。像这种可以修改值，但是地址

没变，也就是id地址指向的值可以变化的，就叫做可变数据类型

但是！我们可以发现如果是重新给列表赋值，列表的地址是会发生变化的（这里需要注意赋值和修改是不一样的），同样的我们也可以看到给别的列表赋同样的值，他们的id地址也是不一样的。

这是因为我们赋值的是一个列表，那么python在赋值之前呢就会创建一个列表对象（python一切皆对象！），那么创建列表对象的时候python就会给这个列表对象分配一个id，然后我们给l2进行赋值的时候也创建了新的列表对象，那么他就会有新的id

# 代码1
print(id([1,2,3]))  # 2048797408832
print(id([1,2,3]))  # 2048797408832
print(id([1,2,3]))  # 2048797408832
l1 = [1,2,3]
l2 = [1,2,3]
print(id(l1))       # 2048797408832
print(id(l2))       # 2048797475328

# 代码2
a = [1]
print(id(a))  # 执行三次，每次id都不一样

再来看看上面的代码，代码1，连续打印三个[1,2,3]他们的id是相同的，因为创建了[1,2,3]这个临时列表对象，且该对象还没有被回收。[1,2,3]赋值给l1后，居然id和[1,2,3]是一样的，是因为[1,2,3]有值但没有变量名（临时），在l1赋值[1,2,3]的时候就直接把id给了第一次出现的l1，而l2则是生成了一个新的列表对象，所以id和l1的不一样。

浅拷贝、深拷贝和赋值的区别

看到这里相信你已经知道什么是可变数据类型和不可变数据类型了，我们的浅拷贝和深拷贝之间的区别其实只有在可变数据类型才有区别的，或者说是对于可变数据类型才有的深拷贝

不可变数据类型下的浅拷贝、深拷贝和赋值

我们先来看看不可变数据类型的浅拷贝、深拷贝和赋值的区别：

import copy

a = "hello"
# a赋值给b
b = a
# c是a的浅拷贝
c = copy.copy(a)
# d是a的深拷贝
d = copy.deepcopy(a)
print("a的id：", id(a))
print("b的id：", id(b))
print("c的id：", id(c))
print("d的id：", id(d))

结果我们发现他们的id都是一样的，这是因为：

创建了一个临时字符串对象“hello”时分配了地址，然后声明变量a时，a指向了这个地址，然后赋值给b时，其实就是b也指向了a指向的地址，然后浅拷贝和深拷贝其实是返回了a这个变量

我们可以看看copy的源码：（如果不想看分析可以直接点目录看可变数据类型就知其区别）

copy的源码维护了一个_copy_dispatch的字典，第一个框是处理不可变数据类型的，如果是不可变数据类型的话会给这个字典赋值一个函数变量，比如

_copy_dispatch[<class 'int'>]=_copy_immutable

假如是我们刚刚传的字符串，那么代码是这样执行的：

可变数据类型下的浅拷贝、深拷贝和赋值【看这里快速弄懂！】

我们再来看看可变数据类型

import copy
a = [1,2,3]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
print("a的id：", id(a))  # a的id： 2880639630592
print("b的id：", id(b))  # b的id： 2880639630592
print("c的id：", id(c))  # c的id： 2880639446144
print("d的id：", id(d))  # d的id： 2880639446272

这里我们可以看到a的b的id是一样的，这里不再赘述，c和d都是新的id，好了这里我们可以看到和不可变数据类型的区别了，但是还看不出来浅拷贝和深拷贝的区别，我们继续往下看

如果是这种嵌套列表的（其他数据类型也可以只要是可变的就行）

浅拷贝时申请了一片新的地址，然后复制了a列表的第一层的值，后面其实还是指向了a嵌套列表的地址

这个时候我们发现如果你去修改c的嵌套列表是会影响a的值的！

import copy
a = [1,2,3,[4,5,6]]
c = copy.copy(a)
print(a)                                     # [1, 2, 3, [4, 5, 6]]
print(c)                                     # [1, 2, 3, [4, 5, 6]]
# 修改c的第一个元素和嵌套列表的第一个元素
c[0] = 0
c[3][0] = 7
print(a) # a中嵌套列表的值也变了              # [1, 2, 3, [7, 5, 6]]
print(c)                                     # [0, 2, 3, [7, 5, 6]]

有时候一些软件bug就是这样来的，找半天也想到是吧

但是浅拷贝就不一样了，他完全是自己的id地址，不会影响a了

import copy
a = [1,2,3,[4,5,6]]
d = copy.deepcopy(a)
print(a)                                     # [1, 2, 3, [4, 5, 6]]
print(d)                                     # [1, 2, 3, [4, 5, 6]]
# 修改d的第一个元素和嵌套列表的第一个元素
d[0] = 0
d[3][0] = 7
print(a) # a中嵌套列表的值没变                # [1, 2, 3, [4, 5, 6]]
print(d)