推导式，集合推导式，生成器表达式及生成器函数day13
1.推导式
用一行循环判断遍历处一系列数据的方式
推导式在使用时，只能用for循环和判断，而且判断只能是单项判断
基本语法：
lst = [i for i in range(1,51)] print(lst)
普通推导式
#[1,2,3,4] => [2,8,24,64] lst = [1,2,3,4] #lst = [i*2**i for i in lst] lst = [i << i for i in lst] #左移 相当于 i*2**i print(lst)
带有条件判断的推导式
lst = [1,2,3,4,5,6,67,7,8,]
lst_new = []
for i in lst:
if i %2 == 0:
lst_new.append(i)
print(lst_new)
#推导式改写
lst = [i for i in lst if i % 2 == 0]
print(lst)
多循环推导式
lst1 = ['王振','黄俊','刘伟']
lst2 = ['魏小林','刘思敏','陈芮']
lst_new = []
for i in lst1:
for j in lst2:
res = i + '♥' + j
lst_mwe.append(res)
print(lst_new)
#推导式改写
lst = [i+'♥'+j for i in lst1 for j in lst2]
print(lst)
带有判断条件的多循环推导式
lst_new = []
for i in lst1:
for j in lst2:
if lst1.index(i) == lst2.index(j):
res = i+'♥'+j
lst_new.append(res)
print(lst_new)
#推导式改写
lst = [i+'♥'+j for i in lst1 for j in lst2 if lst1.index(i) == lst2.index(j)]
print(lst)
推导式练习：
# ### 关于推导式的练习
# (1).{'x': 'A', 'y': 'B', 'z': 'C' } 把字典写成x=A,y=B,z=C的列表推导式
dic = {'x': 'A', 'y': 'B', 'z': 'C' }
lst_new = []
#常规
for k,v in dic.items():
res = k+'='+v
lst_new.append(res)
print(lst_new)
lst = [k+'='+v for k,v in dic.items()]
#(2) 把列表中所有字符变成小写 ["ADDD","dddDD","DDaa","sss"]
#常规
lst = ["ADDD","dddDD","DDaa","sss"]
lst_new = []
for i in lst:
res = i.lower()
lst_new.append(res)
print(lst_new)
lst = [i.lower() for i in lst]
print(lst)
#(3)x是0-5之间的偶数,y是0-5之间的奇数 把x,y组成一起变成元组,放到列表当中
#方法一
lst_new = []
for x in range(6):
for y in range(6):
if x % 2 ==0 and y % 2 ==1:
res = x,y
lst_new.append(res)
print(lst_new)
#推导式
lst = [(x,y) for x in range(6) for y in range(6) if x % 2==0 and y %2 ==1]
print(lst)
#方法二
lst_new = []
for x in range(6):
if x % 2 == 0:
for y in range(6):
if y % 2 ==1:
res = x,y
lst_new.append(res)
print(lst_new)
#(4) 使用列表推导式，制作所有99乘法表中的运算
for i in range(9,0,-1):
for j in range(1,i+1):
print('{:d}*{:d}={:2d}'.format(i,j,i*j),end='')
print()
#推导式
lst = ['{:d}*{:d}={:2d}'.format(i,j,i*j) for i in range(9,0,-1) for j in range(i,i+1)]
print(lst)
# (5)#求M,N中矩阵和元素的乘积
# M = [ [1,2,3],
# [4,5,6],
# [7,8,9] ]
# N = [ [2,2,2],
# [3,3,3],
# [4,4,4] ]
# =>实现效果1 [2, 4, 6, 12, 15, 18, 28, 32, 36]
# =>实现效果2 [[2, 4, 6], [12, 15, 18], [28, 32, 36]]
M = [ [1,2,3] , [4,5,6] , [7,8,9]]
N = [ [2,2,2] , [3,3,3] , [4,4,4]]
'''
M[0][0] * N[0][0] = 2
M[0][1] * N[0][1] = 4
M[0][2] * N[0][2] = 6
M[1][0] * N[1][0] = 12
M[1][1] * N[1][1] = 15
M[1][2] * N[1][2] = 18
M[2][0] * N[2][0] = 28
M[2][1] * N[2][1] = 32
M[2][2] * N[2][2] = 36
#总结：能控制下标等于控制了最后的结果
'''
#第一个效果
lst = [M[i][j]*N[i][j] for i in range(3) for j in range(3)]
print(lst)
'''第一层循环控制外层i=0的时候，j=0,1,2'''
#第二个效果
#[[],[],[]] 通过推导式遍历出三个新列表
lst = [[] for i in range(3)]
print(lst)
'''
外层i动的慢的，里层j动的快的，所有下标M[I][J]
在拿出i的时候，里面的for循环了三遍 是在一个新的列表当中实现的
'''
lst = [[M[i][j]*N[i][j] for j in range(3)] for i in range(3)]
print(lst)
2.集合推导式
案例：
'''
案例：
满足年龄在18到21，存款大于等于5000 小于等于5500的人。
开卡格式为：尊贵VIP卡老X(姓氏)，否则开卡格式为：抠脚大汉卡老X（姓氏）
'''
listvar = [
{"name":"王家辉","age":18,"money":10000},
{"name":"王水机","age":19,"money":5100},
{"name":"王鹏","age":20,"money":4800},
{"name":"李站","age":21,"money":2000},
{"name":"李小龙","age":180,"money":20}
]
setvar = set()
for i in listvar:
if 18<= i['age'] <= 21 and 5000 <= i['money'] <=5500:
res = '尊贵VIP卡老' + i['name'][0]
else:
res = '抠脚大汉卡者' + i['name'][0]
setvar.add(res)
print(setvar)
#setvar = {三元运算符 + for i in iterable}
setvar = {"尊贵VIP卡老" + i["name"][0] if 18 <= i["age"] <= 21 and 5000 <= i["money"] <= 5500 else "抠脚大汉卡老" + i["name"][0] for i in listvar}
3.字典推导式
3.1 enumerate 函数
enumerate(iterable,[start=0])
功能：枚举，将索引号和iterable中的值，一个一个拿出来配对组成元组放入迭代器中
参数：
iterable：可迭代行数据(常用迭代器，容器数据类型，可迭代对象range)
start：可选择开始的索引号(默认从0开始索引)
返回值：迭代器
lst = ["吕洞宾","张果老","蓝采和","何仙姑","铁拐李","韩湘子","曹国舅","动感超人"]
it = enumerate(lst,start=5)
#可以设置开始是索引值 start = 5
from collections import Iterator,Iterable
res = isinstance(it,Iterable)
print(res)
#for + next 迭代所有数据
for i in range(3):
res = next(it)
print(res)
#list 强转迭代器
res = list(it)
print(res)
#1.通过推导式配合enumerate 实现
#(5,'吕洞宾')
dic = {k:v for k,v in enumerate(lst,start=1)}
print(dic)
3.2 zip函数
zip(iterable,...,...)
功能：将多个iterable中的值，一个一个拿出来配对组成元组放入迭代器中
iterable：可迭代性数据(常用：迭代器，容器类数据类型，可迭代对象range)
返回值：迭代器
特点：不能配对的多余的值会被舍弃
zip的基本使用
lst1 = ["黄俊","朱佳怡","王振","魏小林"]
lst2 = ["李博","刘伟","王颖倩"]
lst3 = ["刘思敏","陈芮"]
it = zip(lst1,lst2)
# it = zip(lst1,lst2,lst3)
print(isinstance(it,Iterator))
#用list强转，瞬间拿到里面所有数据
print(list(it)) #[('黄俊', '李博'), ('朱佳怡', '刘伟'), ('王振', '王颖倩')]
#1.使用zip配合推导式实现
dic = {k:v for k,v in zip(lst1,lst2)}
print(dic)
#通过dict 强转字典 实现
dic = dict(zip(lst1,lst2))#{'黄俊': '李博', '朱佳怡': '刘伟', '王振': '王颖倩'}
print(dic)
4.生成器
生成器本质是迭代器，允许自定义逻辑的迭代器
迭代器和生成器区别：
迭代器本身是系统内置的，重写不了，而生成器是用户自定义的，可以重写迭代逻辑
生成器可以用两个方式创建：
(1)生成器表达式(里面是推导式，外面用圆括号)
(2)生成器函数(用def定义,里面含有yield)
from collections import Iterator
#生成器表达式，定义一个生成器用元组括号就是生成器
gen = (i*2 for i in range(1,5))
print(gen)
print(isinstance(gen,Iterator))
#next调用生成器
res = next(gen)
print(res)
res = next(gen)
print(res)
res = next(gen)
print(res)
res = next(gen)
print(res)
#2.for调用生成器
gen = (i*2 for i in range(1,5))
for i in gen:
print(i)
#3.for + next 调用生成器
gen = (i*2 for i in range(1,5))
for i in range(2):
res = next(gen)
print(res)
#4.用list强转，瞬间拿到所有数据
res = list(gen)
print(res)
5.生成器函数
yield 类似于return
共同点在于：执行到这句话都会把值返回出去
不同点在于：yield每次返回时，会记住上次离开时执行的位置，下次再调用生成器，会从上一次执行的位置继续往下走下去，而return直接终止函数，每次重头调用
yield 6 和 yield(6) 2种写法都可以 yield 6更推荐使用
from collections import Iterator
(1)基本语法
def mygen():
print('one')
yield 1
print('two')
yield 2
print('three')
yield 3
初始化生成器函数，返回生成器对象，简称生成器
gen = mygen()
print(isinstance(gen,Iterator))
#第一次
res = next(gen)
print(res)
#第二次
res = next(gen)
#第三次
res = next(gen)
print(res)
解析：
第一次调用,print('one') yield 1,记录当前代码执行的状态在多少行，直接把1返回，等待一下次调用 res = 1 print(1)
第二次调用，从上一次代码的位置继续向下执行，print('two') yield 2,记录当前代码执行的状态在多少行，直接把2返回回去，等待下一次调用 res = 2 print(2)
第三次调用，从上一次代码的位置继续向下执行，print('three') yield 3,记录当前代码执行的状态在多少行，把3直接返回，等待下一次调用 res = 3 print(3)
如果在进行第四次调用，因为没有yield关键字返回数据，所以直接报错StopIteration
send 可以发送数据，发送给上一个yield
send 和 next的区别
next只能取值
send不但能取值，还能发送值
send注意点：
第一个send不能给yield传值，默认只能写None
最后一个yield接收不到send的发送值
def mygen():
print('start')
res = yield 111
print(res)
res = yield 222
print(res)
res =yield 333
print(res)
print('end')
#初始化生成器函数 -> 返回生成器对象 ->简称生成器
gen = mygen()
#第一次调用
#第一次只能默认发送None，因为第一次没有上一个yield
val = gen.send(None)
print(val)
#第二次调用
val = gen.send(444)
print(val)
#第三次调用
val = gen.send(555)
print(val)
#555
#333
#第四次调用error
#val = gen.send(666)
#print(val)
解析：
无论是next还是send都可以调用生成器里面的数据，send不但可以调用，还可以给yield发送值
第一次调用send，只能发送None，因为还没有遇到yield，代码从上到下执行，print('start') 遇到res = yield 111 记录当前代码执行的状态在多少行，把111值返回，等待一下调用外面的val=111 print(111)
第二次代用send，把444发送给上一次保存的位置行，yield进行接收res=444行往下执行，print(444) 遇到res = yield 222记录当前代码执行的状态在多少行，把222值返回，等待下一次调用，外面的val=222 print(222)
第三次调用send，把555发送给上一次保存的位置行，yield进行接收res = 555，再往下执行，print(555),遇到res = yield 333，外面的val = 333，print(333)
第四次调用send，把666发送给上一次保存的位置行，yield进行接收res = 666，再往下执行，print(666),print('end') 没有任何yield返回数据，出现StopIteration到此程序彻底结束、
yield from 将一个可迭代对象变成一个迭代器返回
def mygen():
lst = ["魏小林","陈宁波","朱胜"]
yield from lst
gen = mygen()
print(next(gen))
print(next(gen))
print(next(gen))
案例：用生成器来写一个斐波那契数列
生成器应用在大数据的场景中，按照需求依次取值，切记不要直接迭代生成器所有数据
一旦数据量较大，类似于死循环
#0 1 1 2 3 5 8 13 21 34 55 .....
def mygen(maxlength):
a = 0
b =1
i = 0
while i <maxlength:
yield b
#当前值 = 上上个值 + 上一个值
a , b = b ,a+b
i += 1
gen = mygen(50)
for i in range(30):
print(next(gen))
-------------------------------------------
个性签名：代码过万，键盘敲烂！！！
如果觉得这篇文章对你有小小的帮助的话，记得在右下角点个“推荐”哦，博主在此感谢！
