#用Ctrl+F查阅关键字
常用单词
help 帮助
function 函数
Built-in 或者 builtins 内置
Module 模块
value 值
stream 流
Default 默认值
Format 格式化
digit 数字
Rquired 必须
Raise 抛出，扔出
Operator 运算符
identity 特征
####注释的用法
'''
print（'''
Days are:{}
Hours are:{}
Minutes are:{}
Seconds are: {}
'''.formart(Days,Hours,Minutes,Seconds)） #用于直接打印多个换行的方法
'''
#help() #为什么函数
#例子
a = "xioAmu Adied" #双引号下默认是字符串不是变量
b = "XICKDD xkddklA" #字符串转换例子
c = 12354
d = 5565.555
e,f,g,h,i = 1,2,3,4,5 #可以一次性定义多个字符串
j = 0
k = 1
l = 0.0
m = 0.1
n = '' #空字符串
o = 'None' #字符串
p = None # 就是None，不属于任何数据类型，布尔值返回False
q = ' ' #空格不是空字符串
r = 's'
'''
print(id(c)) #这个字符串的内存里的id
print(int(c)) #整数类型
print(str(c)) #字符串类型
print(float(c)) #浮点类型
'''
#########字符串内置函数###################
'''
print(type(a)) #查询这个a的类型
print(min(a)) #字符串最小字符，同下
print(max(a)) #字符串最大字符，中文符号>字母>数字>英文符号，中文按照拼音首字母来计算
print(len(a)) #字符串长度
print(a.capitalize()) #首 字母大写
print(b.casefold()) #全小写
print(a.upper()) #全大写
print(b.lower()) #英文全小写（德语就不会变小写了）
print(a.swapcase()) #大小写反转
print(a.zfill(20)) #前面填充（0的数量）
print(a.title()) #把所有英文词组首字母大写
print(a.count('i')) #统计字符串中‘i’的数量
#find,index #查找‘i’第一次出现的索引位置
'''
#find,index 的例子
'''
j = a.find('o') #变量.find(找的单个字符) #找到的话返回字符串的位置(从0开始数的），找不到返回-1
print(j)
h = a.index('oA') #格式：变量.index(找的字符串)，找到的话返回字符串的位置（从0开始数），找不到直接报错
print(h)
'''
#刷二周目视频
'''
rindex() rfind() 反向查找
'''
#strip,lstrip,rstrip
'''
j = a.strip() #去掉左右两边的空格
h = a.strip('x') #去掉左右两边带有'x'的字符串
print(h) #lstrip和rstrip只是分别去掉左边和 右边的（）内的字符串或空格
'''
#replace #格式：变量.replace(old,new,max) old代表被替代的元素，new代表替代old的新元素，max代表替代几个,默认是全部匹配的old元素被替代
'''
j = a.replace('oA','BB') #常用这个命令常用来去掉敏感字
print(j)
'''
#split #(重点)按某字符将字符串分割成列表
#join #(重点)按某字符将列表拼接成字符串（Iterable容器类型都可）
#splitlines #按换行符来进行切分（\n）
#partition #将字符串用元祖分割成3等分
'''
a = 'dstsdtrfrewf'
c = a.partition('dtr')
print(c) ##('dsts', 'dtr', 'frewf')
'''
#zfill #填充字符串（默认填充0，原字符串右对齐）
#ljust #填充字符串，原字符居左（默认填充空格）
#rjust #填充字符串，原字符居右（默认填充空格）
#center() #填充字符串，原字符居中（默认填充空格） center(这里写给予的字符串长度)
#repr #不转义字符,原型化输出
#例子
'''
A = {"正兜拳":"升龙破", "反兜脚":"旋风腿", "正兜反兜脚":"大招", "反兜正兜拳":"空中大招"}
print(repr(A),type(repr(A))) # <class 'str'>
'''
#转义字符
'''
\n 换行，一般用于尾部，strip对其也有效果
\t 横向制表符（可以认为是一个间隔符）
\v 纵向制表符（会有一个男性符号）
\a 响铃
\b 退格符，将光标前移，覆盖（删除前一个）
\r 回车 #也能把后面的字符串直接拉到当前行行首
\f 翻页（几乎用不到，会出现一个女性符号）
\' 转义字符串的单引号
\" 转义字符串中的双引号
\\ 转义斜杠
'''
#例子
'''
info = ("我要大大里\n你要大大里")
print(info)
info2 = ("我要大大里\t你要大大里")
print(info2)
info3 = ("我要大大里\v你要大大里") #这个会在不同的解析器得到不同的位置
print(info3)
'''
###转义无效符### 在字符串的起那么加个r就能无效化这个字符串里面的转义字符
#例子
'''
print(r"我要大大里\n你要大大里")
'''
#补记
#字符串前面有 f r b
## f'{变量}{变量}' 这里的f是字符串拼接的意思
## r'字符串\n\t' 这里的r是反转义的意思
## b'\xe4\xbd\xa0\xe5\xa5\xbd' 这里的b是二进制字节流的意思
#####################格式化#########################
'''
%% 输出百分号
%s 格式化字符串，通用类型 重
%d 格式化整形 重
%f 格式化浮点型 重
%.2f 格式化浮点，保留2位小数 重
%u 格式化无符号整型
%c 格式化字符
%o 格式化无符号八进制数
%x 格式化无序号16进制数
%e 科学计数法格式化浮点数
变量.format()
'''
#例子,这个例子是一个转16进制格式的例子，所以int才能包含ab，具体原理不详.
'''
number = int('123ab',16)
print(number)
print('%x' % number)
'''
#有多种格式化方法
'''
cat = 3
dog = 4
print('家里的都是动物园来的有阿猫 %s 只'% cat)
print('家里的都是动物园来的\n有阿猫 %s 只\n有阿狗 %d 只' % (cat,dog)) #当有多个变量的时候用括号
c = ("家里的都是动物园来的,有阿猫 {0} 只有阿狗 {1} 只".format(cat,dog))
print(c)
print('家里的都是动物园来的,有阿狗 {} 只'.format(dog))
print(f"家里的都是动物园来的,有阿猫 {cat} 只") #前面加f和花括号输入变量
# %2d 代表占2位，用于对齐。同理 %-2d 也是，空格在右边，只是调整位置而已 例子：print('家里的都是动物园来的有阿猫 %-2s 只'% cat)
Zoo = ["阿猫","阿狗","公鸡","阿猫","阿猫","猪","阿狗","阿狗","阿狗","公鸡","公鸡","公鸡","猪","阿狗","阿狗"]
print('我们家里有猫咪 %s 只' % Zoo.count('阿猫')) #这个count()括号里面可以是列表等类型
print("%s的妈妈买了阿猫%-2d，也买了阿狗%d,一共花了%.2f元"%('隔壁老王',35,23,14232.523))
'''
#format
#(1)顺序传参
'''
strvar = '{}'.format('你好') ##你好
'''
#(2)索引传参
'''
strvar = '{1}向{0}开了一枪，淫荡而亡'.format('阿猫','阿狗') ##阿狗向阿猫开了一枪，淫荡而亡
'''
#(3)关键字传参
'''
strvar = '{who2}向{who1}开了一枪，淫荡而亡'.format(who1='阿猫',who2='阿狗') ##阿狗向阿猫开了一枪，淫荡而亡
'''
#(4)容器类数据（列表或元祖）传参 ，下面的例子二字符串里面的group1和group2的中括号内不需要引号
'''
strvar = '{0[1]}向{0[0]}开了一枪，淫荡而亡'format.(['阿狗','阿猫']) ##阿狗向阿猫开了一枪，淫荡而亡
strvar = '{group1[貌美如花]}向{group2[丑八怪]}开了一枪，淫荡而亡'.format(group1={'貌美如花':'阿狗'},group2={'丑八怪':'阿猫'}) #阿狗向阿猫开了一枪，淫荡而亡
'''
#format填充符使用
# ^ 原字符居中
# > 原字符居右
# < 原字符居左
# 格式{who:*^3}
# *填充符号
# ^填充方向
# 3填充个数
'''
strvar = '{who:*^5}在{where:}看电视'.format(who='阿猫',where='家') ##*阿猫**在家看电视 #{who:*^5}中的*不写默认空格
'''
#进行转换等特殊符号的使用（:d :f :s :,）
#:d 整型占位符,强制要求类型为整型
'''
strvar = '阿猫买了{:d}个烧鸡'.format(5) ##阿猫买了5个烧鸡
strvar = '阿猫买了{:2d}个烧鸡'.format(5) ##阿猫买了 5个烧鸡
strvar = '阿猫买了{:^3d}个烧鸡'.format(5) ##阿猫买了 5 个烧鸡
strvar = '阿猫买了{:*^3d}个烧鸡'.format(5) ##阿猫买了*5*个烧鸡
'''
# :f 浮点型 占位符
'''
strvar = 'π大概是{:f}'.format(3.1415) ##π大概是3.141500 #保留小数后六位哦
'''
#如果要保留小数点后2位
'''
strvar = 'π大概是{:.2f}'.format(3.1415) ##π大概是3.14
'''
# :s 字符串占位
# :, 金钱占位符
'''
strvar = '{:,}'.format(123456789) ##123,456,789
'''
#字符串拼接
'''
myfriend1 = '阿猫'
myfriend2 = '阿狗'
allmyfriend = f'{myfriend1}'+'和'+f'{myfriend2}'+'都是我的好朋友' ##阿猫和阿狗都是我的好朋友
'''
#########二周目补记######
'''
bin() 二进制转换 前缀 0b
oct() 八进制 前缀 0o
hex() 16进制 前缀 0x
'''
############布尔值###########
#例子
'''
a = 'abcd123456890909'
b = 'abc'
c = '我要大大力'
d = '大力'
c = bool(c) #返回true和Flase
new_a = a.startswith('xi') #找到开头为()的字符串，返回true和Flase
print(new_a)
new_b = b.endswith('lA') #找到结尾为（）的字符串，返回true和Flase
print(new_b)
e = bool(a in b)
f = bool(b in a) # 格式： bool（'找什么' in '在什么变量里面找'）返回True和Flase
print('e是',e)
print('f是',f)
'''
#isspace 判断是否是' '空格，返回 True和False 空格组成的字符串，不是空字符串
'''
print(' '.isspace())
print('hello xioAmu'.isspace()) #包含' '也是返回False
'''
#istitle 判断字符串是否是一个标题类型（意思就是判断所有的因为的单词的首字母是否是大写，仅仅应用在英语）
'''
print(a.istitle())
'''
#isupper,islower 分别判断是否是全大写和全小写,仅仅应用在英语
'''
print(a.isupper())
print(a.islower())
'''
#isalnum #判断字符串是否是由数字，字母，汉字组成
#isalpha #判断字符串是否由字母和文字组成
#isdigit #检查字符串是否数字组成 接受二进制字节流
#isdecimal #检查字符串是否以数字组成 必须纯数字
#isnumeric #检查字符串是否以数字组成
#判断是否包含名为 什么鬼（key）的 字典
'''
Zoo = ["阿猫","阿狗","公鸡","阿猫","阿猫","猪","阿狗","阿狗","阿狗","公鸡","公鸡","公鸡","猪","阿狗","阿狗"]
print('正兜拳' in Zoo ) #不需要bool ##False
'''
#关系运算符
is
'''
age = 20
age1 = 20
print(age is age1) ##True #比较两个变量的ID是否一样
'''
#赋值运算符
'''
= 等于运算符 c = a + b
+= 加法运算符 c += a 意思就是 c = c + a
-= 减法运算符 c -= a 意思就是 c = c - a
*= 乘法运算符 c *= a 意思就是 c = c * a
/= 除法运算符 c /= a 意思就是 c = c / a
%= 取模运算符 c %= a 意思就是 c = c % a #求两个数相除的余数
**= 幕运算符 c **= a 意思就是 c = c** a #求次方
//= 整除运算符 c //= a 意思就是 c = c// a #去掉余数
a,c = 3,2
c **= a
print(c)
'''
#比较运算符
'''
== 判断是否等于 a == b
!= (<>)判断是否不等于 a != b 或 a <> b
> 判断是否大于 a > b
< 判断是否小于 a < b
>= 判断是否大于等于 a >= b
<= 判断是否小于等于 a <= b
is 判断两个对象存储单元是否相同 a is b
in not 判断两个对象存储单元是否不同 a is not b
print(c != a) #返回布尔值
'''
#逻辑运算符 and or not （与 或 非）
'''
a = 1
b = 3
print(b and d) ##and两边是非0数字，结果是最后的数字值
c = 3
print(c and a) ##and两边只有一边为0，结果即为0 在
'''
#运算符的优先级别
'''
** 大于 *,/,//,% 大于 +,- 大于<<,>> 大于 & 大于 | 大于 >,<,>=,<=,==,!= 大于 and 大于 or 大于 =
'''
####一般的应用场景在 登录账号密码的时候
#账号密码 or 手机和验证码 账号名/手机号码 + 密码
'''
a = 'admin' #账号
b = 'abc123123' #密码
c = '13711111111' #'手机号码'
f = 1
while True:
d = input('请输入账号\手机号：')
e = input('密码:')
if bool(d == a or d==c) and bool(b == e) == True:
print('账号密码正确')
break
else:
print('错了')
'''
#字符串，元组，列表 元素的位置是从0开始计算的
#例子
new_A_list = ['1g','2d','3s','4e','5g','6f','7d','8x','9f','0f']
new_B_dict = {'1f123':'啊', '223d4':'哦', '42s323':'额', '42s22':'依', '34f22':'乌', '4t233':'鱼'} #字典的值是可以重复，但键是必须唯一。
new_c_tuple = ("di",),("1", "2", "3", "4") #元组当只有1个的时候要加逗号
'''
g = bool("1g" in new_A_list)
print(g)
h = bool("1f123" in new_B_dict) #能找到键 别外还能用 not in 命令
i = bool('啊' in new_B_dict) #不能找到值（value）
print(h)
print(i)
print(new_c_tuple)
'''
##################列表 list [] 字典dict {键:值} 集合set() {} 元组tuple (变量,) ######################
#字符串，元组，列表 元素的位置是从0开始计算的
#切片 语法 列表[::] 完整格式:[开始索引:结束索引:间隔值] #开始和结束是顾头不顾尾
#增 + 或者 extend 格式： 列表.extend(iterable)
#列表内置函数 append 添加到列表结尾，用法同上
'''
A = [{"正兜拳":"升龙破", "反兜脚":"旋风腿", "正兜反兜脚":"大招", "反兜正兜拳":"空中大招"}]
B = {"后前拳":"格招"}
A.append(B)
print(A)
'''
#修改
'''
lst = ['阿狗']
lst[0] = '阿猫'
'''
##利用切片修改 例如：new_A_list[3:4] 或加入间隔值 new_A_list[3:4:2]
'''
new_A_list = ['1g','2d','3s','4e','5g','6f','7d','8x','9f','0f']
new_A_list[3:4] = ['2222','1111']
print(new_A_list) ##['1g', '2d', '3s', '2222', '1111', '5g', '6f', '7d', '8x', '9f', '0f']
'''
##加入间隔值 new_A_list[3:4:2]
'''
new_A_list = ['1g','2d','3s','4e','5g','6f','7d','8x','9f','0f']
new_A_list[3:7:2] = ['2222','1111']
print(new_A_list) ##['1g', '2d', '3s', '2222', '5g', '1111', '7d', '8x', '9f', '0f']
'''
#删除 del 列表[索引] #一次删除一个 del 列表[开始索引:结束索引] 一次删除一堆
# pop(()索引) remove(值) clear() ##整个列表全删除 格式：lst.clear()
#remove 删除列表中某个元素 用法：list.remove(item)
'''
Zoo.remove('阿猫') #只删除第一个被找到的，找不到就会报错
print(Zoo)
'''
#del 手工删除内存里面的这个列表（为内存腾出空间）
'''
del Zoo
print(Zoo) #所以当打印的时候就是报错
'''
#除此以外还能用 len，max，min
#### max 和 min 是高阶函数能把 Iterable 里的数据分别找到最大值和最小值
'''
a = [1,2,3,4,5,6,7,8,9]
print(min(a)) ##1
print(max(a)) ##9
'''
#列表与元组之间的累加和 乘法
'''
c_list = new_A_list + new_A_list #两者可以相加
print(c_list)
d_list = new_A_list * 5 #得到一个有五次一模一样重复的列表
print(d_list)
'''
#也可以使用赋值运算
'''
c_list += ['0d','ew'] #相当于后面加列表
print(c_list)
c_list *= 2 #相当于后面加多‘多少’个列表
print(c_list)
'''
#列表的内置函数 insert 用法：变量列表.insert(index,new_item) index:代表新的元素插入在什么位置（数字） new_item：代表添加的新元素（成员）
#如果insert传入的位置在列表不存在则会将元素添加到结尾
'''
A_list = ['1g','2d','3s','4e','5g']
B_list = ['de']
C = 'DF'
A_list.insert(0,B_list) #可以添加列表
B_list.insert(0,C) #可以添加变量
B_list.insert(0,'dex') #可以添加字符串
'''
#ps：不需要用新的变量接收，并没有生成一个新的列表，否则返回的是None
'''
print(A_list) #添加的是列表的话，就会在列表内多一个列表的成员
print(B_list)
'''
#列表和（元组）的count函数 用法：变量列表（元组）.count(item) 查询列表和元组里面有多少个item的个数 item是“完整的成员”
#例子
Zoo = ["阿猫","阿狗","公鸡","阿猫","阿猫","猪","阿狗","阿狗","阿狗","公鸡","公鸡","公鸡","猪","阿狗","阿狗"]
cat = Zoo.count('阿猫')
dog = Zoo.count('阿狗')
#reverse 列表反转 用法list.reverse #reverse，sort，clear都是无返回值，直接对原列表修改#
House = ["11阿猫","02阿狗","03公鸡","04阿猫","05阿猫","06猪","08阿狗","09阿狗","07阿狗","11公鸡","14公鸡","16公鸡","19猪","20阿狗","23阿狗"]
'''
print(House)
House.reverse() #和del一样 不需要赋值给别的变量，不然就是None
print(House)
'''
#sort 列表重新排序，英文从a开始排序数字从0开始 也是不需要赋值,排序的列表不能是混合列表 #reverse，sort，clear都是无返回值，直接对原列表修改#
'''
House.sort #两种写法都行
House.sort() #两种写法都行
print(House)
'''
#set 无序排序，强转集合
'''
print(set(House))
'''
#可以通过 reverse=True 和 reverse=Flase改变(True)从大变小还是(False)从小变大, 排序的列表不能是混合列表
'''
House.sort(reverse=True)
print(House)
House.sort(reverse=False)
print(House)
'''
#clear 把列表变为空列表 #reverse，sort，clear都是无返回值，直接对原列表修改#
'''
House.clear() #清空列表是需要加括号的
print(House)
'''
# extend 列表变量.extent(需要传入的列表变量)
'''
a = [1,2,3,4,5,6]
b = ('a','','','','e','f','g','h')
a.extend(b)
print(a)
c = [1,2,3,4,5,6]
d = ('a','','','','e','f','g','h')
print(c+d) #用+是无法实现列表和元组的合并但extent可以
'''
# 如果传入的是字符串会将字符串拆分为单个的字符,如果是字典则会传入key值
'''
test = []
test.extend('dsfgsdjflkds')
print(test)
'''
##list 列表的常用知识点 和上面内容有部分重复
'''
House = ["11阿猫","02阿狗","03公鸡","04阿猫","05阿猫","06猪","08阿狗","09阿狗","07阿狗","11公鸡","14公鸡","16公鸡","19猪","20阿狗","23阿狗"]
print(House[:]) #[:]返回完整数据
print(House[0:]) #别一种返回完整数据
print(House[3:5]) #取中间某段值口诀顾头不顾尾
print(len(House) - 1)#查询最后一个元素的索引
print(House[::-1]) #列表反转
print(House[-3:-1]) #获取最后3个元素
print(House[0:8:2]) #从：到什么：每个隔开多少个元素
print(House[0:0]) #切片生成空列表
#列表获取和修改
print(House[-3]) list[index] = index位置的元素
print(House.index('03公鸡')) #获取这字符串的位置
House[4] = ('大大力') #这样就可以在列表添加这个元素
print(House)
House[3:6] = ['公共','非常','爹额'] #在具体的位置插入列表
print(House)
House[3:6] = '公共','非常','爹额' #也可以是字符串
print(House)
House.pop(13) #删除具体位置上的成员，用法 变量.pop(位置)
del House[4] #第二种删除列表具体位置的方法
#元组除了删除元素和添加外都可以用以上的命令（元组可以整个被删除）
'''
'''
'我要大大力' #字符串无法通过索引修改和删除
#0 1 2 3 4 字符串也是有对应的位置的如424行
#-5-4-3-2-1 倒叙
'''
####高阶函数 sorted 实际工作中用于对比多个平台上的订单列表或商品编号用于对比是否是排序不同的一样订单
'''
lst1 = [123,234,345]
lst2 = [345,234,123]
print(sorted(lst1) == sorted(lst2)) ##True
'''
###########字典############
#字典的相关函数
'''
fromkeys() #使用一组键和默认值创建字典
pop() #通过键去删除键值对
popitem() #删除最后一个键值对
clear() #清空字典
update() #批量更新（有改键就更新，没有该键就添加）
get() #通过键获取值（若没有该键可设置默认值，预防报错）
key() #将字典的键组成新的可迭代对象
value() #将字典的值组成新的可迭代对象
items() #将字典的键值对凑成一个个元组，组成新的可迭代对象
'''
#空字典 dictvar = {}
#字典的键 以及 集合的值有数据类型上的要求 ，需要不可变类型：Number（int float bool complex）,str tuple
'''
dict_123 = {'姓名': '西门口','年龄':'33'} #字符串姓名和年龄都是 key
dict_123['身高'] = 170 #测试不能用{}添加新key，都是用[]
print(dict_123) ##{'姓名': '西门口', '年龄': '33', '身高': 170}
dict_123 = {'姓名': '西门口','年龄':'33'} #字符串姓名和年龄都是 key
dict_123['姓名'] = '坤耿你' #这样就会修改value值 的
print(dict_123) ##{'姓名': '坤耿你', '年龄': '33'}
print(dict_123["姓名"]) #根据key找value ##坤耿你
'''
#增
'''
dic = {}
dic['top'] = '程咬金' #修改字典中的值 # 对不存在的key赋值，就是增加key-value对
dic['middle'] = '鲁班七号'
dic['bottom'] = '刘备' ##{'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备'}
'''
## fromkeys 使用一组键和默认值创建字典
'''
lst = ['top','middle', 'bottom']
dic = {}.fromkeys(lst,None) #这里的value设定了就会所有都变成统一的value
print(dic) #{'top': None, 'middle': None, 'bottom': None}
dic['top'] = []
print(dic) #{'top': [], 'middle': None, 'bottom': None}
dic['top'] = ['fsdf']
print(dic) #{'top': ['fsdf'], 'middle': None, 'bottom': None}
dic['top'].append('22')
print(dic) #{'top': ['fsdf', '22'], 'middle': None, 'bottom': None}
'''
##append()
'''
dic = {}
dic['a'] = ['3'] #字典的value如果是列表的话可以这样添加新的列表
dic['b'] = ['1']
dic['a'].append('dfsd')
print(dic)
'''
##setdefault 获取某个key的value，如key不存在于字典中，将会添加key并将value设置为默认值
'''
dic = {}
dic['a'] = ['1']
dic['b'] = ('3',)
dic['a'].append('dfsd')
dic.setdefault('c')
print(dic) ##{'a': ['1', 'dfsd'], 'b': ('3',), 'c': None}
dic['c'] = []
print(dic) ##{'a': ['1', 'dfsd'], 'b': ('3',), 'c': []}
dic['c'] = ['fsdf']
print(dic) ##{'a': ['1', 'dfsd'], 'b': ('3',), 'c': ['fsdf']}
'''
#删
#删除键值
'''
dic = {'a': ['1', 'dfsd'], 'b': ('3',), 'c': ['fsdf']}
del dic['a']
print(dic) ##{'b': ('3',), 'c': ['fsdf']}
'''
#清空字典 clear
'''
dic = {'a': ['1', 'dfsd'], 'b': ('3',), 'c': ['fsdf']}
dic.clear()
print(dic) ##{}
'''
#pop() 通过键去删除键值对
'''
dic = {'a': ['1', 'dfsd'], 'b': ('3',), 'c': ['fsdf']}
res = dic.pop('b')
print(res) ##('3',) #返回值是删除的value
print(dic) ##{'a': ['1', 'dfsd'], 'c': ['fsdf']}
'''
#pop()防止pop()报错的用法
'''
dic = {'a': ['1', 'dfsd'], 'b': ('3',), 'c': ['fsdf']}
res = dic.pop('d','报错后打印这段字')
print(res) ##报错后打印这段字
'''
#改
##update() 批量更新（有该键就更新，没有） 用法： dict.update(new_dict) 添加新字典，原有的会被跟新，没有的会被添加
'''
dic = {'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备'}
dic_new = {'jungle':'孙权'}
dic.update(dic_new)
print(dic) ##{'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备', 'jungle': '孙权'}
dic_new2 = {'support':'蔡文姬'，w='123'}
dic.update(dic_new2)
print(dic) ##{'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备', 'jungle': '孙权', 'support': '蔡文姬', 'w': '123'}
'''
#查
##get()
'''
dic = {'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备'}
print(dic['dds']) ##报错
print(dic.get('dds')) ##返回None
print(dic.get('dds','找不到哦')) ##找不到哦 #避免报错可以自定义默认值
'''
#key() 从新把字典的键组成新的可迭代对象
'''
dic = {'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备'}
res = dic.keys()
print(res) ##dict_keys(['top', 'middle', 'bottom'])
print([i for i in res]) ##['top', 'middle', 'bottom'] #组成新的可迭代对象Iterable
'''
#values() 从新把字典的值组成新的可迭代对象
'''
dic = {'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备'}
res = dic.values()
print(res) ##dict_values(['程咬金', '鲁班七号', '刘备'])
print([i for i in res]) ##['程咬金', '鲁班七号', '刘备'] #组成新的可迭代对象Iterable
'''
#items() #将字典的键值对凑成一个元祖，组成新的可迭代对象
'''
dic = {'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备'}
res = dic.items()
print(res) ##dict_items([('top', '程咬金'), ('middle', '鲁班七号'), ('bottom', '刘备')])
dic = {'top': '程咬金', 'middle': '鲁班七号', 'bottom': '刘备'}
for k,v in res: ##变量的解包
print(k,v)
'''
########工作案例#########
#####把二维字典转一维####
'''
AAA = ['1号机','8号机','3号机','4号机','5号机','6号机','10号机']
识别码与验证码 = {'1号机':{'301340851':'PI53G7'},'8号机':{'699198462':'ONRxLy'},'3号机':{'199883402':'6wWKvQ'},'4号机':{'337722198':'wk27ms0'},'5号机':{'786817297':'654111'},'6号机':{'516196562':'789333'},'10号机':{'452376586':'b38C09'}}
res1 = [识别码与验证码[i] for i in AAA]
print(res1) #获取对应的工作的电脑名称下的识别码与验证码 ##[{'301340851': 'PI53G7'}, {'699198462': 'ONRxLy'}, {'199883402': '6wWKvQ'}, {'337722198': 'wk27ms0'}, {'786817297': '654111'}, {'516196562': '789333'}, {'452376586': 'b38C09'}]
res2 = {}
res3 = [res2.update(i) for i in res1]
print(res2) #通过update()循环加入到新的字典中 ##{'301340851': 'PI53G7', '699198462': 'ONRxLy', '199883402': '6wWKvQ', '337722198': 'wk27ms0', '786817297': '654111', '516196562': '789333', '452376586': 'b38C09'}
res4 = {}
for i in 识别码与验证码:
print(识别码与验证码[i].keys()) #读取每个value下的key ##dict_keys(['301340851']) ##dict_keys(['699198462']) ##dict_keys(['199883402']) ##dict_keys(['337722198']) ##dict_keys(['786817297']) ##dict_keys(['516196562']) ##dict_keys(['452376586'])
print(list(识别码与验证码[i].keys())) #字典强转列表后只保留key的特性得到每个value下的key
res4[list(识别码与验证码[i].keys())[0]] = i ##用创建字典 的方法得到想要的 识别码：机号
print(res4)
'''
#################### set 集合 ##########################
#空集合
'''
setvar = set()
'''
# 不可获取其中元素 不可修改， 自动去重
'''
setvar = {'王大力'，'隔壁老王','王大捷','王再战','王不屈'}
print(setvar[0]) # 不可获取其中元素 !!!!!
'''
#集合的相关操作 交& 差- 并| 补^ 子集< 父集>
## intersection() 交集 简化符号&
## difference() 差集 简化符号-
## union() 并集 简化符号|
## symmetric_difference() 对称差集 (补集情况涵盖其中) 简化符号^
## issubset() 判断是否子集 简化符号<
## issuperset() 判断是否父集 简化符号>
## isdisjoint() 判断2集合是否不相交 不相交True 相交False
# 集合不能用+
#intersection() 交集 简化符号& （键盘上的数字7）
'''
set1 ={'AAA','BBB','CCC','DDD','EEE','FFF'}
set2 ={'AAA','BBB','CCC','GGG','HHH','III'}
print(set1&set2) ##{'BBB', 'AAA', 'CCC'} #化简符
print(set1.intersection(set2)) ##{'BBB', 'AAA', 'CCC'}
'''
#difference() 差集 简化符号- (减号)
'''
set1 ={'AAA','BBB','CCC','DDD','EEE','FFF'}
set2 ={'AAA','BBB','CCC','GGG','HHH','III'}
print(set1-set2) ##{'FFF', 'EEE', 'DDD'}
print(set1.difference(set2)) ##{'FFF', 'EEE', 'DDD'}
'''
#union() 并集 简化符号|
'''
set1 ={'AAA','BBB','CCC','DDD','EEE','FFF'}
set2 ={'AAA','BBB','CCC','GGG','HHH','III'}
print(set1|set2) ##{'FFF', 'BBB', 'EEE', 'DDD', 'HHH', 'GGG', 'III', 'AAA', 'CCC'}
print(set1.union(set2)) ##{'FFF', 'BBB', 'EEE', 'DDD', 'HHH', 'GGG', 'III', 'AAA', 'CCC'}
'''
## issubset() 判断是否子集 简化符号<
'''
set1 ={'AAA','BBB','CCC','DDD','EEE','FFF'}
set2 ={'AAA','BBB','CCC','GGG','HHH','III'}
print(set1<set2) ##False
print(set1.issubset(set2)) ##False
'''
## issuperset() 判断是否父集 简化符号>
'''
set1 ={'AAA','BBB','CCC','DDD','EEE','FFF'}
set2 ={'AAA','BBB'}
print(set1>set2) ##True
print(set1.issuperset(set2)) ##True
'''
####集合的增删###
#增
##add() 一次加一个
'''
set1 ={'AAA','BBB','CCC','DDD','EEE','FFF'}
set2 ={'AAA','BBB'}
print(set1.add('111')) ##None
print(set1) ##{'DDD', '111', 'AAA', 'BBB', 'EEE', 'FFF', 'CCC'}
'''
##update() 迭代增加一次加一堆
'''
set1 ={'AAA','BBB','CCC','DDD','EEE','FFF'}
set2 ={'AAA2','BB3B'}
print(set1.update(set2)) ##None
print(set1) ##{'CCC', 'BBB', 'BB3B', 'FFF', 'AAA2', 'DDD', 'AAA', 'EEE'}
'''
#删
#clear() 清空集合
#pop() 随机删集合中的一个数据
#remove() 删集合中指定值（不存在会报错）
#discard() 删集合中指定值（不存在不会报错）
#冰冻集合 frozenset() 如果把集合比作列表，冰冻集合就是元组 冰冻集合除了不能修改之外，其余和集合一样
#空的冰冻集合：
'''
变量 = frozenset()
'''
#冰冻集合的常用函数
'''
copy() 可以使用
difference() 差集 可以使用
difference_update() 更新差集 不可以使用
intersection() 交集 可以使用
intersection_update()更新交集 不可以使用
union() 并集 可以使用
update()更新并集 不可以使用
issuperset() 检测超集 可以使用
issubset() 检测子集 可以使用
isdisjoint() 检测是否不相交 可以使用
symmetric_difference()可以使用（对称差集）
symmetric_difference_update()不可以使用（更新对称差集）
'''
######################## 深浅拷贝 #####################(该章节需要重新观看视频，还未看懂)
#copy 把原列表的内容重新赋值到一个新的列表上
'''
old_list = ["A","B","C"]
new_list = old_list.copy()
print(new_list)
'''
#deepcopy 深拷贝 错的
'''
a =[[1,2,3],[4,5,6]]
b = copy.deepcopy(a)
print(b)
'''
#################次数循环################
'''
Mun = 0
while Mun < 4:
if Mun == 0:
print('我特么的开始了循环')
elif Mun >= 2:
print("我真的是有病，现在才循环第"+str(1+Mun)+"次")
elif Mun != 4:
print("加油")
Mun = Mun + 1
'''
#无限循环
'''
B = 0
while True:
if B > 5:
print("我真TM有病要重复无限次")
elif B == 5:
break
B = B +1
print("当前循环第"+str(B)+"次")
'''
#次数循环
'''
d = 2
Mun = 5
print('640行的id',id(d))
for d in range(2,Mun,1):
print('我有病要重复'+str(Mun)+'次，当前重复'+str(int(1)+(d))+'次')
print('351行的id',id(d))
print('352行的id',id(d))
print('353行的',d)
'''
#######for else###### 二周目
'''
for i in range(3):
print(i)
else: #不被中断就会被执行
print('如果上面的for循环没有中断，没有break过，那么就会进入下面这里')
print(i) ##这个i能在外面
'''
####同理 while else 也是可以的####
'''
n = 1
while n < 5:
print(n)
n+=1
else: #不被中断就会被执行
print('test') ##test
'''
#####关于for i in range() 和 while的区别
#for i in range 肯定是有固定次数循环
#while 固定次数循环，不确定的循环
#循环退出和跳过当前循环
'''
break #退出循环
continue #跳过当前循环继续下一次循环
'''
####代码块
'''
变量 = '5'
if 变量 == 5: #格式
print(1) #如果是tab缩进就必须全部tab缩进
print(2) #如果是4空格就必须全部四空格缩进
print(3)
print(4)
else:
print(5)
print(6)
'''
#类型判断 isinstance(var，类型)
lst = [(1,2,3),[4,5]]
for i in lst:
if isinstance(i,list):
for j in i:
print('列表是'+str(j))
elif isinstance(i,tuple):
for k in i:
print('元祖是'+str(k))
############文件基本操作#################
'''
w write 写入模式
r read 读取模式
a append 追加模式
x xor 异或模式
'''
#扩展模式（配合打开模式的辅助模式，自己单独不能用）
'''
+ plus 增强模式（可以让文件具有读写功能）
b bytes bytes模式（二进制字节流）
'''
##模式一共16种
'''
w,w+,wb,wb+
r,r+,rb,rb+
a,a+,ab,ab+
x,x+,xb,xb+
'''
###文件操作###
'''
fp = open(文件名,模式,编码集)
fp: 文件io对象（文件句柄）
i:input 输入
o:output 输出
fp.write() 写入
fp.read() 读取
'''
#如下三步即可创建一个文件并写入‘写入字符’
'''
fp = open(r'E:\新建文件夹\123.txt',mode='w',encoding='utf-8')
fp.write('写入字符')
fp.close()
'''
##文件的扩展模式 +
#(utf-8 编码格式下默认一个中文三个字节一个英文或符号占一个字节)
#read() 功能：读取字符的个数，括号里面的参数代表字节个数
#seek() 功能：调整光标的位置，括号里面的参数代表字节个数
#tell() 功能：当前光标左侧所有的字节数
##字节流：数据传输或1储存的一种二进制格式,多个字节组合在一起就是字节流
#将字符串和字节流转换
#encode() 编码 将字符串转化为字节流
#decode() 解码 将二进制字节流bytes转化为字符串
#关于字节流的个人认识
'''
b'\xe4\xbd\xa0\xe5\xa5\xbd' #在utf-8下每三个字节代表一个汉字
'''
#编码
'''
strvar = '你好'
res = strvar.encode('utf-8')
print(res) ##b'\xe4\xbd\xa0\xe5\xa5\xbd' #这里的b代表二进制字节流的意思
'''
#解码
'''
bytes_str = b'\xe4\xbd\xa0\xe5\xa5\xbd'
res = bytes_str.decode('utf-8')
print(res) ##你好
'''
#字节流的写入操作
'''
fp = open(r'E:\新建文件夹\123.txt',mode='wb') #字节流不需要任何的编码集
fp.write(b'\xe4\xbd\xa0\xe5\xa5\xbd')
fp.close()
'''
#字节流的读取操作
'''
fp = open(r'E:\新建文件夹\123.txt',mode='rb')
res = fp.read()
print(res)
'''
#字节流的用处，复制！ 把文件看成二进制字节流进行系统中的复制粘贴 一般是图，音频，视频
#把图片中的所有字节流获取一下
'''
#复制
pathvar = r'E:\新建文件夹\111.bmp' #当然这个111.bmp请在对应的根目录下创建
fp = open(pathvar,mode='rb')
bytes_data = fp.read()
fp.close()
print(bytes_data)
#粘贴
pathvar2 = r'E:\新建文件夹\112.bmp' #粘贴到什么位置要写好哦
fp = open(pathvar2,mode='wb') #改为写入模式
bytes_data = fp.write(bytes_data)
fp.close()
'''
#r+ 先读后写
'''
fp = open(r'E:\新建文件夹\123.txt',mode = 'r+',encoding = 'utf-8') #r模式下回默认把光标放在文本开头
#先读
res = fp.read() #读光标后面的字节
print(res)
#因为有'+'所以再写
fp.write('abc') #写完后光标会去到最后
#write后会移动光标位置
fp.seek(0) #0代表第0个字节，在utf-8下中文1个字符等于三个字节
#再读
print(fp.read())
fp.close()
#seek(0) 移动光标到开头的意思
#seek(0,2) 移动到结尾
'''
#w+ 可读可写（还会删除之前的内容，别外文件不存在会自动创建）
#没摘录例子
#a+ 可写可读 文件后面添加写入（即使移动光标也强制最后追加，文件不存在自动创建）
'''
fp = open(r'E:\新建文件夹\123.txt',mode = 'a+',encoding = 'utf-8')
fp.write('猪八戒猪八戒听到请回答我是孙悟空')
#移动光标到开头
fp.seek(0)
print(fp.read())
fp.close()
'''
#关于seek 如果是字符串模式 单位 是字符的个数
# 如果是字节流模式 单位 是字节的个数
#别外开发者不会用seek，因有可能把光标移动到字符串里面
#tell() 一般是用tell()因为seek()会移动到字节流里面导致读不到而报错
'''
fp = open(r'E:\新建文件夹\123.txt',mode = 'a+',encoding = 'utf-8')
#移动光标到开头
fp.read(6)
print(fp.tell()) #得到一个读取整段内容的数字
fp.close()
'''
### with ### 可自动实现文件关闭功能
#as 起别名
'''
pathvar = r'E:\新建文件夹\111.bmp' #当然这个111.bmp请在对应的根目录下创建
with open(pathvar,mode = 'rb') as fp:
bytes_data = fp.read()
#上面是复制，下面是粘贴
pathvar2 = r'E:\新建文件夹\222.bmp'
with open(pathvar2,mode = 'wb') as fp:
#如此实现复制粘贴
fp.write(bytes_data)
'''
#上段再进一步优化
'''
pathvar = r'E:\新建文件夹\111.bmp' #当然这个111.bmp请在对应的根目录下创建
pathvar2 = r'E:\新建文件夹\222.bmp'
with open(pathvar,mode = 'rb') as fp1,open(pathvar2,mode = 'wb') as fp2:
bytes_data = fp1.read()
fp2.write(bytes_data)
'''
##刷新缓冲区 flush
'''
with open(r'E:\新建文件夹\111.txt',mode = 'a+',encoding = 'utf-8') as fp:
fp.write('ddd')
#手动刷新缓冲区，直接把内容写入到文件中
fp.flush() #打开文件后就会看到ddd已经写入
#那怕脚本下方是无限循环都能刷新
while True:
pass
'''
############ 文件相关函数 ################
#readline() 功能：读取一行文件内容
#readlines() 功能：将文件中的内容照换行读取到列表当中
#writelines() 功能：将内容是字符串的可迭代数据写入文件中 参数：内容为字符串类型的可迭代数据
#truncate() 功能：把要截取的字符串提取出来，然后清空内容将提取的字符串重新写入文件中（字节）
#readable() 功能：判断文件对象是否可读
#writable() 功能：判断文件对象是否可写
#readable() 判断可读 writable() 判断可写
'''
fp = open(r'E:\新建文件夹\111.txt',mode = 'w',encoding = 'utf-8')
print(fp.readable()) #返回 True 或 False
print(fp.writable()) #用于先判断再干活
'''
#readline() 功能：读取一行文件内容
#readline() 括号里的参数默认不写，读取的是当前行
#如果参数值>当前行字符总个数 就按照当前行读取
#如果参数值<当前行字符总个数 按照参数个数来读取
#先把下面这4段话放进 E:\新建文件夹\111.txt
'''
从前明月光
疑是地上霜
举头望明月
低头思故乡
'''
'''
with open(r'E:\新建文件夹\111.txt',mode = 'r+',encoding = 'utf-8') as fp:
res = fp.readline() #读取当前行
#res = fp.readline(3) #读取3行
#res = fp.readline(1000)#读取当前行，因为读不到所以读取当前行
print(res)
'''
#读取所有内容
'''
with open(r'E:\新建文件夹\111.txt',mode = 'r+',encoding = 'utf-8') as fp:
res = fp.readline() #读取当前行
while res: #如果不为空 开始循环
print(res) #先打印数据
res= fp.readline() ##再读取一行
'''
#可以直接遍历文件对象fp（可迭代对象）一行一行遍历文件中的数据
'''
with open(r'E:\新建文件夹\111.txt',mode = 'r+',encoding = 'utf-8') as fp:
for i in fp:
print(i)
'''
#readlines() 功能:将文件中的内容按照换行读取到列表当中
'''
with open(r'E:\新建文件夹\111.txt',mode = 'r+',encoding = 'utf-8') as fp:
lst = fp.readlines()
print(lst) ##['从前明月光\n', '疑是地上霜\n', '举头望明月\n', '低头思故乡']
##案例 很多时候需要数据清洗一下，把数据两边的空白符去掉，返回新列表
lst_new = [i.strip() for i in lst]
print(lst_new) ##['从前明月光', '疑是地上霜', '举头望明月', '低头思故乡']
'''
#个人愚见的替代上面的优化
'''
with open(r'E:\新建文件夹\111.txt',mode = 'r+',encoding = 'utf-8') as fp:
print([i.strip() for i in fp]) ##['从前明月光', '疑是地上霜', '举头望明月', '低头思故乡']
'''
#writelines() 功能：将内容是字符串的可迭代数据写入文件中 参数：内容为字符串类型的可迭代数据
'''
lst_new = []
lst = ['从前明月光', '疑是地上霜', '举头望明月', '低头思故乡']
with open(r'E:\新建文件夹\111.txt',mode = 'w+',encoding = 'utf-8') as fp:
for i in lst:
lst_new.append(i+'\n') ##用insert(索引,'加的字符串\n')
print(lst_new)
fp.writelines(lst_new)
'''
#truncate() 功能：把要 ‘截取’ 的字符串提取出来，然后 ‘清空’ 内容将提取的字符串 ‘重新’ 写入文件中（字节）
#E:\新建文件夹\111.txt中有以下这段话
'''
从前明月光
疑是地上霜
举头望明月
低头思故乡
'''
'''
with open(r'E:\新建文件夹\111.txt',mode = 'r+',encoding = 'utf-8') as fp:
#truncate(字节) 截取-清空-重写
fp.truncate(6) #3字节=一个中文,所以得到‘从前’ ##从前
'''
#### 练习题 九九乘法表 ####
'''
for i in range(1,10):
for j in range(1,i+1):
print('{:d}*{:d}={:2d}'.format(i,j,i*j),end='')
print()
'''
##得到以下一个9*9乘法表
'''
1*1= 1
2*1= 22*2= 4
3*1= 33*2= 63*3= 9
4*1= 44*2= 84*3=124*4=16
5*1= 55*2=105*3=155*4=205*5=25
6*1= 66*2=126*3=186*4=246*5=306*6=36
7*1= 77*2=147*3=217*4=287*5=357*6=427*7=49
8*1= 88*2=168*3=248*4=328*5=408*6=488*7=568*8=64
9*1= 99*2=189*3=279*4=369*5=459*6=549*7=639*8=729*9=81
'''
########### 函数 #################
#（1）函数的含义
#功能（包裹一部分代码实现某一个功能达成某一个目的）
#（2）函数的特点
#可以反复调用，提高代码的复用性，提高开发效率，便于维护管理
#（3）函数基本格式
#定义函数
'''
def 函数名():
code块
'''
#调用函数
'''
函数名()
'''
##例子 ##定义
'''
#定义
def aaa():
print('我是一个函数')
#调用这个aaa函数
aaa()
'''
#（4）函数命名
#字母数字下划线，首字符不能为数字；
#严格区分大小写，且不能使用关键字；
#函数命名有意义，且不能使用中文哦。
##驼峰命名法：
#(1)大驼峰命名法(每个单词首字符大写)【面向对象中的类】
#(2)小驼峰命名法(除了第一个单词首字符小写外，剩下的单词首字符都大写)【函数,变量】
##例子：
#myapple ~~~~ MyApple 大驼峰命名
#myapple ~~~~ myApple 小驼峰命名
#thisismycar ~~~~ ThisIsMyCar 大驼峰命名
#thisismycar ~~~~ thisIsMyCar 小驼峰命名
##下划线命名法：
#thisismycar ~~~~ this_is_my_car 下划线命名
##函数的运用的例子：
'''
#定义
def aaa():
for i in range(1,10):
for j in range(1,i+1):
print('{:d}*{:d}={:2d}'.format(i,j,i*j),end='')
print()
#调用5次的话
for i in range(5):
aaa() ##就是把定义里面的九九乘法表打印5次哦
'''
##函数的参数
#原则：形参实参一一对应
#参数:配合函数运算的那个值就是参数
#(1)形参：形式参数，在函数定义处
#(2)实参：实际参数，在函数调用处
#形参:
#(1)普通形参(位置)
#(2)默认形参
#(3)普通收集形参
#(4)命名关键字
#(5)关键字手机形参
#实参：
#(1)普通实参
#(2)关键字实参
###(1)普通形参(位置)
#定义函数
'''
def super_star(a,b):
i = a
while i<b:
j=0
while j < b:
print('*',end = '')
j+=1
i+=1
#调用函数
super_star(3,5)
#如果不填变量就会报错
'''
###(2)默认形参
#参数身上带有默认值，下面例子中的hang和lie是默认参数
'''
def super_star(hang=10,lie=6): #这是一个无意义的循环...
i = hang
while i<lie:
j=0
while j < lie:
print('*',end = '')
j+=1
i+=1
#调用函数
super_star() #如果实参没给，直接用参数的默认值
super_star(3,5) #给了就用给了的参数
super_star(3) #给了就用给了的参数
'''
###(3)普通形参+默认形参
#普通形参必须写在默认形参的前面
'''
def super_star(hang,lie=6): #这是一个无意义的循环...
i = hang
while i<lie:
j=0
while j < lie:
print('*',end = '')
j+=1
i+=1
#调用函数
super_star(3,5)
super_star(3)
'''
###(4)关键字实参
#收集形参
#普通收集形参：专门用来收集那些没有人要的多余的普通实参，构成一个元组
'''
def func(*args): #头顶顶一个*
pass #args的意思是arguments
'''
#普通收集形参
'''
def func(a,b,c,*args):
print(a,b,c) ##1 2 3
print(args) ##(4, 5)
func(1,2,3,4,5)
'''
#任意个数值的累加和
'''
def func(*args):
print(args) ##(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
total = 0
for i in args:
total+=i
print(total) ##55
func(1,2,3,4,5,6,7,8,9,10)
'''
#关键字变字典
'''
def func(a,b,**args):
print(args) ##{'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(a,b) ##1,2
func(a=1,b=2,c=3,d=4)
'''
##任意个数值的字符串拼接 ###其实未看懂这个案例，待以后再看！！
#班长：陈一
#班花：李二
#吃瓜群众：张三，李四，黄五
'''
def func(**kwargs):
strvar1 = ''
dic={'monitor':'班长','classflower':'班花'}
print(kwargs) ##{'班长': '陈一', '班花': '李二', '群众': ['张三', '李四', '王五']}
for k,v in kwargs.items():
print(k,v)
if k in dic:
strvar1 = dic[k]+':'+v
print(strvar1) ##
func(班长='陈一',班花='李二',群众=['张三','李四','王五'])
'''
##命名关键字 形参
#def func(a,b,*,c,d)跟在*号后面的c和d是命名关键字形参，意味着调用时必须指定参数的名字进行调用，也就是必须使用关键字实参的形式调用（指名道姓）
#(1)情况1
'''
def func(a,b,*,c,d):
print(a,b)
print(c,d)
func(1,2,c=3,d=4) #在*之后的都需要指名道姓
'''
#(2)情况2
'''
def func(*args,c,d,**kwargs):
print(args) ##(1, 2, 3)
print(c,d) ##3 200
print(kwargs) ##{'f': 1, 'z': 2}
func(1,2,3,f=1,z=2,c=3,d=200)
'''
# *和**的使用
#在函数的 定义处 使用*和**
# *代表最后打包成元祖
# **代表最后打包成字典
#在函数的 调用处 使用*和**
# *代表最后把元祖、列表这样的容器打散，解包
# **代表最后把字典这样的容器打散解包
'''
def func(*args,c,d,**kwargs):
print(args) ##(1, 2, 3)
print(c,d) ##3 200
print(kwargs) ##{'f': 1, 'z': 2}
func(1,2,3,f=1,z=2,c=3,d=200)
'''
##综合版本
'''
lst = [3,4]
dic = {'c':100,'d':200}
#定义处*用来手机打包
def func(*args,**kwargs):
print(args)
print(kwargs)
#调用处*号用来打散解包
func(*lst,**dic)
'''
#总结
#(1)当所有的形参都存在时，必须按照如下顺序进行定义：
#普通形参（位置） ~~~~~~ 默认形参 ~~~~~~ 普通收集形参 ~~~~~ 命名关键字形参 ~~~~~~关键字收集形参
## return 函数返回值
#把函数内部的值返回到函数的外部
#1，return+6大标准数据类型，还可以接类对象和函数把返回值扔给函数调用处
#2，一旦执行了return，函数立即终止
#3，如果函数内部没有定义任何返回值默认返回None
'''
def TTT():
return 1 #接六大标准数据类型和类对象 和 函数
print(TTT()) ##1
'''
#一旦执行了return，函数立即终止和break的区别，break只能在循环中使用
#如果函数内部没有定义任何返回值，默认返回None
'''
def func():
pass
print(func()) ##None
'''
##例子计算器
'''
def calc(sign,num1,num2):
if sign == '+':
return num1+num2
elif sign == '-':
return num1-num2
elif sign == '*':
return num1*num2
elif sign == '/':
if num1 == 0:
return '除数不能为0'
return num1/num2
else:
return '唔识计啊'
res = calc('+',1,2)
print(res)
'''
##局部变量 和 全局变量
#概念：
#局部变量：定义在函数内部的变量
#全局变量：定义在函数外部的变量，或者再函数内部使用global关键字定义的变量
#作用域：
#局部变量：仅限定在函数内部使用
'''
def func():
global b #把b定义为全局变量
b =1000
print(b) ##1000
func()
print(b) ##1000
'''
#总结：global使用
#使用global关键字在函数内部定义一个全局变量，或者修改一个全局变量
#有则改之，无则创建之
###函数名的使用
#python 中的函数可以像变量一样，动态创建，销毁，当参数传递，作为值返回，叫第一类对象，其他语言功能有限
#1，函数名是个特殊的变量，可以当做变量赋值
'''
a = 1
def fun():
print('我是fun函数')
a = fun
a() #我是fun函数
'''
#2，函数名可以作为容器类型数据的元素
#3，函数名可以作为函数的参数
'''
def func1():
print('我是func1')
def func2():
func1()
func2()
'''
#4，函数名可以作为函数的返回值
#5,函数名可以作为容器类型数据的元素
'''
def box1():
print('我是box1')
def box2():
print('我是box2')
def box3():
print('我是box3')
lst = [box1,box2,box3]
#然后可以遍历这个列表了
for i in lst:
i() ##我是box1 ##我是box2 ##我是box3
'''
# __doc__或者help查看文档
'''
def eat_big_chang(something):
'''
功能：教你如何吃大肠
参数：视频的名称
返回值：吃它的状态
'''
print('找{}肠子头'.format(something))
print('把{}放嘴里'.format(something))
print('满意的放下{}肠子头'.format(something))
return '{}吃完了'.format(something)
help(eat_big_chang('双汇大肠'))
#找双汇大肠肠子头
#把双汇大肠放嘴里
#满意的放下双汇大肠肠子头
print(repr(eat_big_chang.__doc__)) ##' \n 功能：教你如何吃大肠\n 参数：视频的名称\n 返回值：吃它的状态\n '
print(eat_big_chang('双汇大肠') )
#找双汇大肠肠子头
#把双汇大肠放嘴里
#满意的放下双汇大肠肠子头
#双汇大肠吃完了
'''
### 函套函数
#函数之间可以互相函套，外部的函数即外函数，内部的函数即内函数
'''
def outer():
def inner():
print('我是inner')
'''
#内函数不可以直接外部调用
#调用外部函数后内部函数也不能外部调用
#内部函数可以在内部调用
#内部函数必须先定义再调用
###（了解）在其他语言中存在预加载机制，会提前把函数加载到内存，然后再执行对应的代码，所以可以先调用再定义，python没有
###LEGB原则
#找变量的调用顺序采用LEGB原则(即就近原则)
#B---Builtin（Python）：python内置模块的命名空间（内建作用域）
#G---Global（module）：函数外部所在的命名空间（全局作用域）
#E---Enclosing function locals：外部嵌套的作用域（嵌套作用域）
#L--- Local(function),当前函数内的作用域
##依据就近原则，从下往上，从里向外，依次寻找
#### nonlocal 用来修改局部变量
#（1）nonlocal修改局部变量时，采用LEGB原则
#（2）如果上一级不存在，继续往更上一级寻找变量
#（3）直到再也找不到报错
##############闭包函数######################
#互相嵌套的两个函数，内涵数使用了外函数的一个局部变量，外函数把内函数返回出来的过程叫做闭包
#其中内函数叫做闭包函数
'''
def liubisen_family():
father = 'yangjiechi'
def say():
print('我爸爸{}说的'.format(father))
return say
res = liubisen_family()
res() ##我爸爸yangjiechi说的
print(res) #<function liubisen_family.<locals>.say at 0x04A30780> 这个打印的意思是liubisen_family有一个say 这个say位置在0x04A30780这个内存地址里面
#是函数的话就可以加()调用
'''
##闭包函数的意义：
#闭包可以优先使用外函数中的变量，并对闭包中的值起到了封装保护的作用，外部无法访问
##为了保护累加值的变化，可以把她卸载函数内部封装起来，并且加长她的生命周期
'''
def func():
a = 0
def click():
nonlocal a
a+=1
print(a)
return click
f = func()
f() ##1
f() ##2
f() ##3
f() ##4
f() ##5
'''
###复杂结构
'''
def box_fanily():
jj = 'AAA'
MM = 'BBB'
money = 1000
def AAA_hobby():
nonlocal money
money -= 300
print('AAA爱车，剩{}钱'.format(money))
def BBB_hobby():
nonlocal money
money -= 600
print('BBB败家，剩{}钱'.format(money))
def big_master():
return [AAA_hobby,BBB_hobby]
return big_master
func = box_fanily()
lst = func()
AAA = lst[0]
AAA() ##AAA爱车，剩700钱
BBB = lst[1]
BBB() ##BBB败家，剩100钱
'''
#闭包
#获取闭包函数使用的变量(了解)
### __closure__,cell_conte
#闭包的定义：
#内函数使用外函数的局部变量，并且外函数将内函数返回出来的方法叫闭包，返回的内函数叫闭包函数
#闭包的特点:
#内函数使用了外函数的局部变量，外函数的局部变量与内函数发生绑定，延长该变量的生命周期
#（实际内存给它存储了这个值，暂时不释放）
#闭包的意义：
#闭包可以优先使用外函数中的变量，并对闭包中的值起到了封装保护的作用，外部无法访问
########迭代器#######
#概念：
#迭代器指的迭代取值的工具，迭代是一个重复的过程，每次重复都是基于上一次的结果而继续，
#别外，单纯的重复并不是迭代
#特征：
#并不是依赖索引，而通过next()指针（内存地址寻址）迭代所有数据一次只取一个值，而不是一股脑的把所有数据放进内存，大大节省空间
###### Iterator 迭代器
###### range 是可迭代对象
###range 和 Iterator 能产生惰性序列
####lambde#####
#函数表达式:只实现一些简单的函数功能，但是写法非常简便
# 匿名函数
#用一句话来表达只有返回值的函数，可以用lambda表达式
#lambda 格式: 参数:返回值
#特点： 高效简洁
#无参数的lambda表达式
'''
def function():
return 12345
print(function())
####用lambda表达式
function = lambda:12345
print(function())
'''
#有参数的lambda表达式
'''
def func(num):
return type(num)
####lambda 表达式改造
func = lambda num:type(num)
func(10)
'''
#带有判断条件的lambda表达式
#该例子有三元表达式 格式： ‘真值 if 表达式 else 假值‘ ~~~ 偶数' if num % 2 ==0 else '奇数
#当表达式满足时，返回真值，否则返回假值
'''
def func(num):
if num % 2 ==0:
return '偶数'
else:
return '奇数'
print(func(22)) ##偶数
##### lambda 表达式改造
func = lambda num : '偶数' if num % 2 ==0 else '奇数'
print(func(55)) ##奇数
'''
##传递2个参数，返回最大值
'''
def func(x,y):
if x > y:
return x
else:
return y
print(func(2,5)) ##5
##### lambda 表达式改造
func = lambda x,y : x if x > y else y
print(func(2,5)) ##5
'''
####locals 和 globals 用法
#global 关键词：声明全局变量 获修改全局变量
#globals 返回字典，存放着全局作用域所有内容
#locals() 返回字典,当前作用域所有内容(locals调用之前的变量)
#nonlocal 关键字：修改局部变量（当前函数上一层的局部变量）
#locals 返回当前作用域所有变量
'''
def func():
z1 =1
z2 =2
a =1
b =2
c =3
dic=locals() #当前作用域在全局空间，获取的是打印之前所有的全局变量
print(dic) #这里print出的东西是没有d也没有 func也没有z1和z2
d =3
'''
#当前作用域在局部空间
'''
def func():
z1 = 1
z2 = 2
dic =locals() #locals() 返回字典,当前作用域所有内容(locals调用之前的变量)
z3 = 3
print(dic) ##{'z1': 1, 'z2': 2}
z4 = 4
func()
a = 1
b = 2
c = 3
'''
#当前作用域在局部空间，获取的是调用之前所有的全局变量
'''
def func():
z1 = 1
z2 = 2
dic = globals()
z3 = 3
print(dic)
z4 = 4
a = 3
b = 2333
func() ## 'func': <function func at 0x043245D0>, 'a': 3, 'b': 2333}
'''
###利用globals穿件全局变量
#globals返回的是系统的一个全局变量的字典，在系统的这个全局字典中添加 键值对 ，就等同于穿件全局变量
'''
dic = globals()
#print(dic,type(dic))
#利用字符串创建变量
dic['wangwang'] = '大好人' #所有塞进全局变量名的键
print(wangwang) #哪怕这里有提示错误提示都是能打印的
print(dic) #可以通过打印dic来判断是否有wangwang这个全局变量
'''
###批量创建全局变量
'''
def func(num):
dic = globals()
for i in range(num):
dic['a%d'%i] = (i+1)
func(7)
print(a0,a1,a2,a3,a4,a5,a6) #哪怕这里有提示错误提示都是能打印的 ##1 2 3 4 5 6
'''
###dir()
#如果print(dir(变量))里面有‘__iter__ ’就是一个可遍历数据
#判断是否是可迭代性数据
'''
res = '__iter__' in lst
print(res)
'''
#for循环之所以迭代所有可迭代数据的原因，底层依靠的就是迭代器，迭代器利用next方法，依靠指针地址寻址的方式，找到一个个数据，遍历出来
#创建一个迭代器
### it = iter(变量)
### it= 变量.__iter__ #得到一个内存地址
### 判断一个迭代器
'''
lst=[1,2,3,4,5]
#创造一个迭代器
it = iter(lst)
#判断一个迭代器
lst = dir(it)
print(lst) #得到一个功能说明 ##['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__length_hint__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']
res = '__iter__' in lst and '__next__' in lst
print(res) ##True
'''
#如果是可迭代对象，不一定是迭代器
#如果是迭代器，一定是可迭代对象
#可迭代对象~~迭代器:从不能直接获取数据，到可直接获取数据的过程（通过next指针，地址寻址的方法找数据）
##如何使用迭代器
#使用next调用数据时，每次只取一个，而且一条路走到黑，不能回头，基于上一个数据往下迭代
'''
a = [1,2,3,4,5,6]
b = iter(a)
print(dir(b)) #查内置函数 ##['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__length_hint__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']
res = next(iter(b))
print(res) ##1
res = next(iter(b))
print(res) ##2
res = next(iter(b))
print(res) ##3
res = next(iter(b))
print(res) ##4
res = next(iter(b))
print(res) ##5
res = next(iter(b))
print(res) ##6
res = next(iter(b))
print(res) ##报错：StopIteration
##重置迭代器
it = iter(a) ##重新再定义一个
'''
##其他方式
##判断迭代器的方式
'''
lst = [1,2,3,4]
it = iter(lst)
from collections import Iterator,Iterable
print(isinstance(it,Iterator)) ##True
#Iterator 迭代器类型
#Iterable 可迭代性对象
'''
######## 装饰器 ################
#原函数功能不足，用装饰器丰富原函数，（个人理解是：指向地址改变了？？？）
'''
定义：
def decotator(func):
def xxx(参数)：
...
func()
return yyy
return xxx #这是一个闭包
装饰：
@装饰器名 ------》原函数 = 装饰（原函数）
def 原函数():
....
原函数()
'''
'''
def decorater(func):
def zhuangxiu():
func()
print('吊天花')
print('铺地砖')
print('买家具')
return zhuangxiu
@decorater
def house():
print('新毛坯房')
house() #新毛坯房
#吊天花
#铺地砖
#买家具
'''
###########高阶函数############
#能把函数当成参数传递的就是高阶函数（map,reduce,filter,sorted）
###map
#格式：map(func,iterable)
#功能：一般用于处理数据，把Iterable中的数据一个个拿出来，扔到func函数中做处理，把处理的结果用迭代器获取出来
#参数：
#(1)func 自定义函数/内置函数
#(2)Iterable 可迭代性数据（容器类型数据，range对象，迭代器）
#返回值：迭代器
#只有在调用迭代器的时候，才会真正的执行map函数
'''
###正常的写法
lst = ['1','2','3']
lst_new=[]
for i in lst:
res = int(i)
lst_new.append(res)
print(lst_new) #[1, 2, 3]
###如果是map函数
it=map(int,lst)
for i in it:
print(i,type(i)) #只有在调用迭代器的时候，才会真正的执行map函数 ##1 <class 'int'> ## 2 <class 'int'> ##3 <class 'int'>
'''
#next
'''
lst = ['1','2','3']
it=map(int,lst)
res =next(it)
print(res)
res =next(it)
print(res)
res =next(it)
print(res)
'''
#函数实现
'''
lst = [1,2,3]
def func(n):
return n<<n #a<<b=a∗(2)b
it = map(func,lst)
print(list(it)) ##[2, 8, 24]
'''
##翻转字典键值对
'''
dic = {97:'a',98:'b',99:'c'}
lst = ['a','b','c']
dic_new = {}
lst_new = []
###map改造
def func(n):
print(n)
#翻转字典键值对
for k,v in dic.items():
dic_new[v]=k
print(dic_new)
return dic_new[n]
it=map(func,lst)
print(list(it))
'''
################# reduce ############
#格式： reduce(func,iterable)
#功能：
#先把iterable里面的前两个数据拿到func函数当中进行运算，得到结果再把计算的结果和iterable中的第三个数据拿到func里面进行运算，依次类推，直到iterable里面的所有数据都拿完位置，程序结束
#参数：
#func 内置或自定义函数
#iterable具有可迭代性的数据([迭代器iterator][容器类型的数据][range对象])
#返回值：计算的最后结果
#把[5,4,8,8] 变成 5488
'''
lst = [5,4,8,8]
#方法一
strvar= ''
for i in lst:
strvar += str(i)
intvar = int(strvar)
print(intvar,type(intvar))
#方法二
it= iter(lst)
num1 = next(it)
num2 = next(it)
total = num1*10+num2
print(total)
for i in it:
total = total*10+i
print(total,type(total))
#reduce 改写
from functools import reduce
def func(x,y):
return x*10+y
res = reduce(func,lst)
print(res,type(res))
#用lambda表达式做简化
res = reduce(lambda x,y:x*10+y,lst)
print(res)
'''
############### sorted ##############
#格式： sorted(iterable,reverse=False|True,key=函数)
#功能： 对数据进行排序
#参数：
#iterable:具有可迭代性的数据（迭代器，容器类型数据，可迭代对象）
#reverse：是否反转 默认为False 代表正序 改成True为倒序
#key:函数内置或自定义函数
#返回值： 返回排序后的数据
#sorted
'''
#默认从小到大
tup = (100,89,1,98)
print(sorted(tup))
#从大到小
tup = (100,89,1,98)
print(sorted(tup,reverse=True))
#按照绝对值排序,abs（内置函数）
tup = (-100,-89,1,98)
lst = sorted(tup,key=abs)
print(lst)
#安照余数进行排序 自定义函数
tup =[19,25.41,62]
def func(n):
return n%10
lst = sorted(tup,key=func)
print(lst)
#lambda表达式
lst = sorted(tup,key=lambda n:n%10)
'''
#sorted 可以排序任意类型的可迭代性数据
#sorted 和 sort 功能一致
#区别 sorted：可排序所有容器类型数据，排序完之后，返回一个新的列表
#sort :只排序列表
#：直接对原列表做排序，没有返回None
################### filter #####################
#格式： filter(func,iterable)
#功能: 用来过滤的，如果func函数中返回True，会将这个值保留到迭代器中，如果func函数中返回False，会将此值舍弃不保留
#参数：
#func:自定义函数
#iterable：具有可迭代性的数据（迭代器，容器类型数据，可迭代对象）
#返回值：
#迭代器
#filter
'''
lst = [1,2,3,4,5,6]
def func(n):
if n%2 == 0:
return True
else:
return False
it = filter(func,lst)
print(list(it))
###假如使用lambda改造
it = filter(lambda n:True if n%2 ==0 else False,lst)
print(list(it))
'''
##### 推导式 #####
#通过一行循环判断，遍历出一系列数据的方式是推导式
#语法：val for val in Iterable(把想要的值卸载for左侧)
#里面是一行循环判断，根据套在推导式外层的符号判断具体是什么类型的推导式
#推导式：
#[val for val in Iterable] #列表推导式
#{val for val in Iterable} #集合推导式
#{k:y for k,v in Iterable} #字典推导式
#1，推导式的基本写法
#lst = [i for i in range(1,5)]
#2,带有判断条件的推导式
#lst =[i for i in rang(1,5) if i % 2 == 0]
#3,带有循环函套的推导式
#lst = [i+j for i in lst1 for j in lst2]
#print(lst)
#4,带有判断条件的循环函套推导式
'''
lst1 = ['1','2','3','4','5']
lst2 = ['a','b','c','d','e']
lst = []
for i in lst1:
for j in lst2:
if lst1.index(i) == lst2.index(j):
strvar = i +'*'+ j
lst.append(strvar)
print(lst) ##['1*a', '2*b', '3*c', '4*d', '5*e']
#推导式写法
lst = [i+'*'+j for i in lst1 for j in lst2 if lst1.index(i) == lst2.index(j)]
print(lst) ##['1*a', '2*b', '3*c', '4*d', '5*e']
'''
#####生成器######
#生成器本质是迭代器，允许自定义逻辑的迭代器
#迭代器和生成器区别：
#迭代器本身是系统内置的，重写不了，而生成器是用户自定义的可以重写迭代逻辑
#1，基本语法
#格式：(i for i in range(5))
#generator 生成器
#生成器函数(用def定义，里面含有yield)
#yield 类似于return
#共同点在于：执行到这句话会把值返回出去
#不同点在于：yield每次返回时，会记住上次离开时执行的位置，下次在调用生成器会从上次执行的位置往下走
#而return 直接终止函数，每次重头调用
#yield 6 和 yield(6) 2种写法都可以
#基本使用
'''
def mygen():
print('one')
yield 111
print('two')
yield 222
print('three')
yield 333
res = mygen()
print(next(res)) ##one
print(next(res)) ##two
print(next(res)) ##three
'''
#优化代码
#切记再迭代器生成器的环节中，一般处理的都是大数据，不要试图一下子获取生成器中的所有数据，可能造成死循环的效果
#自定义生成器
'''
def mygen():
for i in range(1,101):
yield '球衣号码为{}'.format(i)
#初始化生成器对象gen，简称生成器
gen = mygen()
#先获取30个号码
for i in range(30):
print(next(gen))
#再获取30个号码
for i in range(30):
print(next(gen))
'''
#send的使用 该段需要重新看视频，完全理解不了意思！！！！！！！！！！！！！！！！！！
#next和send
#next 只能取值
#send 不但能取值，还能发送值
#send注意点：
#第一个send不能给 yeld 传值，默认只能写None
#第二个yield接收不到send的发送值
#初始化生成器函数~生成器对象~简称生成器
#gen = mygen
#第一次调用send时，因为代码还没有执行，默认发送None
#res = gen.send(None) #next(gen)
#第二次调用send，发送'aaa'
'''
res = gen.send('aaa')
print(res,'外部')
'''
#斐波那契数列
#就是'1,1,2,3,5,8,13,21,34......'
'''
def mygen(maxvalue):
a,b = 0,1
i = 0
while i < maxvalue:
print(b) #yield b
a,b = b,a+b
i+=1
gen= mygen(10)
'''
########### 正则表达式定义和作用##################(已经掌握了)
#http://tool.chinaz.com/regex/
#import re
'把字符串按照正则表达式匹配出来，返回到列表'
#re.findall('正则表达式','字符串')
#例子: \d匹配数字
'''
import re
strvar = '3333'
lst = re.findall('\d',strvar)
print(lst)
'''
####
'''
. 匹配任意字符串，除了换行符\n
\d 匹配数字
\D 匹配非数字
\w 匹配或数字或下划线(正则函数中，支持中文的匹配)
\W 匹配费字母或数字或下划线
\s 匹配任意空白符
\S 匹配任意的非空白符
\n 匹配换行符
\t 匹配制表符
[] 匹配中括号内列举的字符
？ 重复0次或1次
+ 至少1次
* 任意次
{n} 重复{n}
{n,} 至少n次
{n，m}重复n到m次
.* .+贪婪模式匹配
.*？ .+？ 非贪婪模式匹配
'''
#分组
#正常分组
#1正常情况下用()圆括号进行分组
#可以用\1反向引用第一个圆括号匹配的内容
'''
import re
strvar = '34456789'
lst = re.findall('(\d)\\1',strvar)
print(lst) ##['4']
'''
#(?:正则表达式)表示取消优先显示的功能
#(正则表达式)代表分组findall把所有分组的内容显示到列表里
#(?:正则表达式)代表分组findall把所有分组的内容不显示到列表里
'''
import re
out = re.findall(r'\d+(?=abc)',"1abc") ## 只抽取数字，并且该数字后面跟的字符是"abc"
print(out)
out1 = re.findall(r'\d+(?!abc)',"1abf") ## 只抽取数字，并且该数字后面跟的字符是"abc"
print(out1)
out3 = re.findall("A(?:\d{1,2}月)?D", "啊啊A22月DtttADgggg") ## 目的是抽取以A开头和D结尾的字符串
print(out3)
'''
#obj = re.search(正则表达式，字符串)
#对象.group()获取匹配到的第一个内容返回
#对象.groups()获取所有括号里面的内容
#对象.group() 括号内默认第一个索引，可填写索引
#findall和search的区别
#findall 功能是找到所有匹配到的数据，返回列表
#匹配内容和分组内容不能同时显示
#search功能是找到第一个匹配到的内容，返回对象
#匹配内容和分组内容可以同时显示
#############递归函数###################
#递归函数:自己调用自己的函数
#递：去
#归：回
#一去一回是递归
#基本写法：
'''
def digui(n):
#print(n)
if n > 1:
digui(n-1)
print(n)
digui(5)
'''
递归案例 求excel_data 中合计数为50的组合
excel_data = [10,11,16,17,20,18,1,10]
target_count = 50
def get_sum_count(data,sum_count):
result = []
for i in range(len(data)):
if data[i] == sum_count:
result.append([data[i]])
elif data[i] < sum_count:
for j in get_sum_count(data[i+1:],sum_count-data[i]):
result.append([data[i]]+j)
return result
res = get_sum_count(excel_data,target_count)
print(res)
###################OS模块-对系统进行操作##########################
######import ###################
###from xxx import xxx ######
##from xxx.xxx import xxx ########
'''
system() 在python中执行系统命令
popen() 执行系统命令返回对象，通过read方法读出字符串
listdir() 获取指定文件夹中所有内容的名称列表
getcwd() 获取当前文件所在的默认路径
chdir() 修改当前文件工作的默认路径
environ 获取或修改环境变量
--os 模块属性 ？？？
name 获取系统标识 linux，mac~~~~~~~posix
windows ~~~~~~~~~nt
sep 获取路径分割符号 linux，mac~~~~~~~ /
windows ~~~~~~~~~ \
linesep 获取系统的换行符 ##linux，mac \n ##window \r\n 或 \n
'''
###############OS路径模块 -os.path#########################
'''
basename() 返回文件名部分
dirname() 返回路径部分
split() 将路径拆分成单独的文件部分和路径部分 组合成一个元组
join() 将多个路径和文件组合成新的路径，可以自动通过不同的系统加不同的斜杠 linux / windows \
splitext() 将路径分割为后续和其他部分
getsize() 获取文件的大小
isdir() 检测路径是否是一个文件夹
isfile() 检测路径是否是一个文件
islink() 检查路径是否是一个链接
getctime() [windows]文件的创建时间，[linux]权限的改动时间（返回时间戳）
getatime() 获取文件最后一次访问时间（返回时间戳）
exisits() 检查指定的路径是否存在
isabs() 检查一个路径是否是绝对路径
abspath() 将相对路径转化为绝对路径
'''
#############os与shutil模块##################
'''
os模块具体有 新建/删除
os.mknod 创建文件
os.remove 删除文件
os.mkdir 创建目录（文件夹）
os.rmdir 删除目录（文件夹）
os.rename 对文件，目录重命名
os.makedirs 递归穿件文件夹
os.removedirs 递归删除文件夹（空文件夹）
'''
##############shutil模块####################
'''
copyfileobj(fsrc,fdst,[length = 16*1024]) 完全看不懂，需要重看！！！！！！！！！！！！
#复制文件（length的单位是字符（表达一次读多少字符））
copyfile(src,dst) #单纯的仅复制
#文件内容,底层调用了 copyfileobj
copymode(src,dst)#单纯的仅复制文件权限，不包括内容（虚拟机共享目录都是默认777）
copystat(src,dst)#复制所有状态信息，包括权限，组，用户，修改时间等，不包括内容
copy(src,dst)#复制文件权限和内容
copy2(src,dst)#复制文件权限和内容，还包括权限，组，用户，时间等
copytree(src,dst)#拷贝文件里的所有内容（递归拷贝）
rmtree(path)#删除当前文件夹及其中所有内容(递归删除)
move(path1,path2)#移动文件或文件夹
'''
##############json模块##################
#所有编程语言都能够识别的数据格式叫做json，是字符串
'''
dumps 把任意对象序列化成一个str
loads 把任意str反序列化成原来的数据
dump 把对象序列化后写入到file-likeobject（即文件对象）
load 把file.likeobject(即文件对象)中的内容拿出来，反序列化成原来数据
json和pickle两个模块的区别：
json序列化之后的数据类型是str，所有编程语言都能识别
但是仅限于（int，float，bool）（str，list，tuple，dictionary，None）
json不能连续load，只能一次性拿出所有数据
pickle序列化之后的数据类型是bytes
所有数据类型都可转化，但仅限于python之间的存储传输
pickle可以连续load，多套数据放到同一个文件中
'''
#############压缩模块zipfile（后缀为zip）
'''
zipfile.zipfile([file[,mode[,compression[,allowZip64]]])
ZipFile(路径包名,模式,压缩or解包,可迭allowZip64)
功能：创建一个ZipFile对象，表示一个zip文件
参数：参数file表示文件的路径或类文件对象（file-like object）
参数mode指示打开zip文件的模式，默认值为r
r表示读取已经存在的zip文件
w表示新建一个zip文档或覆盖一个已经存在的zip文档
a表示将数据追加到一个现有的zip文档中
参数compression表示在写zip文档时使用的压缩方法
zipfile.ZIP_STORED
只是存储模式，不会对文件进行压缩，这个是默认值
zipfile.ZIP_DEFLATE
对文件进行压缩
如果要操作的ZIP文件大小超过2G应该将allowZip64设置为True
'''
#压缩文件
#1，ZipFile()
#写模式w打开或者新建压缩文件
#2，write(路径，别名)
#向压缩文件中添加文件内容
#3，close()
#关闭压缩文件
#解压文件
#1，ZipFile()读模式r打开压缩文件
#2，extractall(路径)
#解压所有文件到某个路径下
#extract(文件，路径)
#解压指定的某个文件到某个路径下
#3，close()
#关闭压缩文件
#追加文件(支持with写法)
#ZipFile() 追加模式a打开压缩文件
#查看压缩包中的内容
#namelist()
#压缩模块 - tarfile(后缀为.tar|.tar.gz|tar.bz2)
#bz2模式的压缩文件较小根据电脑的不同会产生不同的结果（理论上:bz2压缩之后更小，按实际情况为标准）
'''
w 单纯的套一个后缀打包
w:bz2 采用bz2算法压缩
w:gz 采用bz算法压缩
'''
#压缩文件
#1,open('路径包名','模式','字符编码')创建或者打开文件
#2，add(路径文件，arcname='别名')向压缩文件中添加文件
#3，close()关闭文件
#解压文件
#1,open('路径包名','模式','字符编码')创建或者打开文件
#2,extractall(路径)解压所有文件到某路径下
#extract(文件，路径)解压指定的某个文件到某个路径下
#3，close()关闭压缩文件
#追加文件
#open() 追加模式a： 打开压缩文件正常添加即可
#查看压缩包中的内容
#getnames()
#序列化模块 - pickle
#dumps 把任意对象序列化成一个bytes
#loads 把任意bytes反序列化成原来数据
#dump 把对象序列化后写入到file-like object（即文件对象）
#load 把file-like Object（即文件对象）中的内容拿出来，反序列化成原来数据
#####数学模块 math ############
#ceil() 向上取整操作(对比内置round)
#floor() 向下取整操作(对比内置round)
#pow() 计算一个数值的N次方(结果为浮点数)(对比内置pow)
#sqrt() 开平方运算(结果浮点数)
#fabs() 计算一个数值的绝对值(结果也是浮点)（对比内置abs）
#modf() 将一个数值拆分为整数和小数两部分组成元祖
#copysign()将参数第二个数值的正负号拷贝给第一个(返回一个小数)
#fsum() 将一个容器数据中的数据进行求和运算(结果浮点数)(对比内置sum)
#圆周率常数pi
########随机模块 random#############
#random() 获取随机0-1之间的小数(左闭右开)
#randrange() 随机获取指定方位内的整数(包含开始值，不包含结束值间隔值)
#randint() 随机产生指定范围内的随机整数
#uniform() 获取指定范围内的随机小数（左闭右开）
#choice() 随机获取序列中的值(多选一)
#sample() 随机获取序列中的值（多选多）[返回列表]
#shuffle() 随机打乱序列中的值(直接打乱原序列)
#################时间模块 time ##################
import time
time() #获取本地时间戳
localtime()#获取本地时间元祖(参数是时间戳，默认当前)
mktime() #通过时间元祖获取时间戳（参数是时间元祖
ctime() #获取本地时间字符串(参数是时间戳，默认是当前)
asctime()#通过时间元祖获取时间字符串(参数是时间元祖)
sleep(secs) #程序睡眠等待
strftime()#格式化时间字符串(格式化字符串,时间元祖)
strptime()#将时间字符串通过指定格式提取到时间元祖中()时间字符串,格式化字符串
perf_counter()#用于计算程序运行的时间
################# 内置函数 ####################
#abs 绝对值函数
#round 四舍五入 整数部分奇进偶不进
#sum 计算一个序列的和
#max 获取一个序列里的最大值
#min 获取一个序列里的最小值
#pow 计算某个数值的X次方
#range 产生指定范围数据的可迭代对象
#bin 将10进制数据转化为二进制
#oct 将10进制转入八进制
#hex 将10进制转为16进制
#chr 将ASCII编码换位字符
#ord 将字符转为ASCII编码
#eval 将字符串当做py代码执行
#exec 将字符串当做py代码执行，没有返回值
#repr 不转义字符输出字符串
#input 接受输入字符串
#hash 生成哈希值
#例子：
'''
list = [('A',23),('B',15),('C',87),('D',34),('E',52)] ####max() 高阶函数
m = max(list,key = lambda x:x[1])
print(m) ##('C', 87)
list1 = [('A',23),('B',15),('C',87),('D',34),('E',52)] ####filter() 筛选
f = filter(lambda x : x[1] > 40, list1)
print(list(f)) ##[('C', 87), ('E', 52)]
import functools
list1 = [23,15,87,34,52,5]
f = functools.reduce(lambda x,y : x + y , list1) ##reduce 两两拿出来处理
print(f)
'''
视频的结尾好像是这样说，以上皆为基础部分
import os
os.getcwd() #得到当前工作目录，即当前python脚本工作的目录的目录路径
os.listdir() #返回指定目录下的所有文件和目录名
os.remove() #函数用来删除一个文件
os.removedirs(r'c:\python') #删除多个目录
os.path.isfile() #检验给出的路径是否是一个文件
os.path.isdir() #检验给出的路径是否是一个目录
os.path.isabs() #判断是否是绝对路径
os.path.exists() #检验给出的路径是否为真。返回布尔值
os.path.split() #返回一个路径的目录和文件名，如果最后的不是文件就是目录，得到一个长度为2的元组
os.path.splitext() #分离扩展名
os.path.dirname() #获取路径名
os.path.basename() #获取文件名
os.system() #运行shell命令
os.getenv('HOME') #读取操作系统环境变量Home的值
os.environ #返回操作系统所有的环境变量
os.environ.setdefault('HOME','/home/alex') #设置系统环境变量，仅程序运行时有效
os.linesep #给出当前平台使用的行终止符
os.name #指示你正在使用的平台，对于windows她是nt，对于linux/unix用户他是posix
os.rename(old,new) #重命名
os.makedirs(r'c:\python\test') #创建多级目录
os.mkdir('test') #创建单个目录
os.stat(file) #获取文件属性
os.chmod(file) #修改文件权限与时间戳
os.path.getsize(filename) #获取文件大小
os.path.join(dir,filename) #结合目录名与文件名
os.chdir(dirname) #改变工作目录到dirname
os.get_terminal_size() #获取当前终端的大小
os.kill(10884,signal.SIGKILL) #杀死进程
import sys
sys.path #获取系统环境变量
sys.argv #获取脚本的参数
import datetime
datetime.date(year,month,day) #表示日期的类，常用的属性有year，month，day
datetime.time(hour,minute,second,microsecond) #表示时间的类，常有的属性有hour，minute，second，microsecond
datetime.datetime() #表示日期时间
datetime.datetime.now() #返回当前的datetime日期类型 d.timestamp(),d.today(),d.year,d.timetuple()等方法可以调用
datetime.date.fromtimestamp() #把一个时间戳转为datetime日期类型
#时间运算
'''
'''
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
