目录
一、生成器的概念
二、生成器函数的定义
1、yield和return关键字的区别和相同点
✨（1）yield和return关键字的的不同点：
✨（2）yield和return关键字的的相同点：
2、生成器函数初识
✨（1）什么是生成器函数
✨（2）生成器函数的好处
三、生成器函数初级进阶
1、从生成器中取值的两种方法
✨（1）、方法一：next方法
✨（2）、方法二：send方法
2、预激协程的装饰器
3、Python3新加的yield from
4、回顾
四、生成器函数高级进阶
1、生成器的表达式和各种推导式
✨（1）、列表推导式
✨（2）、生成器的表达式
✨（3）、字典推导式
✨（4）、集合推导式（自带结果去重功能）
2、总结
结语：
一、生成器的概念
我们知道的迭代器有两种：一种是调用方法直接返回的，比如for循环就是Python自带的迭代器，一种是可迭代对象通过执行iter方法得到的，迭代器有的好处是可以节省内存。避免将大量数据一次性取出而导致的错误和内存不足问题。
如果在某些情况下，我们也需要节省内存,就只能自己写。我们自己写的这个能实现迭代器功能的东西就叫生成器。
简而言之：生成器就是我们自己写的迭代器
我们知道的迭代器有两种：一种是调用方法直接返回的，比如for循环就是Python自带的迭代器，一种是可迭代对象通过执行iter方法得到的，迭代器有的好处是可以节省内存。避免将大量数据一次性取出而导致的错误和内存不足问题。
如果在某些情况下，我们也需要节省内存,就只能自己写。我们自己写的这个能实现迭代器功能的东西就叫生成器。
简而言之：生成器就是我们自己写的迭代器
二、生成器函数的定义
1、yield和return关键字的区别和相同点
yield是用于生成器。什么是生成器，你可以通俗的认为，在一个函数中，使用了yield来代替return的位置的函数，就是生成器。
-
✨（1）yield和return关键字的的不同点：
它不同于函数的使用方法是：函数使用return来进行返回值，每调用一次，返回一个新加工好的数据返回给你；yield不同，它会在调用生成器的时候，把数据生成object，然后当你需要用的时候，要用next()方法来取，同时不可逆。你可以通俗的叫它"轮转容器"，可用现实的一种实物来理解：水车，先yield来装入数据、产出generator object（你执行了含有yield关键字的函数，之后调用该函数不会的到返回值而是得到一个可迭代的对象"generator object"）使用next()来释放；
好比水车转动后，车轮上的水槽装入水，随着轮子转动，被转到下面的水槽就能将水送入水道中流入田里。水车这个比方太恰当不过了，就是每次有个数据要取出来，先按照顺序将数据放进水车的水槽中，当后面在调用next函数的时候相当于使用水槽的水，并且是按照水车中原来进去的顺序进行取水的（先进先出）‘
-
✨（2）yield和return关键字的的相同点：
相同点：都是返回函数执行的结果
不同点：return 在返回结果后结束函数的运行，而yield 则是让函数变成一个生成器（或者叫做可迭代对象），生成器每次产生一个值（yield语句），函数被冻结，被唤醒后再产生一个值
用一个栗子总结:
def f1():
return 'aaa'
return 'bbb'
def f2():
yield 'aaa'
yield 'bbb'
print(f1())
print(f2())
for i in f2():
print(i)
输出结果：
aaa
aaa
bbb
2、生成器函数初识
-
✨（1）什么是生成器函数
一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。
简而言之就是函数内部含有yield关键字的就是生成器函数
-
✨（2）生成器函数的好处
生成器有什么好处就是不会一下子在内存中生成太多数据，而是你找它要它才给你值，你不向它要它也不会返回值给你。
举个栗子：
假如我预定了2000000件秋装服，我和工厂一说，工厂应该是先答应下来，然后再去生产，我可以一件一件的要，也可以一批一批的找工厂拿。而不能是一说要生产2000000件衣服，工厂一次性生产2000000件衣服在一起给我，等回来做好了，都冬天了。。。
def produce():
"""生产衣服"""
for i in range(2000000):
yield "生产了第%s件衣服"%i
product_g = produce()
print(product_g.__next__()) #要一件衣服
print(product_g.__next__()) #再要一件衣服
print(product_g.__next__()) #再要一件衣服
num = 0
for i in product_g: #要一批衣服，比如5件
print(i)
num +=1
if num == 5:
break
#到这里我们找工厂拿了8件衣服，我一共让我的生产函数(也就是produce生成器函数)生产2000000件衣服。
#剩下的还有很多衣服，我们可以一直拿，也可以放着等想拿的时候再拿
三、生成器函数初级进阶
1、从生成器中取值的两种方法
✨（1）、方法一：next方法
def generator():
print(123)
yield 1
print(456)
yield 2
g1 = generator() #生成器g1
g2 = generator() #生成器g2
print('*',g1.__next__()) #从生成器g1中取第一个值
print('**',g1.__next__()) #从生成器g1中取第二个值
print('***',g2.__next__()) #从生成器g2中取第一个值
输出结果：
123
* 1
456
** 2
123
*** 1
✨（2）、方法二：send方法
- send 获取下一个值的效果和next基本一致
只是在获取下一个值的时候给上一个yield的位置传递了一个数据
- 使用send的注意事项：
- 第一次使用生成器时候是用next获取下一个值
- 最后一个yield不能接收外部的值
总结：
send：不能用在第一个，取下一个值的时候给上一个位置传一个新的值
def generator():
print(123)
content = yield 1
print('=======',content)
print(456)
yield 2
#send 获取下一个值的效果和next基本一致
#只是在获取下一个值的时候，给上一yield的位置传递一个数据
#使用send的注意事项
# 第一次使用生成器的时候 是用next获取下一个值
# 最后一个yield不能接受外部的值
g = generator()
print('*',g.__next__())
ret = g.send('hello') #send的效果与next一样
print('***',ret)
输出结果：
123
* 1
======= hello
456
*** 2
2、预激协程的装饰器
什么是预激协程的装饰器？
简单来说就是个加了装饰器的生成器（装饰器介绍）
预激协程的装饰器的实例：
#实际上就是省略了avg_g = average() avg_g.__next__()这两步
def init(func): #func = average
'''
装饰器函数
:param func:
:return:
'''
def inner(*args,**kwargs):
g = func(*args,**kwargs) #g = average()
g.__next__()
return g
return inner
@init #average = init(average) = inner
def average():
sum = 0
count = 0
avg = 0
while 1:
#num = yield
num = yield avg
sum += num
count += 1
avg = sum/count
avg_g = average() #===>inner
ret = avg_g.send(10)
print(ret)
# avg_g.__next__()
# avg1 = avg_g.send(10)
# avg2 = avg_g.send(20)
# print(avg1,avg2)
输出结果：
10.0
3、Python3新加的yield from
yield from: 后接列表、生成器、协程。与asyncio.coroutine同时使用，定义协程函数。在python3.5以后改成了await。当yield from后面是IO耗时操作的时候，会切换至另一个yield from。
在这我们简单来说：yield可以在函数中代替for循环对返回的数据进行迭代
def generator():
a = 'ab'
b = '12'
for i in a:
yield i
for i in b:
yield i
g = generator() 从生成器中取返回值
for i in g:
print(i)
输出结果：
a
b
1
2
def generator():
a = 'cd'
b = '34'
yield from a # ,b只能有一个变量
yield from b
g = generator() #从生成器中取返回值
for i in g:
print(i)
输出结果：
c
d
3
4
4、回顾
回顾：
一、send：
1、send的作用范围和next一模一样（从一个yield作用到下一个yield）
2、第一次不能使用send
3、函数在的最后一个yield不能接收新的值
二、
预激生成器的装饰器的例子
四、生成器函数高级进阶
1、生成器的表达式和各种推导式
✨（1）、列表推导式
模板：
[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历后挨个处理
[满足条件的元素进行相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能
egg_list = ['鸡蛋%s'%i for i in range(10)] #这是个列表推导式
print(egg_list)
'''相当于'''
egg_list = []
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)
print([i for i in range(10)])
输出结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
✨（2）、生成器的表达式
- 生成器表达式（generator expression）也叫生成器推导式或生成器解析式，用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。
- 与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，不能再次访问
- 已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象，enumerate、filter、map、zip等其他迭代器对象也具有同样的特点。
g = (i for i in range(10))
print(g) #返回了一个生成器
for i in g:
print(i)
输出结果：
at 0x000002075E40FC10>
0
1
2
3
4
5
6
7
8
9
✨（3）、字典推导式
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
✨（4）、集合推导式（自带结果去重功能）
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
yield是用于生成器。什么是生成器，你可以通俗的认为，在一个函数中，使用了yield来代替return的位置的函数，就是生成器。
✨（1）yield和return关键字的的不同点：
它不同于函数的使用方法是：函数使用return来进行返回值，每调用一次，返回一个新加工好的数据返回给你；yield不同，它会在调用生成器的时候，把数据生成object，然后当你需要用的时候，要用next()方法来取，同时不可逆。你可以通俗的叫它"轮转容器"，可用现实的一种实物来理解：水车，先yield来装入数据、产出generator object（你执行了含有yield关键字的函数，之后调用该函数不会的到返回值而是得到一个可迭代的对象"generator object"）使用next()来释放；
好比水车转动后，车轮上的水槽装入水，随着轮子转动，被转到下面的水槽就能将水送入水道中流入田里。水车这个比方太恰当不过了，就是每次有个数据要取出来，先按照顺序将数据放进水车的水槽中，当后面在调用next函数的时候相当于使用水槽的水，并且是按照水车中原来进去的顺序进行取水的（先进先出）‘
✨（2）yield和return关键字的的相同点：
相同点：都是返回函数执行的结果
不同点：return 在返回结果后结束函数的运行，而yield 则是让函数变成一个生成器（或者叫做可迭代对象），生成器每次产生一个值（yield语句），函数被冻结，被唤醒后再产生一个值用一个栗子总结:
def f1(): return 'aaa' return 'bbb' def f2(): yield 'aaa' yield 'bbb' print(f1()) print(f2()) for i in f2(): print(i) 输出结果： aaaaaa bbb
2、生成器函数初识
-
✨（1）什么是生成器函数
一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。
简而言之就是函数内部含有yield关键字的就是生成器函数
-
✨（2）生成器函数的好处
生成器有什么好处就是不会一下子在内存中生成太多数据，而是你找它要它才给你值，你不向它要它也不会返回值给你。
举个栗子：
假如我预定了2000000件秋装服，我和工厂一说，工厂应该是先答应下来，然后再去生产，我可以一件一件的要，也可以一批一批的找工厂拿。而不能是一说要生产2000000件衣服，工厂一次性生产2000000件衣服在一起给我，等回来做好了，都冬天了。。。
def produce():
"""生产衣服"""
for i in range(2000000):
yield "生产了第%s件衣服"%i
product_g = produce()
print(product_g.__next__()) #要一件衣服
print(product_g.__next__()) #再要一件衣服
print(product_g.__next__()) #再要一件衣服
num = 0
for i in product_g: #要一批衣服，比如5件
print(i)
num +=1
if num == 5:
break
#到这里我们找工厂拿了8件衣服，我一共让我的生产函数(也就是produce生成器函数)生产2000000件衣服。
#剩下的还有很多衣服，我们可以一直拿，也可以放着等想拿的时候再拿
三、生成器函数初级进阶
1、从生成器中取值的两种方法
✨（1）、方法一：next方法
def generator():
print(123)
yield 1
print(456)
yield 2
g1 = generator() #生成器g1
g2 = generator() #生成器g2
print('*',g1.__next__()) #从生成器g1中取第一个值
print('**',g1.__next__()) #从生成器g1中取第二个值
print('***',g2.__next__()) #从生成器g2中取第一个值
输出结果：
123
* 1
456
** 2
123
*** 1
✨（2）、方法二：send方法
- send 获取下一个值的效果和next基本一致
只是在获取下一个值的时候给上一个yield的位置传递了一个数据
- 使用send的注意事项：
- 第一次使用生成器时候是用next获取下一个值
- 最后一个yield不能接收外部的值
总结：
send：不能用在第一个，取下一个值的时候给上一个位置传一个新的值
def generator():
print(123)
content = yield 1
print('=======',content)
print(456)
yield 2
#send 获取下一个值的效果和next基本一致
#只是在获取下一个值的时候，给上一yield的位置传递一个数据
#使用send的注意事项
# 第一次使用生成器的时候 是用next获取下一个值
# 最后一个yield不能接受外部的值
g = generator()
print('*',g.__next__())
ret = g.send('hello') #send的效果与next一样
print('***',ret)
输出结果：
123
* 1
======= hello
456
*** 2
2、预激协程的装饰器
什么是预激协程的装饰器？
简单来说就是个加了装饰器的生成器（装饰器介绍）
预激协程的装饰器的实例：
#实际上就是省略了avg_g = average() avg_g.__next__()这两步
def init(func): #func = average
'''
装饰器函数
:param func:
:return:
'''
def inner(*args,**kwargs):
g = func(*args,**kwargs) #g = average()
g.__next__()
return g
return inner
@init #average = init(average) = inner
def average():
sum = 0
count = 0
avg = 0
while 1:
#num = yield
num = yield avg
sum += num
count += 1
avg = sum/count
avg_g = average() #===>inner
ret = avg_g.send(10)
print(ret)
# avg_g.__next__()
# avg1 = avg_g.send(10)
# avg2 = avg_g.send(20)
# print(avg1,avg2)
输出结果：
10.0
3、Python3新加的yield from
yield from: 后接列表、生成器、协程。与asyncio.coroutine同时使用，定义协程函数。在python3.5以后改成了await。当yield from后面是IO耗时操作的时候，会切换至另一个yield from。
在这我们简单来说：yield可以在函数中代替for循环对返回的数据进行迭代
def generator():
a = 'ab'
b = '12'
for i in a:
yield i
for i in b:
yield i
g = generator() 从生成器中取返回值
for i in g:
print(i)
输出结果：
a
b
1
2
def generator():
a = 'cd'
b = '34'
yield from a # ,b只能有一个变量
yield from b
g = generator() #从生成器中取返回值
for i in g:
print(i)
输出结果：
c
d
3
4
4、回顾
回顾：
一、send：
1、send的作用范围和next一模一样（从一个yield作用到下一个yield）
2、第一次不能使用send
3、函数在的最后一个yield不能接收新的值
二、
预激生成器的装饰器的例子
四、生成器函数高级进阶
1、生成器的表达式和各种推导式
✨（1）、列表推导式
模板：
[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历后挨个处理
[满足条件的元素进行相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能
egg_list = ['鸡蛋%s'%i for i in range(10)] #这是个列表推导式
print(egg_list)
'''相当于'''
egg_list = []
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)
print([i for i in range(10)])
输出结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
✨（2）、生成器的表达式
- 生成器表达式（generator expression）也叫生成器推导式或生成器解析式，用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。
- 与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，不能再次访问
- 已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象，enumerate、filter、map、zip等其他迭代器对象也具有同样的特点。
g = (i for i in range(10))
print(g) #返回了一个生成器
for i in g:
print(i)
输出结果：
at 0x000002075E40FC10>
0
1
2
3
4
5
6
7
8
9
✨（3）、字典推导式
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
✨（4）、集合推导式（自带结果去重功能）
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
-
✨（1）什么是生成器函数
一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。
简而言之就是函数内部含有yield关键字的就是生成器函数
-
✨（2）生成器函数的好处
生成器有什么好处就是不会一下子在内存中生成太多数据，而是你找它要它才给你值，你不向它要它也不会返回值给你。
举个栗子：
假如我预定了2000000件秋装服，我和工厂一说，工厂应该是先答应下来，然后再去生产，我可以一件一件的要，也可以一批一批的找工厂拿。而不能是一说要生产2000000件衣服，工厂一次性生产2000000件衣服在一起给我，等回来做好了，都冬天了。。。
def produce():
"""生产衣服"""
for i in range(2000000):
yield "生产了第%s件衣服"%i
product_g = produce()
print(product_g.__next__()) #要一件衣服
print(product_g.__next__()) #再要一件衣服
print(product_g.__next__()) #再要一件衣服
num = 0
for i in product_g: #要一批衣服，比如5件
print(i)
num +=1
if num == 5:
break
#到这里我们找工厂拿了8件衣服，我一共让我的生产函数(也就是produce生成器函数)生产2000000件衣服。
#剩下的还有很多衣服，我们可以一直拿，也可以放着等想拿的时候再拿
1、从生成器中取值的两种方法
✨（1）、方法一：next方法
def generator():
print(123)
yield 1
print(456)
yield 2
g1 = generator() #生成器g1
g2 = generator() #生成器g2
print('*',g1.__next__()) #从生成器g1中取第一个值
print('**',g1.__next__()) #从生成器g1中取第二个值
print('***',g2.__next__()) #从生成器g2中取第一个值
输出结果：
123
* 1
456
** 2
123
*** 1
✨（2）、方法二：send方法
- send 获取下一个值的效果和next基本一致
只是在获取下一个值的时候给上一个yield的位置传递了一个数据
- 使用send的注意事项：
- 第一次使用生成器时候是用next获取下一个值
- 最后一个yield不能接收外部的值
总结：
send：不能用在第一个，取下一个值的时候给上一个位置传一个新的值
def generator():
print(123)
content = yield 1
print('=======',content)
print(456)
yield 2
#send 获取下一个值的效果和next基本一致
#只是在获取下一个值的时候，给上一yield的位置传递一个数据
#使用send的注意事项
# 第一次使用生成器的时候 是用next获取下一个值
# 最后一个yield不能接受外部的值
g = generator()
print('*',g.__next__())
ret = g.send('hello') #send的效果与next一样
print('***',ret)
输出结果：
123
* 1
======= hello
456
*** 2
2、预激协程的装饰器
什么是预激协程的装饰器？
简单来说就是个加了装饰器的生成器（装饰器介绍）
预激协程的装饰器的实例：
#实际上就是省略了avg_g = average() avg_g.__next__()这两步
def init(func): #func = average
'''
装饰器函数
:param func:
:return:
'''
def inner(*args,**kwargs):
g = func(*args,**kwargs) #g = average()
g.__next__()
return g
return inner
@init #average = init(average) = inner
def average():
sum = 0
count = 0
avg = 0
while 1:
#num = yield
num = yield avg
sum += num
count += 1
avg = sum/count
avg_g = average() #===>inner
ret = avg_g.send(10)
print(ret)
# avg_g.__next__()
# avg1 = avg_g.send(10)
# avg2 = avg_g.send(20)
# print(avg1,avg2)
输出结果：
10.0
3、Python3新加的yield from
yield from: 后接列表、生成器、协程。与asyncio.coroutine同时使用，定义协程函数。在python3.5以后改成了await。当yield from后面是IO耗时操作的时候，会切换至另一个yield from。
在这我们简单来说：yield可以在函数中代替for循环对返回的数据进行迭代
def generator():
a = 'ab'
b = '12'
for i in a:
yield i
for i in b:
yield i
g = generator() 从生成器中取返回值
for i in g:
print(i)
输出结果：
a
b
1
2
def generator():
a = 'cd'
b = '34'
yield from a # ,b只能有一个变量
yield from b
g = generator() #从生成器中取返回值
for i in g:
print(i)
输出结果：
c
d
3
4
4、回顾
回顾：
一、send：
1、send的作用范围和next一模一样（从一个yield作用到下一个yield）
2、第一次不能使用send
3、函数在的最后一个yield不能接收新的值
二、
预激生成器的装饰器的例子
四、生成器函数高级进阶
1、生成器的表达式和各种推导式
✨（1）、列表推导式
模板：
[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历后挨个处理
[满足条件的元素进行相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能
egg_list = ['鸡蛋%s'%i for i in range(10)] #这是个列表推导式
print(egg_list)
'''相当于'''
egg_list = []
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)
print([i for i in range(10)])
输出结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
✨（2）、生成器的表达式
- 生成器表达式（generator expression）也叫生成器推导式或生成器解析式，用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。
- 与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，不能再次访问
- 已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象，enumerate、filter、map、zip等其他迭代器对象也具有同样的特点。
g = (i for i in range(10))
print(g) #返回了一个生成器
for i in g:
print(i)
输出结果：
at 0x000002075E40FC10>
0
1
2
3
4
5
6
7
8
9
✨（3）、字典推导式
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
✨（4）、集合推导式（自带结果去重功能）
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
def generator():
print(123)
yield 1
print(456)
yield 2
g1 = generator() #生成器g1
g2 = generator() #生成器g2
print('*',g1.__next__()) #从生成器g1中取第一个值
print('**',g1.__next__()) #从生成器g1中取第二个值
print('***',g2.__next__()) #从生成器g2中取第一个值
输出结果：
123
* 1
456
** 2
123
*** 1
✨（2）、方法二：send方法
- send 获取下一个值的效果和next基本一致
只是在获取下一个值的时候给上一个yield的位置传递了一个数据
- 使用send的注意事项：
- 第一次使用生成器时候是用next获取下一个值
- 最后一个yield不能接收外部的值
总结：
send：不能用在第一个，取下一个值的时候给上一个位置传一个新的值
def generator():
print(123)
content = yield 1
print('=======',content)
print(456)
yield 2
#send 获取下一个值的效果和next基本一致
#只是在获取下一个值的时候，给上一yield的位置传递一个数据
#使用send的注意事项
# 第一次使用生成器的时候 是用next获取下一个值
# 最后一个yield不能接受外部的值
g = generator()
print('*',g.__next__())
ret = g.send('hello') #send的效果与next一样
print('***',ret)
输出结果：
123
* 1
======= hello
456
*** 2
2、预激协程的装饰器
什么是预激协程的装饰器？
简单来说就是个加了装饰器的生成器（装饰器介绍）
预激协程的装饰器的实例：
#实际上就是省略了avg_g = average() avg_g.__next__()这两步
def init(func): #func = average
'''
装饰器函数
:param func:
:return:
'''
def inner(*args,**kwargs):
g = func(*args,**kwargs) #g = average()
g.__next__()
return g
return inner
@init #average = init(average) = inner
def average():
sum = 0
count = 0
avg = 0
while 1:
#num = yield
num = yield avg
sum += num
count += 1
avg = sum/count
avg_g = average() #===>inner
ret = avg_g.send(10)
print(ret)
# avg_g.__next__()
# avg1 = avg_g.send(10)
# avg2 = avg_g.send(20)
# print(avg1,avg2)
输出结果：
10.0
3、Python3新加的yield from
yield from: 后接列表、生成器、协程。与asyncio.coroutine同时使用，定义协程函数。在python3.5以后改成了await。当yield from后面是IO耗时操作的时候，会切换至另一个yield from。
在这我们简单来说：yield可以在函数中代替for循环对返回的数据进行迭代
def generator():
a = 'ab'
b = '12'
for i in a:
yield i
for i in b:
yield i
g = generator() 从生成器中取返回值
for i in g:
print(i)
输出结果：
a
b
1
2
def generator():
a = 'cd'
b = '34'
yield from a # ,b只能有一个变量
yield from b
g = generator() #从生成器中取返回值
for i in g:
print(i)
输出结果：
c
d
3
4
4、回顾
回顾：
一、send：
1、send的作用范围和next一模一样（从一个yield作用到下一个yield）
2、第一次不能使用send
3、函数在的最后一个yield不能接收新的值
二、
预激生成器的装饰器的例子
四、生成器函数高级进阶
1、生成器的表达式和各种推导式
✨（1）、列表推导式
模板：
[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历后挨个处理
[满足条件的元素进行相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能
egg_list = ['鸡蛋%s'%i for i in range(10)] #这是个列表推导式
print(egg_list)
'''相当于'''
egg_list = []
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)
print([i for i in range(10)])
输出结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
✨（2）、生成器的表达式
- 生成器表达式（generator expression）也叫生成器推导式或生成器解析式，用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。
- 与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，不能再次访问
- 已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象，enumerate、filter、map、zip等其他迭代器对象也具有同样的特点。
g = (i for i in range(10))
print(g) #返回了一个生成器
for i in g:
print(i)
输出结果：
at 0x000002075E40FC10>
0
1
2
3
4
5
6
7
8
9
✨（3）、字典推导式
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
✨（4）、集合推导式（自带结果去重功能）
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
- send 获取下一个值的效果和next基本一致
只是在获取下一个值的时候给上一个yield的位置传递了一个数据
- 使用send的注意事项：
- 第一次使用生成器时候是用next获取下一个值
- 最后一个yield不能接收外部的值
总结：
send：不能用在第一个，取下一个值的时候给上一个位置传一个新的值
def generator():
print(123)
content = yield 1
print('=======',content)
print(456)
yield 2
#send 获取下一个值的效果和next基本一致
#只是在获取下一个值的时候，给上一yield的位置传递一个数据
#使用send的注意事项
# 第一次使用生成器的时候 是用next获取下一个值
# 最后一个yield不能接受外部的值
g = generator()
print('*',g.__next__())
ret = g.send('hello') #send的效果与next一样
print('***',ret)
输出结果：
123
* 1
======= hello
456
*** 2
什么是预激协程的装饰器？
简单来说就是个加了装饰器的生成器（装饰器介绍）
预激协程的装饰器的实例：
#实际上就是省略了avg_g = average() avg_g.__next__()这两步 def init(func): #func = average ''' 装饰器函数 :param func: :return: ''' def inner(*args,**kwargs): g = func(*args,**kwargs) #g = average() g.__next__() return g return inner @init #average = init(average) = inner def average(): sum = 0 count = 0 avg = 0 while 1: #num = yield num = yield avg sum += num count += 1 avg = sum/count avg_g = average() #===>inner ret = avg_g.send(10) print(ret) # avg_g.__next__() # avg1 = avg_g.send(10) # avg2 = avg_g.send(20) # print(avg1,avg2) 输出结果： 10.0
3、Python3新加的yield from
yield from: 后接列表、生成器、协程。与asyncio.coroutine同时使用，定义协程函数。在python3.5以后改成了await。当yield from后面是IO耗时操作的时候，会切换至另一个yield from。
在这我们简单来说：yield可以在函数中代替for循环对返回的数据进行迭代
def generator():
a = 'ab'
b = '12'
for i in a:
yield i
for i in b:
yield i
g = generator() 从生成器中取返回值
for i in g:
print(i)
输出结果：
a
b
1
2
def generator():
a = 'cd'
b = '34'
yield from a # ,b只能有一个变量
yield from b
g = generator() #从生成器中取返回值
for i in g:
print(i)
输出结果：
c
d
3
4
4、回顾
回顾：
一、send：
1、send的作用范围和next一模一样（从一个yield作用到下一个yield）
2、第一次不能使用send
3、函数在的最后一个yield不能接收新的值
二、
预激生成器的装饰器的例子
四、生成器函数高级进阶
1、生成器的表达式和各种推导式
✨（1）、列表推导式
模板：
[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历后挨个处理
[满足条件的元素进行相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能
egg_list = ['鸡蛋%s'%i for i in range(10)] #这是个列表推导式
print(egg_list)
'''相当于'''
egg_list = []
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)
print([i for i in range(10)])
输出结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
✨（2）、生成器的表达式
- 生成器表达式（generator expression）也叫生成器推导式或生成器解析式，用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。
- 与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，不能再次访问
- 已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象，enumerate、filter、map、zip等其他迭代器对象也具有同样的特点。
g = (i for i in range(10))
print(g) #返回了一个生成器
for i in g:
print(i)
输出结果：
at 0x000002075E40FC10>
0
1
2
3
4
5
6
7
8
9
✨（3）、字典推导式
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
✨（4）、集合推导式（自带结果去重功能）
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
yield from: 后接列表、生成器、协程。与asyncio.coroutine同时使用，定义协程函数。在python3.5以后改成了await。当yield from后面是IO耗时操作的时候，会切换至另一个yield from。
在这我们简单来说：yield可以在函数中代替for循环对返回的数据进行迭代
def generator():
a = 'ab'
b = '12'
for i in a:
yield i
for i in b:
yield i
g = generator() 从生成器中取返回值
for i in g:
print(i)
输出结果：
a
b
1
2
def generator():
a = 'cd'
b = '34'
yield from a # ,b只能有一个变量
yield from b
g = generator() #从生成器中取返回值
for i in g:
print(i)
输出结果：
c
d
3
4
回顾：
一、send：
1、send的作用范围和next一模一样（从一个yield作用到下一个yield）
2、第一次不能使用send
3、函数在的最后一个yield不能接收新的值
二、
预激生成器的装饰器的例子
四、生成器函数高级进阶
1、生成器的表达式和各种推导式
✨（1）、列表推导式
模板：
[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历后挨个处理
[满足条件的元素进行相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能
egg_list = ['鸡蛋%s'%i for i in range(10)] #这是个列表推导式
print(egg_list)
'''相当于'''
egg_list = []
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)
print([i for i in range(10)])
输出结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
✨（2）、生成器的表达式
- 生成器表达式（generator expression）也叫生成器推导式或生成器解析式，用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。
- 与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，不能再次访问
- 已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象，enumerate、filter、map、zip等其他迭代器对象也具有同样的特点。
g = (i for i in range(10))
print(g) #返回了一个生成器
for i in g:
print(i)
输出结果：
at 0x000002075E40FC10>
0
1
2
3
4
5
6
7
8
9
✨（3）、字典推导式
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
✨（4）、集合推导式（自带结果去重功能）
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
✨（1）、列表推导式
模板：
[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历后挨个处理
[满足条件的元素进行相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能
egg_list = ['鸡蛋%s'%i for i in range(10)] #这是个列表推导式
print(egg_list)
'''相当于'''
egg_list = []
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)
print([i for i in range(10)])
输出结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
✨（2）、生成器的表达式
- 生成器表达式（generator expression）也叫生成器推导式或生成器解析式，用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。
- 与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，不能再次访问
- 已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象，enumerate、filter、map、zip等其他迭代器对象也具有同样的特点。
g = (i for i in range(10))
print(g) #返回了一个生成器
for i in g:
print(i)
输出结果：
at 0x000002075E40FC10>
0
1
2
3
4
5
6
7
8
9
✨（3）、字典推导式
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
✨（4）、集合推导式（自带结果去重功能）
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
模板：
[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历后挨个处理
[满足条件的元素进行相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能
egg_list = ['鸡蛋%s'%i for i in range(10)] #这是个列表推导式
print(egg_list)
'''相当于'''
egg_list = []
for i in range(10):
egg_list.append('鸡蛋%s' %i)
print(egg_list)
print([i for i in range(10)])
输出结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- 生成器表达式（generator expression）也叫生成器推导式或生成器解析式，用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。
- 与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的next()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，不能再次访问
- 已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象，enumerate、filter、map、zip等其他迭代器对象也具有同样的特点。
g = (i for i in range(10)) print(g) #返回了一个生成器 for i in g: print(i) 输出结果：at 0x000002075E40FC10> 0 1 2 3 4 5 6 7 8 9
✨（3）、字典推导式
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
✨（4）、集合推导式（自带结果去重功能）
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
例一：将一个字典的key和value对调
dic = {'a' : 97,'b' : 98}
dic_exchange = {dic[k] :k for k in dic}
print(dic_exchange)
输出结果：
{97: 'a', 98: 'b'}
set = {x**2 for x in [1,-1,2,-2,3,4]}
print(set)
输出结果：
{16, 1, 4, 9}
2、总结
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
结语：
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
唯独没有元组推导式，要得到一个元组就可以直接将推出来的数据类型转换为元组就行
总结：各种推导式：生成器 列表 字典 集合
1、遍历操作
2、筛选操作
二、惰性运算
生成器与迭代器都是惰性运算：
但是生成器你可以看的见因为这是你写的而迭代器一般看不见
1、同一生成器中的数据只能取一次取完就没了
2、惰性运算：不找它要值它就不返回
# 列表解析
sum([i for i in range(100000000)]) # 内存占用大,机器容易卡死
# 生成器表达式
sum(i for i in range(100000000)) # 几乎不占内存
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
感谢各位能够看到这里：在鲁迅一篇未发表的文章中说过：“代码看懂了不是懂✨一定要自己实际操作哇✨这样才能更好的理解和吸收。”
最后来一句：一个人可以在任何他怀有无限热忱的事情上成功，让我们一起进步吧✨✨
