小数据池，不同代码块的缓存机制，也称为小整数缓存机制，或者称为驻留机制等等，博主认为，只要你在网上查到的这些名字其实说的都是一个意思，叫什么因人而异。
那么到底什么是小数据池？他有什么作用呢？
前提条件：在不同一个代码块内。
机制内容：官方对于整数，字符串的小数据池是这么说的:
1小数据池 --缓存机制（驻留机制）
'==' 判断两边内容是否相等
'is' 基于内存地址进行判断是否相同
a = 10
b = 10
print(a == b )
#is
print(a is b)
小数据池的数字范围： -5 ~256
a = -5
b = -5
c = -5
print(id(a))
print(id(b))
print(id(c))
#<-5不行
a = -6
b = -6
print(id(a))
print(id(b))
a = 256
b = 256
print(id(a))
print(id(b))
#>256可以，但是不是小数据池，是python的代码块
a = 257
b = 257
print(id(a))
print(id(b))
1.代码块：python自有的属性
1.代码块范围：（3.7以下版本）
支持：一个文件，一个函数，一个类，一个模块，终端的每一行是一个代码块
2.数字：
在同一代码块下，只要内容相同，就采用相同的内存地址，(-5以后就不是)，
*数字在做乘法的时候范围-5 ~ 256
数字在做乘法的时候不能用浮点数
a = -2.5 * 1
b = -2.5 * 1
print(id(a))
print(id(b))
3.字符串：
在同一代码块下，只要内容相同，就采用相同的内存地址
*做乘法的时候总长度不能超过20(python4.7版本到4096)
乘法的时候中文，特殊符号乘以1或0
a = "alex你好" *2
b = "alex你好" *2
print(id(a))
print(id(b))
4.布尔值：
在同一代码块下，只要内容相同，就采用相同的内存地址
2.小数据池：
1.数字：
范围*-5 ~256
2.字符串：
在同一代码块下，只要内容相同，就采用相同的内存地址
做乘法的时候总长度不能超过20
乘法的时候中文，特殊符号乘以0
3.bool:
在同一代码块下，只要内容相同，就采用相同的内存地址
必会*：
小数据池的验证方法：必须脱离代码块才能验证(在Windows cmd下验证)
python规则：先执行代码块的规则，在执行小数据池的规则 --(驻留机制)
2.深浅拷贝，赋值
面试必问：赋值，浅拷贝，深拷贝
1.浅拷贝 -- 拷贝第一层元素内存地址,修改第一层元素的时候新拷贝的列表不进行改变
2.深拷贝 -- 不可变的数据类型共用,可变数据类型开辟一个新的空间,新的空间中的元素如果是不可变类型也是共用
3.赋值 -- 多个变量名指向同一个内存地址
import copy
v1 = "alex"
v2 = copy.copy(v1)
v3 = copy.deepcopy(v1)
print(v1 is v2)#结果：True
print(v1 is v3)#结果：True
v1 = [1,2,3]
v2 = copy.copy(v1)
v3 = copy.deepcopy(v1)
print(v1 is v2)#结果：False
print(v1 is v3)#结果：False
1.赋值：
多个变量名指向同一个内存地址
#1.赋值
lst = [1,2,3,[5,6,7]]
lst1= list2
print(lst)
print(lst1)
#赋值后，一个操作，两个全变，内存地址相同
lst1[-1].append(8)
print(lst)
print(lst1)
print(id(lst),id(lst1))
2.浅拷贝
*浅拷贝的时候,只会开辟一个新的容器列表,其他元素使用的都是源列表中的元素
lst = [1,2,3,[6,5,7]]
lst1 = lst.copy()#新开辟一个空间给lst1
print(lst)
print(lst1)
print(id(lst),id(lst1))#结果：46646536 46647136
#操作1.修改第二层数据，原列表也变
lst1[-1].append(8)
print(lst1)#结果：[1, 2, 3, [6, 5, 7, 8]]
print(lst)#结果：[1, 2, 3, [6, 5, 7, 8]]
#操作2.修改第一层数据，原列表不变
lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()
lst1[3] = 567
print(lst1)#结果：[1, 2, 3, 567]
print(lst)#结果：[1, 2, 3, [6, 5, 7]]
#操作3.修改第三层数据，原列表也变
lst = [1,2,3,4,[5,6,7,[8,9]]]
lst1 = lst.copy()
lst1[-1][-1] = "56"
print(lst)#结果：[1, 2, 3, 4, [5, 6, 7, '56']]
print(lst1) #结果：[1, 2, 3, 4, [5, 6, 7, '56']]
#操作4.注意，字典的值整个就算为第一层数据，里面的任意都不只是第一层数据
dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()
dic["alex"] = "56"
print(dic)#结果：{'alex': '56'}
print(dic1)#结果：{'alex': [1, 2, 3, [5, 6]]}
dic["alex"][0] = "56"
print(dic)#结果：{'alex': ['56', 2, 3, [5, 6]]}
print(dic1)#结果：{'alex': ['56', 2, 3, [5, 6]]}
浅拷贝总结：
浅拷贝只拷贝第一层元素的内存地址
浅拷贝在修改第一层数据时，原数据不变
浅拷贝在修改非第一层数据时，同时发生改变
3.深拷贝
深拷贝总结：
无论怎样改变新拷贝的数据，原数据都不会改变。
开辟一个容器空间，不可变数据类型(第一层元素)共用同一内存地址，共用值，可变数据类型(非第一层)在开辟一个新空间(新的内存地址)，但是里面的值是共用的
import copy
lst = [1,2,3[6,5,7]]
lst1 = copy.deepcopy(lst)
lst1[-1].append(8)
print(lst)
print(lst1)
#修改非第一层数据，原数据不变
lst1[0] = 88
print(lst)
print(lst1)
#修改第一层数据，原数据不变
print(id(lst[0]))#结果：494255688
print(id(lst1[0]))#结果：494255688
#第一层是同一内存地址
print(id(lst[-1]))#结果：43102336
print(id(lst1[-1]))#结果：43321264
#非第一层是不同的内存地址，但是非第一层内层的值内存地址相同。
print(id(lst[-1][0]))#结果：503627400
print(id(lst[-1][0]))#结果：503627400
4.集合 -- set
1.简介：
没有值的字典，无序 - - 不支持索引，
*天然去重
定义:
s = {1,"alex",False,(1,2,3),12,15,1,1,2,12}#列表不可以作为元素
#面试题：
list1 = [1,2,1,21,21,2,1,212,1,1]
print(list(set(list1)))
2.方法
1.增：
s.add('66'):一次添加一个元素
s.update("今天")：迭代添加
s = {1,2,3,4}
s.add("67") #只能添加一个
print(s)
s.update("今天")#迭代添加
print(s)
2.删：
s.pop():随机删除
s.remove(3):指定元素删除
s.clear():清空
s = {1,2,3,4}
s.pop()#有返回值，随机删除
print(s)
print(s.pop)
s.remove(3)#指定元素删除
print(s)
s.clear()
print(s)#集合 set()
3.改：
先删再增
4.查：
for 循环
s = {1,2,3,4}
for i in s:
print(i)
菜中菜：各种集合
s1 = {1,2,3,4,5,6,6,7}
s2 = {5,6,7,1,9}
print(s1 & s2) #交集。结果：{1, 5, 6, 7}
print(s1 | s2) #并集，可去重。结果：{1, 2, 3, 4, 5, 6, 7，9}
print(s1 - s2) #差集。结果：{2, 3, 4}
print(s1 ^ s2) #反交集。结果：{2, 3, 4, 9}
print(s1 > s2) #父集(超集)。结果：False
print(s1 < s2) #字迹。结果：False
#冻结集合,很不常用，也没什么用，使此集合不可更改
print(frozenset(s1))#结果：frozenset({1, 2, 3, 4, 5, 6, 7})
dic = {frozenset(s1):1}
print(dic)#结果：{frozenset({1, 2, 3, 4, 5, 6, 7}): 1}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
