单层浅拷贝

import copy
a = 1  # 不可变数据类型copy_a = copy.copy(a)
print(id(a),id(copy_a))  # 内存地址相同a = [1,2]  # 可变数据类型copy_a = copy.copy(a)
print(id(a),id(copy_a))  # 内存地址不相同

单层深拷贝

import copy
a = 1  # 不可变数据类型copy_a = copy.deepcopy(a)
print(id(a),id(copy_a))  # 内存地址相同a = [1,2]  # 可变数据类型copy_a = copy.deepcopy(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))  # 内存地址相同# 情况二，内嵌不可变数据类型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 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]))  # 内存地址相同

结论二：

浅拷贝：

1. 外层是不可变类型、不管内层是否可变都是引用拷贝

2. 外层是可变类型，不管内层是否可变都会从新创建新的内存空间

深拷贝：

1. 外层是不可变类型，会递归判断内层数据类型、如果可变则创建新的内存地址、都为不可变就是引用拷贝

2. 外层是可变数据类型、不管内层是否可变都会创新新的内存地址、但是内部如果为可变则递归创建、不可变则为引用地址

总结：

浅拷贝：

1. 浅拷贝只做最顶层的数据类型判断

2. 如果顶层是可变类型则创建新的内存空间

3. 如果顶层是不可变数据类型就是引用拷贝

深拷贝：

1. 深拷贝做递归拷贝，可以递归拷贝所有的内部嵌套数据（可以理解为循环遍历做浅拷贝判断）

2. 深拷贝递归拷贝遇到可变类型则创建新的内存空间

3. 深拷贝递归拷贝遇到不可变数据类型就是拷贝的引用

作者：FANDX

原文出处： https://www.cnblogs.com/fandx/p/10462913.html