Python中引用、浅拷贝和深拷贝三个之间的区别_python的浅拷贝和引用拷贝的区别

Python中有六大数据类型：数字（int, float等），字符串str，列表list，字典dict，集合set，元组tuple

其中

可变类型有：列表list，字典dict，集合set

不可变类型有：数字（int, float等），字符串str，元组tuple

目录

一、对于可变类型

1，引用：=赋值符号

2，浅拷贝：copy.copy()方法

3，深拷贝：copy.deepcopy()方法

二、对于不可变对象

1，引用：=赋值符号

2，浅拷贝：copy.copy()方法

3，深拷贝：copy.deepcopy()方法

三、对于可变复合对象

1，引用：=赋值符号

2，浅拷贝：copy.copy()方法

3，深拷贝：copy.deepcopy()方法

四、对于不可变复合对象

1，引用：=赋值符号

2，浅拷贝：copy.copy()方法

3，深拷贝：copy.deepcopy()方法 

结论：

---

一、对于可变类型

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

对于不可变复合对象：使用深拷贝时会根据数据是否是可变类型进行拷贝，是可变类型就拷贝（开辟新地址），不可变类型不拷贝（不开辟新地址）

结论：

对于可变类型，无论是深浅拷贝都会开辟新地址，使用赋值引用=符号时不会开辟新地址
对于不可变类型，无论是深浅拷贝都不会开辟新地址，使用赋值引用=符号也不会开辟地址

对于可变复合对象：使用浅拷贝时只会拷贝（开辟新地址）第一层数据（最外层数据），里面所有嵌套的数据无论是否是可变类型都不会拷贝（不会开辟新地址）
对于可变复合对象：使用深拷贝时会根据数据是否是可变类型进行拷贝，是可变类型就拷贝（开辟新地址），不可变类型不拷贝（不开辟新地址）

对于不可变复合对象：使用浅拷贝时都不会拷贝（不会开辟新地址）
对于不可变复合对象：使用深拷贝时会根据数据是否是可变类型进行拷贝，是可变类型就拷贝（开辟新地址），不可变类型不拷贝（不开辟新地址）

对于可变和不可变复合对象：使用赋值引用=符号时都不会拷贝（不会开辟新地址）