python 第六章
小数据池
# == 判断两边内容是否相等
a = 10
b = 10
print(a == b)# 判断a是否等于b
# 输出 True
# is 是 基于内存地址进行判断，用id判断
# 相同输出相同内容，否则输出id不同
# pring(id(数据类型))
# 查看内存地址
a = 10
b = 10
print(id(a))
# 输出4401028560
print(id(b))
# 输出4401028560
print(a is b)
# 输出False
# 代码块 -- 一个文件，函数，类，模块，终端的每一行
# 代码块支持范围：
# 数字：
# 同一代码块下，只要内容相同就采用相同的内存地址，-5以后就不是，正无穷
# 在做乘法的时候范围 -5～256 ***
# 在做乘法的时候不能使用浮点系
#
# 字符串：
# 同一代码块下，只要内容相同就采用相同的内存地址
# 乘法的时候总长度不能超过20
# 乘法的时候中文，特殊符号只能乘以1或0
#
# 布尔值：
# 同一代码块下，只要内容相同就采用相同的内存地址
#
#
# 小数据池 -- 缓存机制(驻留机制)
# 小数据池支持的范围
# 数字：
# -5～256 ***
#
#
# 字符串：
# 同一代码块下，只要内容相同就采用相同的内存地址
# 乘法的时候总长度不能超过20 ***
# 乘法的时候中文，特殊符号只能乘以0
#
# 布尔值：
# 同一代码块下，只要内容相同就采用相同的内存地址
#
# 验证方法，必须脱离代码块才能验证
#
# 优先级：
# 代码块 > 小数据池（驻留机制）
# 在终端中操作，不需要print，直接回车返回
#
# 必会：
# == 判断等号两边的值是否相等 ***
# is 判断两边的内容地址是否相等 ***
深浅拷贝
# 赋值 : 数据完全共享
# 浅拷贝 : 数据半共享
# 深拷贝 : 数据完全不共享
# 赋值
l1 = [1,2,3,["aa","bb"]]
l2 = l1
print(l1)
print(l2)
# 输出
# [1, 2, 3, ['aa', 'bb']]
# [1, 2, 3, ['aa', 'bb']]
# 修改元素
l2[0] = "aaa"
l2[3][0] = "bbb"
print(l1)
print(l2)
# 输出
# ['aaa', 2, 3, ['bbb', 'bb']]
# ['aaa', 2, 3, ['bbb', 'bb']]
# 浅拷贝 只拷贝第一层，第二层有变动，列表一起变动
ls1 = [1,2,3,["11","22","33"]]
ls2 = ls1.copy()# 将ls1 的内容拷贝到ls2中
print(ls2)
# 输出[1, 2, 3, ['11', '22', '33']]
# 不可变的是int,srt，tuple
# 可变的是list，set，dic
# 修改不可变类型的值，变化的只有修改的列表生效
# 修改源列表的不可变类型的值，源列表变，新列表不变
ls1 = [1,2,3,["11","22","33"]]
ls2 = ls1.copy()
ls1[0] = 0
print(ls1)
print(ls2)
# 输出 lst1变 lst2不变
# [0, 2, 3, ['11', '22', 'aaa']]
# [1, 2, 3, ['11', '22', 'aaa']]
# 修改新列表的不可变类型的值，新列表变，源列表不变
ls1 = [1,2,3,["11","22","33"]]
ls2 = ls1.copy()
ls2[0] = 0
print(ls1)
print(ls2)
# 输出 lst1不变 lst2变
# [1, 2, 3, ['11', '22', 'aaa']]
# [0, 2, 3, ['11', '22', 'aaa']]
# 修改可变类型的值，源列表和新列表均生效
# 修改源列表可变类型的值，源列表变，新列表变
ls1 = [1,2,3,["11","22","33"]]
ls2 = ls1.copy()
ls1[3][2] = "aaa"# 修改ls2 中第4个元素-列表中的第3个元素
print(ls1)
print(ls2)
# 输出 都变
# [1, 2, 3, ['11', '22', 'aaa']]
# [1, 2, 3, ['11', '22', 'aaa']]
# 修改新列表可类型的值，源列表变，新列表变
ls1 = [1,2,3,["11","22","33"]]
ls2 = ls1.copy()
ls2[3][2] = "bbb"# 修改ls2 中第4个元素-列表中的第3个元素
print(ls1)
print(ls2)
print(id(l1[-1]) == id(l2[-1]))
# 输出 都变
# [1, 2, 3, ['11', '22', 'bbb']]
# [1, 2, 3, ['11', '22', 'bbb']]
ls1 = [1,2,3,[4,5,6]]
ls2 = ls1.copy()
ls1[-1]=10# 将列表看成一组，所以源不变
print(ls1)
print(ls2)
ls1 = [1,2,3,[4,5,6]]
ls2 = ls1.copy()
ls2[-1]=11# 将列表看成一组，所以源不变
print(ls1)
print(ls2)
# id 内存地址的判断
# 浅拷贝：
# 源列表和新列表的内存地址不一样
ls1 = [1,2,3,[11,22,33]]
ls2 = ls1.copy()
print(id(ls1) == id(ls2))
# 输出False
# 源列表和新列表的第一层的内存地址一样
ls1 = [1,2,3,[11,22,33]]
ls2 = ls1.copy()
print(id(ls1[0]) == id(ls2[0]))
# 源列表和新列表的第二层的内存地址一样
ls1 = [1,2,3,[11,22,33]]
ls2 = ls1.copy()
print(id(ls1[3]) == id(ls2[3]))
# 深拷贝 拷贝所有,修改任意一个列表对另一个列表没有影响
import copy # 倒入copy类
import copy
ls1 = [1,2,3,[11,22,33]]
ls2 = copy.deepcopy(ls1)# ls2深拷贝ls1列表
print(ls1)
print(ls2)
# 输出
# [1, 2, 3, [11, 22, 33]]
# [1, 2, 3, [11, 22, 33]]
# 修改不可变类型的值，变化的只有修改的列表生效
# 修改源列表的不可变类型的值，源列表变，新列表不变
import copy
ls1 = [1,2,3,[11,22,33]]
ls2 = copy.deepcopy(ls1)
ls1[1] =11
print(ls1)
print(ls2)
# 输出
# [11, 2, 3, [11, 22, 33]]
# [1, 2, 3, [11, 22, 33]]
# 修改源列表的不可变类型的值，源列表不变，新列表变
import copy
ls1 = [1,2,3,[11,22,33]]
ls2 = copy.deepcopy(ls1)
ls2[1] =11
print(ls1)
print(ls2)
# [1, 2, 3, [11, 22, 33]]
# [1, 11, 3, [11, 22, 33]]
# 修改可变类型的值，变化的只有修改的列表生效
# 修改源列表可变类型的值，源列表变，新列表不变
import copy
ls1 = [1,2,3,[11,22,33]]
ls2 = copy.deepcopy(ls1)
ls1[3][2] = "aaa"# 修改ls2 中第4个元素-列表中的第3个元素
print(ls1)
print(ls2)
# 输出
# [1, 2, 3, [11, 22, 'aaa']]
# [1, 2, 3, [11, 22, 33]]
# 修改可变类型的值，变化的只有修改的列表生效
# 修改新列表可变类型的值，源列表不变，新列表变
import copy
ls1 = [1,2,3,[11,22,33]]
ls2 = copy.deepcopy(ls1)
ls2[3][2] = "aaa"# 修改ls2 中第4个元素-列表中的第3个元素
print(ls1)
print(ls2)
# 输出
# [1, 2, 3, [11, 22, 33]]
# [1, 2, 3, [11, 22, 'aaa']]
# id 内存地址的判断
# 深拷贝：
# 源列表和新列表的内存地址不一样
import copy
ls1 = [1,2,3,[11,22,33]]
ls2 = copy.deepcopy(ls1)
print(id(1) == id(2))
# 输出False
# 源列表和新列表的第一层的内存地址一样
import copy
ls1 = [1,2,3,[11,22,33]]
ls2 = copy.deepcopy(ls1)
print(id(ls1[0]) == id(ls2[0]))
# 源列表和新列表的第二层的内存地址不一样
import copy
ls1 = [1,2,3,[11,22,33]]
ls2 = copy.deepcopy(ls1)
print(id(ls1[3]) == id(ls2[3]))
# 浅拷贝：
# 只拷贝第一层，第二层有变动，列表一起变动
# 修改不可变类型的值，变化的只有修改的列表生效
# 修改可变类型的值，源列表和新列表均生效
# 修改和增删的区别
# 修改：只能改不可变数据类型，新开辟的不进行改变
# 增删改：使用可变数据类型，新开辟的进行改变
#
# 深拷贝：
# 拷贝所有,修改任意一个列表对另一个列表没有影响
#
# id 内存地址的判断
# 浅拷贝：
# 源列表和新列表的内存地址不一样
# 源列表和新列表的元素内存地址一样
#
#
# 深拷贝：
# 源列表和新列表的内存地址不一样
# 源列表和新列表的第一层的内存地址一样
# 源列表和新列表的第二层的内存地址不一样
ls1 = [1,2,3,[4,5,6]]
ls2 = ls1.copy()
ls2[-1][-1] = 8
print(ls1)
print(ls2)
ls1 = [1,2,3,[4,5,6]]
ls2 = ls1.copy()
ls1[-1].append(10)
print(ls1)
print(ls2)
ls1 = [1,2,3,[4,5,6]]
ls2 = ls1.copy()
ls1[-1]=10# 将列表看成一组，所以源不变
print(ls1)
print(ls2)
ls1 = [1,2,3,[4,5,6]]
ls2 = ls1.copy()
ls2[-1]=11# 将列表看成一组，所以源不变
print(ls1)
print(ls2)
集合
# 集合 -- set
# 没有值的字典，只有键，无序，不支持索引
# 天然去重 ***
#
# 定义集合
s = {1,"alex",False,(1,2,3),12,1,12}
print(s)
# 输出{1,"alex",False,(1,2,3),12,1,12}
lst = [1,2,1,2,4,2,45,3,2,45,2345,]
print(list(set(lst)))# set先去重，set无序，去重后转换成list列表
# 输出[1, 2, 3, 4, 2345, 45]
# 增：add update
# s.add("键") 只能添加一个
s.add("键")
print(s)
# 输出{False, 1, 'alex', 12, '键', (1, 2, 3)}
# s.update("键")迭代增加
s.update("abc")
print(s)
# 输出{False, 1, 'b', 'c', 'alex', 12, (1, 2, 3), 'a'}
# 删:pop remove clear
# s.pop()随机删 有返回值
s.pop()
print(s)
# 输出{1, 12, (1, 2, 3), 'alex'}
# s.remove("键")指定元素删
s.remove(1)
print(s)
# 输出 {False, 'alex', 12, (1, 2, 3)}
# s.clear()清空 --set() 空集合
s.clear()
print(s)
# 输出 ()
# 改：
# 先删再加
# 查：
# for i in s:
# print(i)
# 其他操作：
s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,1}
# 取交集
# s1&s2
print(s1 & s2) # 交集
# 取并集 去重合并
# s1|s2
print(s1 | s2) # 并集
# 取差集
# s1-s2
print(s1 - s2) # 差集
# 反交集 对称差集
# s1^s2
print(s1 ^ s2) # 差集
# 父集
# s1 > s2
print(s1 > s2) # 父集(超集)
# 子集
# s1 < s2
print(s1 < s2) # 子集
#冻结集合
frozenset(s1)
# 用作与字典的键
dic={frozenset(s1):1}
print(dic)
今日总结
小数据池
代码块：
一个文件、函数、类、模块，终端每一行代码
数字：-5～256
字符串：乘法总长不超过20
布尔值：内容相同内存地址相同
小数据池：
数字：-5～256
字符串：乘法总长不超过20
布尔值：内容相同内存地址相同
优先级：
先执行代码块，再执行小数据池
== 判断两边值是否相等
is 判断两边的内容地址是否相等
深浅拷贝
赋值：
多个变量名指向同一个内存地址
一个变量对其操作，其他变量查看时都变动
浅拷贝：
浅拷贝 -- lst[1:10]
只拷贝第一层元素
修改第一层元素时新开辟的不进行改变
深拷贝：
不可变的数据类型共用，可变的数据类型重新开辟一个空间
对源数据进行修改，深拷贝的内容不进行改变
集合
没用值的字典
无序，可变的
天然去重
增：add,update
删：pop,remove,clear
改：先删再加
其他操作
& | - ^ > <
交集 并集 差集 反差集 父集 子集