拷贝
1.不可变类型和可变类型
知识点:
不可变类型: 字符串 , 元组
可变类型: 列表 , 字典(它的value值) , 集合 (除了可变类型都是不可变类型)
2.浅拷贝和深拷贝
知识点:
python中拷贝模块: copy
1. 浅拷贝: copy.copy()
2. 深拷贝: copy.deepcopy()
3. 结论:
浅拷贝: 最多拷贝一层
深拷贝: 可能拷贝多层
3.不可变类型的拷贝
浅拷贝:
# 常见的不可变类型容器: 字符串,元组
from copy import copy
# 字符串浅拷贝
s1 = 'abcdefg'
s2 = copy(s1)
print(s2)
print(id(s1)) # 2671807844656
print(id(s2)) # 2671807844656
print('---------------------------------------')
# 元组的浅拷贝
t1 = (1,2,3,4,5)
t2 = copy(t1)
print(t2)
print(id(t1)) # 1621263292432
print(id(t2)) # 1621263292432
print('---------------------------------------')
# 元组嵌套
tu1 = (1,2,(3,4,5))
tu2 = copy(tu1)
print(tu2)
print(id(tu1)) # 2398684684672
print(id(tu2)) # 2398684684672
print(tu1[2]) # (3, 4, 5)
print(tu2[2]) # (3, 4, 5)
print(id(tu1[2])) # 1483914034944
print(id(tu2[2])) # 1483914034944
# 结论: 对于不可变类型浅拷贝都是直接引用了原来的地址,没有开辟新的地址
深拷贝:
# 常见的不可变类型容器: 字符串,元组
from copy import deepcopy
# 字符串深拷贝
s1 = 'abcdefg'
s2 = deepcopy(s1)
print(s2)
print(id(s1)) # 2614005088368
print(id(s2)) # 2614005088368
print('---------------------------------------')
# 元组的浅拷贝
t1 = (1,2,3,4,5)
t2 = deepcopy(t1)
print(t2)
print(id(t1)) # 2614000130064
print(id(t2)) # 2614000130064
print('---------------------------------------')
# 元组嵌套
tu1 = (1,2,(3,4,5))
tu2 = deepcopy(tu1)
print(tu2)
print(id(tu1)) # 2614006030912
print(id(tu2)) # 2614006030912
print(tu1[2]) # (3, 4, 5)
print(tu2[2]) # (3, 4, 5)
print(id(tu1[2])) # 2614006005504
print(id(tu2[2])) # 2614006005504
# 结论:对于不可变类型深拷贝都是直接引用了原来的地址,没有开辟新的地址
4.可变类型的拷贝
浅拷贝:
# 可变类型容器: 列表 , 字典 , 集合
from copy import copy
# 列表浅拷贝
list1 = [1, 2, 3, 4, 5]
list2 = copy(list1)
print(list2)
print(id(list1)) # 1788150694272
print(id(list2)) # 1788150695104
print('----------------------------------')
# 列表嵌套
a1 = [1, 2, [3, 4, 5]]
a2 = copy(a1)
print(a2)
print(id(a1)) # 2114821471936
print(id(a2)) # 2114821471936
print(a1[2]) # [3, 4, 5]
print(a2[2]) # [3, 4, 5]
print(id(a1[2])) # 1647661700800
print(id(a2[2])) # 1647661700800
# 结论: 对于可变类型浅拷贝最多拷贝一层,其他的保留了原来的引用地址
深拷贝:
# 可变类型容器: 列表 , 字典 , 集合
from copy import deepcopy
# 列表深拷贝
list1 = [1, 2, 3, 4, 5]
list2 = deepcopy(list1)
print(list2)
print(id(list1)) # 2717051408576
print(id(list2)) # 2717051409408
print('----------------------------------')
# 列表嵌套
a1 = [1, 2, [3, 4, 5]]
a2 = deepcopy(a1)
print(a2)
print(id(a1)) # 2717051305344
print(id(a2)) # 2717051409984
print(a1[2]) # [3, 4, 5]
print(a2[2]) # [3, 4, 5]
print(id(a1[2])) # 2717051409664
print(id(a2[2])) # 2717051410432
# 结论: 对于可变类型深拷贝可以拷贝多层,都开辟新的内存地址
5.特殊情况
不可变类型嵌套可变类型
可见,在元组嵌套列表时,由于列表时可变类型,导致深拷贝时,元组本身的不可变类型的数据也被复制了一份,由此可以看到,不可变类型也有可能被重复创建.
from copy import deepcopy
# 不可变类型套可变(面试题)
t1 = (1, 2, [3, 4, 5])
t2 = deepcopy(t1)
print(t2) # (1, 2, [3, 4, 5])
print(id(t1)) # 1974352432448
print(id(t2)) # 1974353561792 此处变化了,受内部可变类型的影响
print(t1[2]) # [3, 4, 5]
print(t2[2]) # [3, 4, 5]
print(id(t1[2])) # 2193229955456
print(id(t2[2])) # 2193229956544
# 特殊情况: 如果不可变类型里面套了可变类型,都会开辟新的内存地址