赋值这种操作，如果是不可变类型，修改不会互相影响。如果是可变类型，修改会互相影响，因为是指向的同一个内存地址，1个变了，另外一个也会变。
浅拷贝：不管是可变类型还是不可变类型，都是一一复制。嵌套的是可变类型，修改会互相影响。
深拷贝：嵌套的可变类型重新创建一份，这样和原来的嵌套可变类型互不影响。不可变类型还是用之前的。如果不可变类型修改，是重新指向新的地址，原来的指向不变。
浅拷贝和深拷贝
一、通过赋值
1.不可变类型
- 不可变类型变量a赋值给另外一个变量b。a,b改变互不影响
# 不可变类型，变量a赋值给b.一方百变另一方不改变。互不影响
a = "阿登"
b = a
print(a, type(a),id(a))
print(b, type(b),id(b))
print("---".center(50, "-"))
b = "向佳"
print(a, type(a),id(a))
print(b, type(b),id(b))
结果：
阿登 <class 'str'> 6376944
阿登 <class 'str'> 6376944
-----------------------------------
阿登 <class 'str'> 6376944
向佳 <class 'str'> 31573248
- 画图理解
image.png
- 可变类型变量a赋值给另外一个变量b。a,b改变，互相影响
# 可变类型a,通过赋值给b。一方改变，另一个也会改变
one_list = [1,2,[3,4]]
two_list = one_list
print(one_list,id(one_list))
print(two_list,id(two_list))
print("---------------------")
two_list[0] = 5
print(one_list,id(one_list))
print(two_list,id(two_list))
结果：
[1, 2, [3, 4]] 42912264
[1, 2, [3, 4]] 42912264
---------------------
[5, 2, [3, 4]] 42912264
[5, 2, [3, 4]] 42912264
二、浅拷贝
from copy import copy
浅拷贝拷贝的是第一层，元素都是不可变类型，修改里面的元素。原来的不会改变
浅拷贝如果元素是可变类型，修改可变类型内的元素，原来的可变类型中的元素也会跟着改变
from copy import copy,deepcopy
list1 = [["a","b"],1]
list2 = copy(list1)
print(list1,type(list1), id(list1))
print(list2,type(list2), id(list2))
list2[0][0] = "c"
print("---".center(50, "-"))
print(list1,type(list1), id(list1))
print(list2,type(list2), id(list2))
结果：
[['a', 'b'], 1] <class 'list'> 35682440
[['a', 'b'], 1] <class 'list'> 35681224
--------------------------------------------------
[['c', 'b'], 1] <class 'list'> 35682440
[['c', 'b'], 1] <class 'list'> 35681224
# 可以看出list1和list2 索引为0的列表里的第一个元素被修改成了'c' .
image.png
三、深拷贝
- 浅拷贝是把第一层内存地址不加区分一一复制一份。
嵌套的可变类型不加一区分，考的内存地址是原来的所以啊你改变嵌套的可变类型的元素，原来的可变嵌套里的元素也变了。 - 深拷贝:将嵌套的可变类型在内存中重新创建一份，而不可变类型还是用之前的。
list1 = [["a","b"],1]
list2 = deepcopy(list1)
print(f"list1嵌套列表的id:{id(list1[0])}--{id(list1[1])}")
print(f"list2嵌套列表的id:{id(list2[0])}--{id(list2[1])}")
print("---".center(50, "-"))
print("嵌套可变第一个元素地址{}\n嵌套可变第2个元素地址{}\n不可变元素地址{}".format(id(list1[0][0]),id(list1[0][1]),id(list1[1])))
print("嵌套可变第一个深拷贝元素地址{}\n嵌套可变深拷贝第2个元素地址{}\n不可变深拷贝元素地址{}".format(id(list2[0][0]),id(list2[0][1]),id(list2[1])))
print(list1,type(list1), id(list1))
print(list2,type(list2), id(list2))
print()
list2[0][0] = "c"
list2[1] = 2
print("list2修改嵌套列表第一个元素为c".center(50, "-"))
print(f"list1嵌套列表的id:{id(list1[0])}--{id(list1[1])}")
print(f"list2嵌套列表的id:{id(list2[0])}--{id(list2[1])}")
print()
print("---".center(50, "-"))
print("嵌套可变第一个元素地址{}\n嵌套可变第2个元素地址{}\n不可变元素地址{}".format(id(list1[0][0]),id(list1[0][1]),id(list1[1])))
print("嵌套可变第一个深拷贝元素地址{}\n嵌套可变深拷贝第2个元素地址{}\n不可变深拷贝元素地址{}".format(id(list2[0][0]),id(list2[0][1]),id(list2[1])))
print(list1,type(list1), id(list1))
print(list2,type(list2), id(list2))
image.png
list1嵌套列表的id:42982152--8791146423120
list2嵌套列表的id:42982472--8791146423120
--------------------------------------------------
嵌套可变第一个元素地址34327160
嵌套可变第2个元素地址34325480
不可变元素地址8791146423120
嵌套可变第一个深拷贝元素地址34327160
嵌套可变深拷贝第2个元素地址34325480
不可变深拷贝元素地址8791146423120
[['a', 'b'], 1] <class 'list'> 42863368
[['a', 'b'], 1] <class 'list'> 42862152
----------------list2修改嵌套列表第一个元素为c----------------
list1嵌套列表的id:42982152--8791146423120
list2嵌套列表的id:42982472--8791146423152
--------------------------------------------------
嵌套可变第一个元素地址34327160
嵌套可变第2个元素地址34325480
不可变元素地址8791146423120
嵌套可变第一个深拷贝元素地址6069192
嵌套可变深拷贝第2个元素地址34325480
不可变深拷贝元素地址8791146423152
[['a', 'b'], 1] <class 'list'> 42863368
[['c', 'b'], 2] <class 'list'> 42862152
总结：
赋值这种操作，如果是不可变类型，修改不会互相影响。如果是可变类型，修改会互相影响，因为是指向的同一个内存地址，1个变了，另外一个也会变。
浅拷贝：不管是可变类型还是不可变类型，都是一一复制。嵌套的是可变类型，修改会互相影响。
深拷贝：嵌套的可变类型重新创建一份，这样和原来的嵌套可变类型互不影响。不可变类型还是用之前的。如果不可变类型修改，是重新指向新的地址，原来的指向不变。
