4-1-3 内存相关+深浅拷贝
(一).Outline
1.内存相关
2.深浅拷贝
(二).Content
1.内存相关
1.1 赋值意味着重新开辟一个新的内存空间。但python中有特例 -缓存机制。
但是在python中，由于python内部性能优化，为了避免浪费内存，存在一个缓存机制。对于一些常用的int、str、float(浮点型)而言，不用再重新开辟内存空间，而是共用1个内存空间。list/dict/set/bool/tuple若赋值,则仍需重新开辟1个新的内存空间。
缓存机制内的3种数据范围如下：
-
int：-5 -256以内的数字；叫小数据池。？？？py3.6.8 & py2.7无论任何数字全部缓存了。？？？
-
str：只有当‘str中含有非字母、下划线的符号，同时乘了一个大于1的数字’时，才会重新开辟内存空间。其他case均在缓存机制内。
-
float：后补。
示例一：赋值 -重新开辟1个内存空间。适用于list/dict/set/bool/tuple以及范围外的int/str/float。
# 写在前面：
# 1.等号代表赋值。不管是同一个变量，还是不同的变量，=均代表赋值。
# 2.在python中，若赋值，除了范围内的int/str/float不需要重新开辟内存空间外，其它list/dict/set/bool /tuple均需要重新开辟一块内存空间。
# (1).赋值 -需要重新开辟内存空间的：list/dict/set/bool/tuple + 范围外的int/str/float。
# list/dict/set/bool/tuple：
v1 = [11, 22, 33]
v2 = [11, 22, 33]
print(id(v1), id(v2))
# 结果：(60714248L, 61296392L) # 每次在电脑内存中开辟空间都是随机的，故内存地址也是随机的。 # 每次开辟的空间都不一样。故2次打印的内存地址也会不同。
v1 = {11, 22, 33}
v2 = {11, 22, 33}
v1 = (11, 22, 33)
v2 = (11, 22, 33)
v1 = False
v2 = False
print(v1 is v2) # # True？？？？？？？？？？？？？。。。。。。。。。。。。。。。。。。。。。。。？？？
v1 = {'name': '吕布', 'age':18}
v2 = {'name': '吕布', 'age':18}
# 范围外的int/str/float：
v1 = 257
v2 = 257
print(v1 is v2) # True？？？。。。。。。。。。。。在终端是False，在pycharm中是True？？？？？。。。
v1 = '$' * 8
v2 = '$' * 8
print(v1 is v2) # False
print(v1 == v2) # True # 以上情况均是重新开辟内存空间。2者的内存地址不同。
# 另外，若给同一个变量重新赋值，在没有其他变量使用原内存空间的情况下，计算机会将此内存空间进行垃圾回收。
v1 = [1, 2, 3] # 内存垃圾 -待回收。
v1 = [1, 2, 3]
或：
v1 = [1, 2, 3, 4] # 内存垃圾 -待回收。
v1 = [1, 2, 3]
示例二：特例。
# (2).赋值 -不需要重新开辟内存空间的：范围内的int/str/float。
# a.-5 - 256以内的数字。
v1 = 99
v2 = 99
# b.常用字符串(不含非字母、下划线以外的符号，同时不做乘法计算：乘以一个大于1的数字)。
v1 = 'zxcv'
v2 = 'zxcv' # 以上2种情况，v1,v2共用1个内存空间,2者内存地址相同。
1.2 两个变量共用一个内存空间，然后修改此内存里存储的内容/赋值。
Case1：两个变量共用一个内存空间，然后做内部修改。-老巢变了,都变。
写在前面：仅list/dict/set存在此情况。
v1 = [1, 2]
v2 = v1 # 代表v1,v2共用一个内存空间。
v1 = [1, 2]
v2 = v1
v1.append(666)
print(v2) # v2变了 -含666。因为是在2者共用的内存空间内部做的修改。
练习题： 2种修改方式。
v1 = [1, 2, 3]
v2 = [11, 22, v1] # v2[-1]和v1共用一个内存空间。
v1.append(666) # 老巢变了，则都变。
print(v2) # [11, 22, [1, 2, 3, 666]]
v1 = [1, 2, 3]
v2 = [11, 22, v1]
v2[-1].append(666) # 这是通过v2[-1]找到的老巢，然后进行修改。
print(v1) # [1, 2, 3, 666]
# 写在最后：不管是在哪边修改，只要是老巢变了，则2者都变。
Case2：两个变量共用一个内存空间，然后赋值。-老巢没变,则不变。
写在前面：int/bool/str/tuple只能赋值,不能做内部修改。
但list/dict/set两种情况(既可赋值也可做内部修改)都存在。
v1 = [1, 2]
v2 = v1
v1 = [11, 22, 33]
print(v2) # v2没变 -因为v1是重新赋值，而不是修改老巢。只要老巢不变，v2就不变！
# 结果：[1, 2]
练习题：2种赋值方式。
v1 = [1, 2, 3]
v2 = [11, 22, v1]
v1 = 999 # 重新赋值。老巢没变。v2没变。
print(v2) # [11, 22, [1, 2, 3]]
v1 = [1, 2, 3]
v2 = [11, 22, v1]
v2[-1] = 999 # 改的只是v2这边的元素指向(重新赋值)，老巢没变。故,v1不变。
print(v1) # [1, 2, 3]
# 写在最后：不管是在哪边赋值，只要是老巢没变，则未被赋值的那个就不变。
Case1 & Case2综合练习题:
# 1.共用一个内存空间，然后做内部修改。-老巢变了,则都变。 # 2种修改方式。
v1 = [1, 2]
v2 = [2, 3]
v3 = [11, 22, v1, v2, v1]
v1.append(666)
print(v3) # v3变了 -含666。因为老巢变了。
v1 = [1, 2]
v2 = [2, 3]
v3 = [11, 22, v1, v2, v1]
v3[2].append(7)
print(v1) # v1变了 -含7。因为老巢变了。
# 2.共用一个内存空间，然后赋值。-老巢没变,则不变。 # 2种赋值方式。
v1 = [1, 2]
v2 = [2, 3]
v3 = [11, 22, v1, v2, v1]
v1 = 100
print(v3) # v3没变。因为老巢没变。
v1 = [1, 2]
v2 = [2, 3]
v3 = [11, 22, v1, v2, v1]
v3[2] = 100
print(v1) # v1没变。因为改变的只是v3[2]的指向，老巢没变。
# 写在最后：判断变量是否发生改变，只需看2者共用的那个内存空间有没有做修改即可(即看老巢变没变)。
1.3 练习题 -1：可变/不可变数据类型共用一个内存空间。
# 一.list/dict/set(可变) -共用一个内存空间，然后赋值/做内部修改。-判断结果如何，只需看老巢变没变！！
# 1.
v1 = [1, 2, 3]
v2 = v1
v3 = v1
v1.append(999) # v2，v3都变了。因为老巢变了。
print(v2, v3)
# 2.
v1 = [1, 2, 3]
v2 = v1
v3 = v1
v1 = [1, ] # 重新赋值。# v2，v3没变。因为老巢没变。
print(v2, v3)
# 3.
v1 = [1, 2, 3]
v2 = v1
v3 = v1
v2 = [1, ] # 重新赋值。# v2，v3没变。因为老巢没变。
print(v1, v3)
# 4.
v1 = [1, 2, 3]
v2 = v1
v3 = v2 # v3指向的依然是[1, 2, 3]这个内存空间。
v2 = [1, ]
print(v1, v3) # v1，v3没变。因为老巢没变。
# 5.
v1 = {1, 2, 3}
v2 = v1
v1.add(999) # 修改老巢。
print(v1, v2) # v1，v2都变了。因为老巢变了。
# 6.
v1 = {1, 2, 3}
v2 = v1
new_set = v1.intersection([1, 22, 3]) # 取交并补集是生成一个新的set，即重新去开辟一个内存空间。而
print(v1, v2) # v1，v2没变。因为老巢没变。 # 不是在原有set上进行修改。
# 二.str/int/tuple/bool(不可变) -共用一个内存空间，然后赋值。-结果均不变。因为老巢不会变！！
# 因为：不可变数据类型不管做任何操作，均不会改变原数据(即不可变类型的老巢永远不会被修改)，而是生成新的数据(即会去重新开辟一个内存空间放修改后的数据的内存地址)。
# 1.
v1 = 'lvbu' # str是不可变数据类型。
v2 = v1
new_str = v1.upper() # 是去重新开辟一个内存空间，放LVBU的内存地址。而不是在原有lvbu上做操作。
print(v1, v2) # 不变。因为老巢没变。
# 对比可变数据类型：
v1 = [1, 2, 3] # list是可变数据类型。
v2 = v1
v1.append(666) # 是对原有数据进行修改(即修改老巢)。
print(v1, v2) # 都变了。因为老巢变了。
# 2.
v1 = 'lvbu'
sequence = v1[0:2] # # 是去重新开辟一个内存空间，放lv的内存地址。而不是在原有lvbu上做操作。
print(v1) # 没变。因为老巢没变。
1.3 练习题 -2：可变数据类型共用一个内存空间 -多重嵌套。
# list/dict/set(可变) -共用一个内存空间，然后赋值/做内部修改。-判断结果如何，只需看老巢变没变！！
# 可变数据类型 -多重嵌套。
# ps：多重嵌套这种，画图一定要画到最底层元素！
# 练习1.
v1 = [1, 2, 3]
v2 = v1
v1[0] = [11, 22] # 修改老巢里面的内部元素。
print(v1, v2) # v1，v2都变了。因为老巢变了。
# 写在最后：虽然v1，v2的指向没变，但它们共同指向的这个内存空间里的内部元素指向变了。故2者均会随之改变。
# 练习2.
v1 = [1, 2, [88, 99], 3]
v2 = v1
v1[0] = 10 # 修改老巢里面的内部元素。
print(v1, v2) # v1，v2都变了。因为老巢变了。
v1 = [1, 2, [88, 99], 3]
v2 = v1
v1[2] = '吕布' # 修改老巢里面的内部元素。
print(v1, v2) # v1，v2都变了。因为老巢变了。
v1 = [1, 2, [88, 99], 3]
v2 = v1
v1[2][0] = 666 # 修改老巢里面的内部元素。
print(v1, v2) # v1，v2都变了。因为老巢变了。
# 写在最后：虽然v1，v2的指向没变，但它们共同指向的这个内存空间里的内部元素指向变了。故2者均会随之改变。
# 练习3.
v1 = [1, 2]
v2 = [1, 2, v1]
v1[0] = '吕布'
print(v2) # v2变了。因为老巢变了。
v1 = [1, 2]
v2 = [1, 2, v1]
v2[-1] = 999 # 改变指向，重新赋值。
print(v1) # v1没变。因为老巢没变。
v1 = [1, 2]
v2 = [1, 2, v1]
v2[-1][0] = 999 # 通过v2[-1][0]找到老巢，并修改。
print(v1) # v1变了。因为老巢变了。
# 写在最后：判断最后结果变没变，只需看老巢变没变即可！！
1.4 id is ==
-
id -id()是查看某个数据的内存地址。
# 定义：在Python中，id是内存地址。可以利用id()内置函数去查询一个数据的内存地址： # 示例： name = '吕布' name_id = id(name) # 通过内置方法获取name变量对应的值在内存中的编号。 print(name_id) # 49941360 这就是name在内存中的编号。 -
is -比较两边的内存地址是否相等。
v1 = [1, 2] v2 = [1, 2] print(v1 is v2) # False v1 = [1, 2] v2 = v1 print(v1 is v2) # True -
== -比较的两边的数值是否相等。
v1 = [1, 2] v2 = [1, 2] print(v1 == v2) # True v1 = [1, 2] v2 = v1 print(v1 == v2) # True
2.深浅拷贝
2.0格式
import copy # 引入copy模块。
a = '吕布'
b = copy.copy(a) # 浅copy
c = copy.deepcopy(a) # 深copy
2.1str/int/bool此3种不可变数据类型，深浅copy相同。-均是共用一份内存空间。
# 以str为例:
import copy
a = '吕布'
b = copy.copy(a) # 浅copy
c = copy.deepcopy(a) # 深copy
print(a is b) # True
print(a is c) # True
# 写在最后：按说结果应该都是False，因为copy过来后重新开辟了一个新的内存空间。
# 但是由于python的小数据池缘故(为了防止浪费内存)，对常用的这些str/int/bool数据，不会再重新开辟内存空间，而是沿用原来的内存空间。
# 故，str/int/bool 深/浅copy后的数据的id和原有数据id相同(因为是共用1个内存空间)。
2.2list/set/dict此3种可变数据类型的深浅copy。
写在前面：深copy只有在list/set/dict中存在嵌套list/set/dict时才有意义。(因为它copy的是所有的可变类型)
ps-1: 浅copy：只copy空壳+第一层元素。内部的所有元素均不copy。
ps-2: 深copy：是将内部所有的可变类型的数据全都copy一份。不可变数据延用原来的(python小数据池的缘故)。
# 示例一：拷贝list-无嵌套。-->深/浅copy相同。
# 浅copy：只copy空壳+第一层元素；
# 深copy：是将内部所有的可变类型的数据全都copy一份。不可变数据延用原来的。
import copy
v1 = [1, 2, 3]
v2 = copy.copy(v1) # 浅copy
v3 = copy.deepcopy(v1) # 深copy
print(v1 == v2) # True
print(v1 is v2) # False
print(v1[0] is v2[0]) # True
# 示例二：拷贝list中嵌套list。-->深/浅copy不同。
# 浅copy：只copy空壳+第一层元素；
# 深copy：是将内部所有的可变类型的数据全都copy一份。不可变数据延用原来的。
import copy
v1 = [1, 2, 3, [11, 22]]
v2 = copy.copy(v1) # 浅copy
v3 = copy.deepcopy(v1) # 深copy
print(v1 == v2) # True
print(v1 == v3) # True
print(v1 is v2) # False
print(v1 is v3) # False
print(v1[-1] is v2[-1]) # True
print(v1[-1] is v3[-1]) # False
print(v1[-1][0] is v3[-1][0]) # True
# 示例三：拷贝list中嵌套dict。-->深/浅copy不同。
# 浅copy：只copy空壳+第一层元素；
# 深copy：是将内部所有的可变类型的数据全都copy一份。不可变数据延用原来的。
import copy
v1 = [1, 2, 3, {'k1': 11, 'k2': 22}]
v2 = copy.copy(v1) # 浅copy
v3 = copy.deepcopy(v1) # 深copy
print(v1 == v2) # True
print(v1 == v3) # True
print(v1 is v2) # False
print(v1 is v3) # False
print(v1[-1] is v2[-1]) # True
print(v1[-1] is v3[-1]) # False
print(v1[-1] == v3[-1]) # true
print(v1[-1]['k1'] is v3[-1]['k1']) # True
2.3tuple的深浅copy -特殊情况(很少用到)。
Case 1：tuple的所有元素里没有可变数据类型。-同str。
# tuple里没有可变数据类型。
# 同str/int/bool：深/浅copy均与原数据共用一个内存空间。
# 原因：因为python小数据池的缘故，tuple为不可变类型，故对其copy不会重新开辟一个新的内存空间。
import copy
v1 = (1, 2, 3, )
v2 = copy.copy(v1)
v3 = copy.deepcopy(v1)
print(v1 is v2) # True
print(v1 is v3) # True
Case 2：tuple的元素里含有可变数据类型。-特殊！！
# tuple的元素里含有可变数据类型。
# 浅copy：同str。-延用原有数据。
# 深copy：copy可变数据 + 元组空壳。不可变数据延用原来的。-特殊！！
import copy
v1 = (1, 2, [11, 22], 3, )
v2 = copy.copy(v1)
v3 = copy.deepcopy(v1)
print(v1 is v2) # True
print(v1 is v3) # False
print(v1[2] is v3[2]) # False
print(v1[2][0] is v3[2][0]) # True
