Python中的代码块及其缓存机制、深浅copy

一、代码块及其缓存机制

代码块

一个模块、一个函数、一个类、一个文件等都是一个代码块；交互式命令下，一行就是一个代码块。

同一个代码块内的缓存机制（字符串驻留机制）

机制内容：Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用，即将两个变量指向同一个对象。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两个变量指向同一个对象，满足缓存机制则他们在内存中只存在一个，即：id相同。

适用对象： int（float），str，bool。

对象的具体细则：（了解）

• int(float)：任何数字在同一代码块下都会复用。

• bool：True和False在字典中会以1，0方式存在，并且复用。

• str：几乎所有的字符串都会符合字符串驻留机制

不同代码块间的缓存机制（小数据池、小整数缓存机制、小整数驻留机制）

适用对象： int（float），str，bool

具体细则：-5~256数字，bool，满足一定规则的字符串。

优点：提升性能，节省内存。

Python自动将-5~256的整数进行了缓存，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。

python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象， 而是使用在字符串驻留池中创建好的对象。

其实，无论是缓存还是字符串驻留池，都是python做的一个优化，就是将~5-256的整数，和一定规则的字符串，放在一个‘池’（容器，或者字典）中，无论程序中那些变量指向这些范围内的整数或者字符串，那么他直接在这个‘池’中引用，言外之意，就是内存中之创建一个。

#同一个代码块内的缓存机制————任何数字在同一代码块下都会复用i1 = 1000i2 = 1000print(id(i1))print(id(i2))​输出结果：3210011232100112

#同一个代码块内的缓存机制————几乎所有的字符串都会符合缓存机制s1 = 'hfdjka6757fdslslgaj@!#fkdjlsafjdskl;fjds中国's2 = 'hfdjka6757fdslslgaj@!#fkdjlsafjdskl;fjds中国'print(id(s1))print(id(s2))​输出结果：3161667231616672

#同一个代码块内的缓存机制————非数字、str、bool类型数据，指向的内存地址一定不同t1 = (1,2,3)t2 = (1,2,3)l1 = [1,2,3]l2 = [1,2,3]print(id(t1))print(id(t2))print(id(l1))print(id(l2))​输出结果：32191328321914723221069632232712

二、深浅copy

赋值运算讨论

令y=x，然后对x重新赋值时：

• 若x, y为不可变数据类型（可哈西的数据类型）（int, str, bool, tuple），则y不会跟着x的变化而变化

• 若x, y为可变数据类型（不可哈西的数据类型）（list, dict, set），则y会跟着x的变化而变化

#int的例子
x=1
y=x
x=x+1
print(x)
print(y)

输出结果：
2
1

#str的例子
x='abc'
y=x
x=x+'d'
print(x)
print(y)

输出结果：
abcd
abc

#bool的例子
x=True
y=x
x=False
print(x)
print(y)

输出结果：
False
True

#tuple的例子
x=(1,2)
y=x
x=(3,4)
print(x)
print(y)

输出结果：
(3, 4)
(1, 2)

#list的例子
x=[1,2]
y=x
x.append(3)
print(x)
print(y)

输出结果：
[1, 2, 3]
[1, 2, 3]

#dict的例子
x={1:2,3:4}
y=x
x[5]=6
print(x)
print(y)

输出结果：
{1: 2, 3: 4, 5: 6}
{1: 2, 3: 4, 5: 6}

#set的例子
x={1,2}
y=x
x.add(3)
print(x)
print(y)

输出结果：
{1, 2, 3}
{1, 2, 3}

不可变数据类型（可哈西的数据类型）（int, str, bool, tuple)原理图：

可变数据类型（不可哈西的数据类型）（list, dict, set)原理图：

浅copy

拷贝目标可变对象（list, dict, set）时，仅为第一层可变对象分配新的内存地址，第二层及以上的可变对象沿用之前对象的内存地址，此外所有层的不可变对象（int, str, bool, tuple）均沿用之前对象的内存地址。

#更改第一层的例子
l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1.append(666)
print(l1,id(l1))
print(l2,id(l2))
print(l1[0],id(l1[0]))
print(l2[0],id(l2[0]))
print(l1[3],id(l1[3]))
print(l2[3],id(l2[3]))

输出结果：
[1, 2, 3, [22, 33], 666] 43242760
[1, 2, 3, [22, 33]] 43243208
1 1414365296
1 1414365296
[22, 33] 43220744
[22, 33] 43220744

#更改第二层的例子
l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1[-1].append(666)
print(l1, id(l1))
print(l2, id(l2))
print(l1[0],id(l1[0]))
print(l1[0],id(l2[0]))
print(l1[-1],id(l1[-1]))
print(l1[-1],id(l2[-1]))

输出结果：
[1, 2, 3, [22, 33, 666]] 43046152
[1, 2, 3, [22, 33, 666]] 43046600
1 1414365296
1 1414365296
[22, 33, 666] 43024136
[22, 33, 666] 43024136

浅copy的另一种表示方式（此种方式必须在前面写import copy搭建模块，否则报错！）

import copy
x=[1,2,3]
y=copy.copy(x)

深copy

拷贝目标可变对象（list, dict, set）时，为所有层的可变对象分配新的内存地址，此外所有层的不可变对象（int, str, bool, tuple）均沿用之前对象的内存地址。

必须在前面写import copy搭建模块，否则报错！

import copy
l1 = [1, 2, 3, [22, 33]]
l2 = copy.deepcopy(l1)
print(l1,id(l1))
print(l2,id(l2))
print(l1[0],id(l1[0]))
print(l1[0],id(l2[0]))
print(l1[-1],id(l1[-1]))
print(l1[-1],id(l2[-1]))

输出结果：
[1, 2, 3, [22, 33]] 43650504
[1, 2, 3, [22, 33]] 43754248
1 1414365296
1 1414365296
[22, 33] 43650312
[22, 33] 43754184