1. 小数据池
小数据池——缓存机制(驻留机制)
数字的范围为：-5~256（在此范围内的数字，内存地址相同）
1.1 代码块
一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块。
支持的数据类型：
-
数字类型：
在同一代码块下 只要内容相同就采用相同的内存地址(-5 ~ 正无穷大)；
数字在做乘法的时候范围 -5 ~ 256；
数字在做乘法的时候不能使用浮点数，否则地址不同。
- 字符串类型：
在同一代码块下 只要内容相同就采用相同的内存地址；
乘法的时候总长度不能超过20，内存地址相同；
乘法的时候中文,特殊符号乘以1或0，内存地址相同。
- 布尔值：
在同一代码块下 只要内容相同就采用相同的内存地址。
1.2 小数据池
支持的数据类型：
-
数字类型：
数字范围 -5 ~ 256；
-
字符串类型：
纯字母、数字任意长度，只要内容相同就采用相同的内存地址；
只有乘法的时候总长度不能超过20，内存地址相同；
乘法的时候中文,特殊符号乘以0，内存地址相同。
- 布尔值：
只要内容相同就采用相同的内存地址。
1.3 执行顺序 （代码块--小数据池）
小数据池的验证方法，必须脱离代码块才能进行验证。否则会先执行代码块的规则，再执行小数据池的验证规则。
1.4 "=="和 “is”
"== 判断等号两边值是否相等
"is" 判断两边的值内存地址是否相等
2. 深浅拷贝
2.1 赋值
多个变量名指向同一个内存地址
一个变量对其进行操作,其他变量查看时都变动
lst = [1,2,3,[4,5,6]]
lst1 = lst
print(lst1)
print(lst)
lst[-1].append(8)
print(lst1) # lst、lst1都改变
print(lst)
2.2 浅拷贝： copy()
2.2.1 本质
浅拷贝的时候,只会开辟一个新的容器列表(内存空间),使用的都是源列表中的元素。
lst1 = lst.copy()
print(lst[-1]) # [4,5,6]
print(lst1[-1]) # [4,5,6]
print(id(lst[-1])) # id 内存地址也一样
print(id(lst1[-1]))
2.2.2 特征
lst[ : ] -- 也是浅拷贝；
浅拷贝只拷贝第一层元素；
修改第一层元素时,新开辟了内存空间，则不会进行改变；修改第二层及以上元素时，会改变。
lst = [1,2,3,[4,5,6]]
lst1 = lst.copy() #浅拷贝
lst[0]=10
print(lst) # 会变[10, 2, 3, [4, 5, 6]]
print(lst1) # 不会变[1, 2, 3, [4, 5, 6]]
# 总结：当改变第一层元素（不可变数据类型）时，拷贝出来的新列表不会改变
lst = [1,2,3,[4,5,6]]
lst1 = lst.copy()
lst[-1]=4
print(lst) # 会变 [1, 2, 3, 4]
print(lst1) # 不会变[1, 2, 3, [4, 5, 6]]
# 总结：当改变第一层元素（可变数据类型）时，拷贝出来的新列表不会改变
lst = [1,2,3,[4,5,6]]
lst1 = lst.copy()
lst[-1][-1]=10
print(lst) # 会变[1, 2, 3, [4, 5, 10]]
print(lst1) # 会变[1, 2, 3, [4, 5, 10]]
#总结：当修改（增删改）第一层元素中可变数据类型（第二层元素）时，拷贝出来的新列表会改变，两个列表相同
dic = {"alex":[1,2,3,[4,5,6]]}
dic1 = dic.copy()
dic["alex"].append (0)
print(dic) #{'alex': [1, 2, 3, [4, 5, 6], 0]}
print(dic1) #{'alex': [1, 2, 3, [4, 5, 6], 0]}
#总结：字典存在的值就是第二层元素
dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()
dic["wusir"]=[7,8] #增加新的键值对
# dic["alex"]=[7,8] #替换键值对的整体值
print(dic) # {'alex': [1, 2, 3, [5, 6]], 'wusir': [7, 8]}
print(dic1) # {'alex': [1, 2, 3, [5, 6]]}
#总结：如果是新增/减键值对或者是替换键值对的整体值，那就是在改第一层元素，不会改变
2.3 深拷贝：copy.deepcopy（）
2.3.1 格式
import copy #导入
lst = [1,2,3,[4,5,6]]
lst1 = copy.deepcopy(lst) # 深拷贝
print(lst)
print(lst1)
2.3.2 特征
不可变的数据类型共用,可变的数据类型重新开辟一个空间对源数据进行修改; 深拷贝的内容都不会改变。
import copy
lst = [1,2,3,[4,5,6]]
lst1 = copy.deepcopy(lst)
lst[-1][-1] = 10
print(lst) #会变[1, 2, 3, [4, 5, 10]]
print(lst1) #不变[1, 2, 3, [4, 5, 6]]
import copy
lst = [1,2,3,[4,5,6]]
lst1 = copy.deepcopy(lst)
lst[-1].append(7)
print(lst) #会变[1, 2, 3, [4, 5, 6, 7]]
print(lst1) #不变[1, 2, 3, [4, 5, 6]]
#总结：深拷贝对第二层元素改变时，拷贝出来的新列表不会改变
import copy
lst = [1,2,3,[4,5,6]]
lst1 = copy.deepcopy(lst)
lst[-1] = 10
print(lst) #会变[1, 2, 3, 10]
print(lst1) #不变[1, 2, 3, [4, 5, 6]]
#总结：深拷贝对第一层元素改变时，拷贝出来的新列表也不会改变
3.集合——set
集合是没用值得字典 { }，集合是无序,可变的，集合可以天然去重（唯一），元素时不可变的数据类型。
3.1 定义
s = {1,"alex",False,(1,2,3),12,4,6,32,2}
3.2 操作
3.2.1增
s.add(67) #只能添加一个
s.update("迭代的内容") # 迭代添加
3.2.2 删
s.pop() #随机删
s.remove(1) #指定元素删除
s.clear() # 清空 -- set() 空集合
3.2.3 改
先删再加
3.2.4 查
for i in {1,2,3}:
print(i)
3.2.5 其他操作
s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,1}
print(s1 & s2) # 交集 {1, 5, 6, 7}
print(s1 | s2) # 并集 {1, 2, 3, 4, 5, 6, 7}
print(s1 - s2) # 差集 {2, 3, 4} 差集是减去相同的元素，打印s1中其他剩下的元素
print(s1 ^ s2) # 反交集 {2, 3, 4} 去两个集合的重
print(s1 > s2) # 父集(超集) True
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}
3.3 集合面试题
1. 用一行代码将列表去重：
lst = [1,2,1,2,4,2,45,3,2,45,2345,]
print(list(set(lst))) # [1, 2, 3, 4, 2345, 45]