关于python中的深拷贝和浅拷贝的总结

可变对象和不可变对象

了解深拷贝和浅拷贝之前你得先知道什么时可变对象什么是不可变对象传送门

深拷贝和浅拷贝拷贝不可变对象时

import copy
a = 1
b = copy.copy(a)
c = copy.deepcopy(a)
print(id(a))
print(id(b))
print(id(c)

输出结果

140714631783056
140714631783056
140714631783056

当深拷贝和浅拷贝拷贝可变对象时

a = [1,2]b = copy.copy(a)
c = copy.deepcopy(a)
a.append(3)
print(a)
print(b)
print(c)
print(id(a))
print(id(b))
print(id(c))

输出结果:

[1, 2, 3]
[1, 2]
[1, 2]
2161196250376
2161196250248
2161196250632

不管深拷贝还是浅拷贝对不可变数据类型都是引用内存地址
不管深拷贝还是浅拷贝对可变数据类型都是会重新创建新的内存空间

浅拷贝嵌套对象

# -----------不可变数据类型---------
# 情况一，内嵌可变数据类型
import copy
a = ([1,2],(3,4))  # 不可变数据类型
copy_a = copy.copy(a)
print(id(a),id(copy_a))  # 内存地址相同
# 情况二，内嵌不可变数据类型
a = ((1,2),(3,4))  # 不可变数据类型
copy_a = copy.copy(a)
print(id(a),id(copy_a))  # 内存地址相同#-----------可变数据类型-------------
# 情况一，内嵌可变数据类型
import copy
a = [(1,2),[3,4]]  # 可变数据类型
copy_a = copy.copy(a)
print(id(a),id(copy_a))  # 内存地址不相同# 情况一， 可变数据类型 内嵌可变数据类型
import copy
a = [(1,2),(3,4)]  # 可变数据类型
copy_a = copy.copy(a)
print(id(a),id(copy_a))  # 内存地址不相同

import copya = [1,2,[3,4]]b = copy.copy(a)
print(a)
print(b)
print(id(a))
print(id(b))a[2].append(5)
print(a)
print(b)
print(id(a))
print(id(b))

输出结果:

[1, 2, [3, 4]]
[1, 2, [3, 4]]
2879593821128
2879593821512
[1, 2, [3, 4, 5]]
[1, 2, [3, 4, 5]]
2879593821128
2879593821512     # 内存地址虽然不一样，但是当a的顶层的数据发生了变化   b的顶层的数据也发生了变化

深拷贝嵌套对象

# -----------不可变数据类型---------
# 情况一，内嵌可变数据类型
import copy
a = ([1,2],(3,4))  # 不可变数据类型
copy_a = copy.deepcopy(a)
print(id(a),id(copy_a))  # 内存地址不相同
# 情况二，内嵌不可变数据类型
a = ((1,2),(3,4))  # 不可变数据类型
copy_a = copy.deepcopy(a)
print(id(a),id(copy_a))  # 内存地址相同#-----------可变数据类型-------------
# 情况一，内嵌可变数据类型
import copy
a = [(1,2),[3,4]]  # 可变数据类型
copy_a = copy.deepcopy(a)
print(id(a),id(copy_a))  # 内存地址不相同
print(id(a[0]),id(copy_a[0]))  # 内存地址相同
print(id(a[1]),id(copy_a[1]))  # 内存地址不相同# 情况一， 可变数据类型 内嵌可变数据类型
import copy
a = [(1,2),(3,4)]  # 可变数据类型
copy_a = copy.deepcopy(a)
print(id(a),id(copy_a))  # 内存地址不相同
print(id(a[0]),id(copy_a[0]))  # 内存地址相同

a = [1,2,[3,4]]b = copy.deepcopy(a)
print(a)
print(b)
print(id(a))
print(id(b))a[2].append(5)
print(a)
print(b)
print(id(a))
print(id(b))

输出结果:

[1, 2, [3, 4]]
[1, 2, [3, 4]]
2049726264200
2049726264584
[1, 2, [3, 4, 5]]
[1, 2, [3, 4]]
2049726264200   # 这时候和浅拷贝不一样了哦，虽然a的顶层的数据发生了变化，但是b还是未发生变化
2049726264584

浅拷贝：

外层是不可变类型、不管内层是否可变都是引用拷贝
外层是可变类型，不管内层是否可变都会从新创建新的内存空间
当拷贝另一个对象后，顶层的数据时引用原对象的，所以原对象的顶层数据发生改变，拷贝的也会发生改变

深拷贝：

外层是不可变类型，会递归判断内层数据类型、如果可变则创建新的内存地址、都为不可变就是引用拷贝
外层是可变数据类型、不管内层是否可变都会创新新的内存地址、但是内部如果为可变则递归创建、不可变则为引用地址
面对可变对象的时候就相当于时将a完全拷贝到一个新的内存地址

总结

浅拷贝

浅拷贝只做最顶层的数据类型判断
如果顶层是可变类型则创建新的内存空间
如果顶层是不可变数据类型就是引用拷贝

深拷贝

拷贝做递归拷贝，可以递归拷贝所有的内部嵌套数据（可以理解为循环遍历做浅拷贝判断）
深拷贝递归拷贝遇到可变类型则创建新的内存空间
深拷贝递归拷贝遇到不可变数据类型就是拷贝的引用

参考博客:
https://www.cnblogs.com/fandx/p/10462913.html