Python中的引用赋值，深拷贝，浅拷贝

摘要：Python，引用赋值，深拷贝，浅拷贝

总结一下Python中的变量的引用赋值，深拷贝和浅拷贝，先上结论

• 赋值引用会直接将内存地址传递过去，此时变量间不仅值相等，内存地址也相等，是同一个对象。
• 赋值存在缓存重用的情况，当重复定义小整数和字符串变量时，或者在同一个代码块中，内存中已经存在的值会直接被引用，不需要重新创建对象。
• 组合变量存在赋值引用，深拷贝，浅拷贝三种模式，赋值引用将组合对象的每一层地址全部引用，浅拷贝创建新对象，但是内部元素引用旧对象的内部元素，深拷贝所有地址全部重新创建，不依赖之前任何的内存地址。
• 和原始对象的关系或者联系紧密程度：赋值引用 > = 浅拷贝 >= 深拷贝
• 内存的复用程度：赋值引用 > = 浅拷贝 >= 深拷贝
• 变量的崭新程度：深拷贝 >= 浅拷贝 >= 赋值引用

引用赋值

在python中，使用等号无论是直接的变量赋值，还是参数传递，都是按照引用进行赋值的，等号赋值是指将对象的内存指针赋值。
在Python中对于非组合变量（对象中不包含其他对象，只有一层地址关系）的赋值直接使用等号赋值即可，即将一个变量赋值给另一个变量，则两者不仅在数值上相等，而且还是同一对象，id相同，is判断为True，这两个变量都指向这一个数据对象，即这个数据对象有两个引用，只有这两个引用都没了的时候，堆内存中的数据对象才会等待垃圾回收器回收

>>> # 将一个变量赋值给另一个变量
>>> a = 10000
>>> b = a
>>> id(a)
140139864296144
>>> id(b)
140139864296144
>>> a is b
True

如果单独对两个变量赋值，就算赋值的数据对象相同，也只是数据对象的值相等，两个变量在堆内存中是不同的对象。

>>> a = 10000
>>> b = 10000
>>> id(a)
140139864296272
>>> id(b)
140139864296048
>>> a is b
False

---

可变对象，不可变对象对引用赋值的影响

如果变量的值是不可变对象，比如string，int，float，tuple等，其中一个变量重新赋值意味着在内存中要新创建一个数据对象，此时变量间不会相互影响，即不会影响另外一个变量。

>>> a = 10000
>>> b = a
>>> id(a)
140139864296272
>>> id(b)
140139864296272
>>> a = 20000  # 改变a的值
>>> id(a)  # a在堆内存中新创建了一个对象，获得新的id地址
140139864295920
>>> b  # b不变
10000

不可变对象赋值引用改变变量值.png

---

对于可变对象，调用自身方法使的值改变不会改变内存地址。比如列表list，字典dict，集合set，如果是在原数据对象自身上做修改，比如修改列表中的某个元素，列表的地址不会变，还是原来的那个内存对象，此时调用另一个变量的值也会改变，因为是同一个内存对象的两个引用，因此对于可变对象的引用赋值，变量之间是相互影响的。

>>> a = {"a": 1, "b": 3}
>>> b = a
>>> b["c"] = 9  # 改变其中一个变量，给字典新增一个值
>>> a  # 原始变量也会收到影响
{'a': 1, 'b': 3, 'c': 9}
>>> id(a)
140139842087104
>>> id(b)
140139842087104  # 内存地址未改变，只是新增了一个元素

可变对象赋值引用改变变量值.png

---

缓存的重用机制

Python会根据对象的读取频繁程度以及内存占用情况，按照一定规则将对象存入缓存。当程序的其他代码使用这些值的时候，会先去缓存中找并且直接引用缓存中的地址，不需要额外创建，这些值包括：[-5, 256]之间的小整数，字符串对象。

>>> a = -3
>>> b = -3
>>> a is b
True
>>> b = 2234 - 2237
>>> a is b
True

超过256分别赋值就是不同对象了

>>> a = 257
>>> b = 257
>>> a is b
False

字符串是直接读取缓存中地址

>>> a = "aaaabbbbcccc"
>>> b = "aaaabbbbcccc"
>>> a is b
True

除此之外，其他不可变变量如果处在同一个代码块或者同行，也直接获取代码块中缓存的变量，不再另外创建

>>> # 同行
>>> a = 20000; b = 20000
>>> a is b
True
>>> a = 20000
>>> b = 20000
>>> a is b
False

同一个函数代码块

>>> def a():
...     a = -2836755.383274835
...     b = -2836755.383274835
...     print(a is b)
...     print(id(a))
...     print(id(b))
... 
>>> a()
True
140139864296112
140139864296112

深拷贝和浅拷贝

首先深拷贝和浅拷贝是针对组合对象的，组合对象就是这个对象中还包含其他对象，比如list，set，dict等，也就是说这个对象有不止一层内存地址，非组合对象都是直接等号赋值。

• 浅拷贝：创建一个新的组合变量，但是组合变量中每一个元素指向拷贝的对象内元素地址
• 深拷贝：创建一个新的组合变量，原对象中的每个元素都会在新对象中重新创建一次

对于组合对象list，set，dict（没有tuple）自带copy浅拷贝方法，深拷贝需要导入copy模块，调用deepcopy方法，copy的copy方法对应浅拷贝

# 浅拷贝
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> print(a is b)
False
>>> for i, j in zip(a, b):
...     print(id(i))
...     print(id(j))
...     print(i is j)
... 
93994145530624
93994145530624
True
93994145530656
93994145530656
True
93994145530688
93994145530688
True

浅拷贝后新对象地址不一样，但是内部元素引用一致

---

>>> a = [1, 2, 3]
>>> import copy
>>> b = copy.deepcopy(a)
>>> print(a is b)
False
>>> for i, j in zip(a, b):
...     print(id(i))
...     print(id(j))
...     print(i is j)
... 
93994145530624
93994145530624
True
93994145530656
93994145530656
True
93994145530688
93994145530688
True

深拷贝新建了一个对象，但是内部元素也是引用的原始地址，原因是内部元素是小整数，小整数在内存中有缓存直接调用，换一下内部元素为可变对象。

>>> a = [[1, 2], [2, 3], [3, 4]]
>>> b = copy.deepcopy(a)
>>> print(a is b)
False
>>> for i, j in zip(a, b):
...     print(id(i))
...     print(id(j))
...     print(i is j)
... 
140139841222048
140139840826496
False
140139841244208
140139840826816
False
140139841244128
140139840826976
False

原型毕露，深拷贝不仅对象，连对象内部的元素都重新创建，在用新数据试下浅拷贝

>>> a = [[1, 2], [2, 3], [3, 4]]
>>> b = copy.copy(a)
>>> print(a is b)
False
>>> for i, j in zip(a, b):
...     print(id(i))
...     print(id(j))
...     print(i is j)
... 
140139841222048
140139841222048
True
140139841244208
140139841244208
True
140139841244128
140139841244128
True

厉害，浅拷贝只是创建新对象，内部元素还是老的引用。

---

在对比一下组合对象的赋值引用

>>> a = [[1, 2], [2, 3], [3, 4]]
>>> b = a
>>> print(a is b)
True
>>> for i, j in zip(a, b):
...     print(id(i))
...     print(id(j))
...     print(i is j)
... 
140139841222048
140139841222048
True
140139841244208
140139841244208
True
140139841244128
140139841244128
True

可见赋值引用所有地址全部拷贝去了，既不要创建新对象，内部元素也全是来的对象内部元素的引用。

总结

• 赋值引用会之间将内存地址传递过去，此时变量间不仅值相等，内存地址也相等，是同一个对象。
• 分别赋值存在缓存重用的情况，当重复定义小整数和字符串变量时，或者在同一个代码块中，内存中已经存在的值会直接被引用，不需要重新创建对象。
• 组合变量存在赋值引用，深拷贝，浅拷贝三种模式，赋值引用将组合对象的每一层地址全部引用，浅拷贝创建新对象，但是内部元素引用旧对象的内部元素，深拷贝所有地址全部重新创建，不依赖之前任何的内存地址。

最后再用一个例子对比一下组合对象的三种拷贝方式

>>> a = [[1, 2], [2, 3], [3, 4]]
>>> for line in a:
...     line[1] = 9  # 直接拿到组合变量的内部元素进行修改
... 
>>> a
[[1, 9], [2, 9], [3, 9]]
>>> a = [[1, 2], [2, 3], [3, 4]]
>>> for line in a.copy():  # 生成一个新对象遍历，但是内部元素还是旧元素的引用，内部元素是list，地址没变，只是list的第二个值改了，因此也会对原对象产生影响
...     line[1] = 9
... 
>>> a
[[1, 9], [2, 9], [3, 9]]
>>> a = [[1, 2], [2, 3], [3, 4]]
>>> for line in copy.deepcopy(a):  # 创建新元素遍历，内部元素也是新创建的和之前没有任何关系，所以修改内部元素不会对原来变量造成影响
...     line[1] = 9
... 
>>> a
[[1, 2], [2, 3], [3, 4]]

再来一个例子

>>> a = [[1, 2], [2, 3], [3, 4]]
>>> for line in a:
...     b = line
...     b[1] = 9  # 直接拿到值，调用自身方法修改值
... 
>>> a
[[1, 9], [2, 9], [3, 9]]
>>> a = [[1, 2], [2, 3], [3, 4]]
>>> for line in a:
...     b = line.copy()  # 内嵌list更改内存地址，内嵌list的整数元素是旧引用，但是由于新赋值了9，所有指针全部重新指向9，旧对象和旧元素不变
...     b[1] = 9
... 
>>> a
[[1, 2], [2, 3], [3, 4]]
>>> for line in a:
...     b = copy.deepcopy(line)  # 深拷贝更不用说有，全部重新创建，和之前不搭嘎
...     b[1] = 9
... 
>>> a
[[1, 2], [2, 3], [3, 4]]

彻底懂了吧