不可变对象赋值引用改变变量值.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]]
彻底懂了吧
