本文详细探讨了Python中可变和不可变数据类型的拷贝行为，包括引用、浅拷贝和深拷贝。对于可变类型如列表、字典和集合，无论是深拷贝还是浅拷贝都会创建新地址，而引用则不会。不可变类型如数字、字符串和元组在浅拷贝和深拷贝中都不会创建新地址，引用同样如此。对于可变复合对象，浅拷贝仅拷贝最外层，深拷贝会递归处理可变类型。不可变复合对象的处理方式类似，深拷贝会对可变子元素进行拷贝。
Python中有六大数据类型：数字（int, float等），字符串str，列表list，字典dict，集合set，元组tuple
其中
可变类型有：列表list，字典dict，集合set
不可变类型有：数字（int, float等），字符串str，元组tuple
目录
一、对于可变类型
1，引用：=赋值符号
a = {"a": 1, "b": 2}
b = a
print(a) # {'a': 1, 'b': 2}
print(b) # {'a': 1, 'b': 2}
print(id(a)) # 3231591188544
print(id(b)) # 3231591188544
print(a == b) # True
print(a is b) # True
使用赋值引用=符号时不会拷贝（不会开辟新地址）
2，浅拷贝：copy.copy()方法
import copy
a = {"a": 1, "b": 2}
b = copy.copy(a)
print(a) # {'a': 1, 'b': 2}
print(b) # {'a': 1, 'b': 2}
print(id(a)) # 3159722903616
print(id(b)) # 3159722903680
print(a == b) # True
print(a is b) # False对于可变类型，无论是深浅拷贝都会拷贝（开辟新地址）
3，深拷贝：copy.deepcopy()方法
import copy
a = {"a": 1, "b": 2}
b = copy.deepcopy(a)
print(a) # {'a': 1, 'b': 2}
print(b) # {'a': 1, 'b': 2}
print(id(a)) # 2130634229824
print(id(b)) # 2130636795264
print(a == b) # True
print(a is b) # False对于可变类型，无论是深浅拷贝都会拷贝（开辟新地址）
二、对于不可变对象
1，引用：=赋值符号
import copy
x = (1, 2)
y = x
print(x) # (1, 2)
print(y) # (1, 2)
print(id(x)) # 2722753740672
print(id(y)) # 2722753740672
print(x == y) # True
print(x is y) # True使用赋值引用=符号不会拷贝（不会开辟地址）
2，浅拷贝：copy.copy()方法
import copy
x = (1, 2)
y = copy.copy(x)
print(x) # (1, 2)
print(y) # (1, 2)
print(id(x)) # 2464879148928
print(id(y)) # 2464879148928
print(x == y) # True
print(x is y) # True对于不可变类型，无论是深浅拷贝都不会拷贝（不会开辟新地址）
3，深拷贝：copy.deepcopy()方法
import copy
x = (1, 2)
y = copy.copy(x)
print(x) # (1, 2)
print(y) # (1, 2)
print(id(x)) # 2464879148928
print(id(y)) # 2464879148928
print(x == y) # True
print(x is y) # True对于不可变类型，无论是深浅拷贝都不会拷贝（不会开辟新地址）
三、对于可变复合对象
1，引用：=赋值符号
import copy
z = [1, {"age": 33}, (11, 22)]
w = z
print(z) # [1, {'age': 33}, (11, 22)]
print(w) # [1, {'age': 33}, (11, 22)]
print(id(z)) # 2254907732608
print(id(w)) # 2254907732608
print(z == w) # True
print(z is w) # True
print(z[0] is w[0]) # True
print(z[1] is w[1]) # True
print(z[2] is w[2]) # True对于可变复合对象：使用赋值引用=符号时都不会拷贝（不会开辟新地址）
2，浅拷贝：copy.copy()方法
import copy
z = [1, {"age": 33}, (11, 22)]
w = copy.copy(z)
print(z) # [1, {'age': 33}, (11, 22)]
print(w) # [1, {'age': 33}, (11, 22)]
print(id(z)) # 1276900438976
print(id(w)) # 1276900113088
print(z == w) # True
print(z is w) # False
print(z[0] is w[0]) # True
print(z[1] is w[1]) # True
print(z[2] is w[2]) # True对于可变复合对象：使用浅拷贝时只会拷贝（开辟新地址）第一层数据（最外层数据），里面所有嵌套的数据无论是否是可变类型都不会拷贝（不会开辟新地址）
3，深拷贝：copy.deepcopy()方法
import copy
z = [1, {"age": 33}, (11, 22)]
w = copy.deepcopy(z)
print(z) # [1, {'age': 33}, (11, 22)]
print(w) # [1, {'age': 33}, (11, 22)]
print(id(z)) # 2109476139456
print(id(w)) # 2109468071872
print(z == w) # True
print(z is w) # False
print(z[0] is w[0]) # True
print(z[1] is w[1]) # False
print(z[2] is w[2]) # True对于可变复合对象：使用深拷贝时会根据数据是否是可变类型进行拷贝，是可变类型就拷贝（开辟新地址），不可变类型不拷贝（不开辟新地址）
四、对于不可变复合对象
1，引用：=赋值符号
import copy
tuple1 = (1, {"age", 10}, "abc", [11, 22, 33])
tuple2 = tuple1
print(tuple1) # (1, {10, 'age'}, 'abc', [11, 22, 33])
print(tuple2) # (1, {10, 'age'}, 'abc', [11, 22, 33])
print(id(tuple1)) # 2307305972576
print(id(tuple2)) # 2307305972576
print(tuple1 == tuple2) # True
print(tuple1 is tuple2) # True
print(tuple1[0] is tuple2[0]) # True
print(tuple1[1] is tuple2[1]) # True
print(tuple1[2] is tuple2[2]) # True
print(tuple1[3] is tuple2[3]) # True对于不可变复合对象：使用赋值引用=符号时都不会拷贝（不会开辟新地址）
2，浅拷贝：copy.copy()方法
import copy
tuple1 = (1, {"age", 10}, "abc", [11, 22, 33])
tuple2 = copy.copy(tuple1)
print(tuple1) # (1, {10, 'age'}, 'abc', [11, 22, 33])
print(tuple2) # (1, {10, 'age'}, 'abc', [11, 22, 33])
print(id(tuple1)) # 2523963556384
print(id(tuple2)) # 2523963556384
print(tuple1 == tuple2) # True
print(tuple1 is tuple2) # True
print(tuple1[0] is tuple2[0]) # True
print(tuple1[1] is tuple2[1]) # True
print(tuple1[2] is tuple2[2]) # True
print(tuple1[3] is tuple2[3]) # True对于不可变复合对象：使用浅拷贝时都不会拷贝（不会开辟新地址）
3，深拷贝：copy.deepcopy()方法
import copy
tuple1 = (1, {"age", 10}, "abc", [11, 22, 33])
tuple2 = copy.deepcopy(tuple1)
print(tuple1) # (1, {10, 'age'}, 'abc', [11, 22, 33])
print(tuple2) # (1, {10, 'age'}, 'abc', [11, 22, 33])
print(id(tuple1)) # 1417646908096
print(id(tuple2)) # 1417655276304
print(tuple1 == tuple2) # True
print(tuple1 is tuple2) # False
print(tuple1[0] is tuple2[0]) # True
print(tuple1[1] is tuple2[1]) # False
print(tuple1[2] is tuple2[2]) # True
print(tuple1[3] is tuple2[3]) # False对于不可变复合对象：使用深拷贝时会根据数据是否是可变类型进行拷贝，是可变类型就拷贝（开辟新地址），不可变类型不拷贝（不开辟新地址）
结论：
对于可变类型，无论是深浅拷贝都会开辟新地址，使用赋值引用=符号时不会开辟新地址 对于不可变类型，无论是深浅拷贝都不会开辟新地址，使用赋值引用=符号也不会开辟地址
对于可变复合对象：使用浅拷贝时只会拷贝（开辟新地址）第一层数据（最外层数据），里面所有嵌套的数据无论是否是可变类型都不会拷贝（不会开辟新地址） 对于可变复合对象：使用深拷贝时会根据数据是否是可变类型进行拷贝，是可变类型就拷贝（开辟新地址），不可变类型不拷贝（不开辟新地址）
对于不可变复合对象：使用浅拷贝时都不会拷贝（不会开辟新地址） 对于不可变复合对象：使用深拷贝时会根据数据是否是可变类型进行拷贝，是可变类型就拷贝（开辟新地址），不可变类型不拷贝（不开辟新地址）
对于可变和不可变复合对象：使用赋值引用=符号时都不会拷贝（不会开辟新地址）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
