十八、python沉淀之路--生成器

一、生成器

生成器总结：
语法上和函数类似：生成器函数和常规函数几乎是一样的。他们都是使用def语句进行定义，差别在于生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值。自动实现迭代器协议；对于生成器，python会自动实现迭代器协议，以便应用到迭代背景种，（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生stop iteration异常。

状态挂起：生成器使用yield语句返回一个值，yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从他离开的地方继续执行。

1、初识

 gift_list = ('礼盒%s'%i for i in range(10))   #这就是生成器表达式
 print(gift_list)
 print(gift_list.__next__())
 print(next(gift_list))

 <generator object <genexpr> at 0x00000294B972DDB0>
 礼盒0
 礼盒1

2、

 import time
 def test():
     print('桃树准备开花了')
     time.sleep(1)
     yield '长了第一个桃子'
     time.sleep(1)
     print('把第一个桃子吃了')
     time.sleep(1)
     yield '长了第二个桃子'
     print('把第二个桃子吃了')
     yield '长了第三个桃子'

 res = test()
 print(res)
 print(res.__next__())    #这次执行yield就会停在那里。下一次执行next就从上一次yield的地方开始执行。
 print(next(res))
 print(res.__next__())

 <generator object test at 0x00000121469BA308>
 桃树准备开花了
 长了第一个桃子
 把第一个桃子吃了
 长了第二个桃子
 把第二个桃子吃了
 长了第三个桃子

3、卖包子的例子

 def produce_baozi():
     for i in range(1,11):
         print('准备生产包子')
         yield '一笼包子%i'%i
         print('开始卖包子')
 p_baozi = produce_baozi()
 print(p_baozi.__next__())
 print(p_baozi.__next__())

 准备生产包子
 一笼包子1
 开始卖包子
 准备生产包子
 一笼包子2

4、产鸡蛋的例子

 def produce_egg():
     ret = []
     for i in range(1,11):
         ret.append('鸡蛋-%s'%i)
     return ret

 p_egg = produce_egg()
 print(p_egg)

 这种方式 占空间大，效率低

 def produce_egg():
     for i in range(1,11):
         yield 'egg-%s'%i
 chicken = produce_egg()
 print(chicken.__next__())
 print(chicken.__next__())
 print(chicken.__next__())
 print(next(chicken))
 print(next(chicken))

 for egg in chicken:
     print(egg)

 ['鸡蛋-1', '鸡蛋-2', '鸡蛋-3', '鸡蛋-4', '鸡蛋-5', '鸡蛋-6', '鸡蛋-7', '鸡蛋-8', '鸡蛋-9', '鸡蛋-10']
 egg-1
 egg-2
 egg-3
 egg-4
 egg-5
 egg-6
 egg-7
 egg-8
 egg-9
 egg-10

优点一：生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果。这对于大数据量处理，将会非常有用。

列表解释
sum((i for i in range(1000000000))  #内存占用大，机器容易卡死

生成器表达式
sum(i for i in range(1000000000))  #几乎不占内存

优点二：生成器还能有效提高代码可读性

这里，至少有两个充分的理由说明，使用生成器比不使用代码更加清晰：
    1、使用生成器以后，代码行数更少。大家要记住，如果想要把代码写的pythonic在保证代码可读性的前提下，代码行数越少越好。
    2、不使用生成器的时候，对于每次结果，我们首先看到的是result append（index），其次，才是index。也就是说，我们每次看到的是一个列表的append的操作      的，知识append的是我们想要的结果。使用生成器时候，直接yield index，少了列表append操作的干扰，我们一眼就能够看出，代码是要返回index。
    
    上面的例子充分说明了，合理使用生成器，能够有效提高代码可读性，只要大家完全接收了生成器的概念，理解了yield语句和return语句一样，业绩是返回一个值。
    那么，就能够理解为什么使用生成器比不适用生成器要好，能够 理解使用生成器真的可以让代码变得清晰易懂。

二、通过生成器实现协程并行运算

例1

 def consumer(name):
     print('%s开始准备吃包子了'%name)
     while True:
         baozi = yield 1
         print('包子%s被%s吃完了'%(baozi,name))

 def producer(name):
     c = consumer('A')
     c2 = consumer('B')
     print(c.__next__())
     print(c2.__next__())
     print('大爷要吃包子啦')
     for i in range(1,11):
         c.send(i)
         c2.send(i)
 producer('隔壁老王')

 A开始准备吃包子了
 1
 B开始准备吃包子了
 1
 大爷要吃包子啦
 包子1被A吃完了
 包子1被B吃完了
 包子2被A吃完了
 包子2被B吃完了
 包子3被A吃完了
 包子3被B吃完了
 包子4被A吃完了
 包子4被B吃完了
 包子5被A吃完了
 包子5被B吃完了
 包子6被A吃完了
 包子6被B吃完了
 包子7被A吃完了
 包子7被B吃完了
 包子8被A吃完了
 包子8被B吃完了
 包子9被A吃完了
 包子9被B吃完了
 包子10被A吃完了
 包子10被B吃完了

例2

 import time
 def consumer(name):
     print('我是[%s],我准备开始吃包子了' %name)
     while True:
         baozi=yield
         time.sleep(1)
         print('%s 很开心的把【%s】吃掉了' %(name,baozi))

 def producer():
     c1=consumer('隔壁老王')
     c2=consumer('对面老李')
     c1.__next__()
     c2.__next__()
     for i in range(10):
         time.sleep(1)
         c1.send('包子 %s' %i)
         c2.send('包子 %s' %i)
 producer()

 我是[隔壁老王],我准备开始吃包子了
 我是[对面老李],我准备开始吃包子了
 隔壁老王 很开心的把【包子 0】吃掉了
 对面老李 很开心的把【包子 0】吃掉了
 隔壁老王 很开心的把【包子 1】吃掉了
 对面老李 很开心的把【包子 1】吃掉了
 隔壁老王 很开心的把【包子 2】吃掉了
 对面老李 很开心的把【包子 2】吃掉了
 隔壁老王 很开心的把【包子 3】吃掉了
 对面老李 很开心的把【包子 3】吃掉了
 隔壁老王 很开心的把【包子 4】吃掉了
 对面老李 很开心的把【包子 4】吃掉了
 隔壁老王 很开心的把【包子 5】吃掉了
 对面老李 很开心的把【包子 5】吃掉了
 隔壁老王 很开心的把【包子 6】吃掉了
 对面老李 很开心的把【包子 6】吃掉了
 隔壁老王 很开心的把【包子 7】吃掉了
 对面老李 很开心的把【包子 7】吃掉了
 隔壁老王 很开心的把【包子 8】吃掉了
 对面老李 很开心的把【包子 8】吃掉了
 隔壁老王 很开心的把【包子 9】吃掉了
 对面老李 很开心的把【包子 9】吃掉了

例3

 import time
 def producer():
     ret=[]
     for i in range(10):
         time.sleep(0.1)
         ret.append('包子%s' %i)
     return ret

 def consumer(res):
     for index,baozi in enumerate(res):
         time.sleep(0.1)
         print('第%s个人，吃了%s' %(index,baozi))

 res=producer()
 consumer(res)

 第0个人，吃了包子0
 第1个人，吃了包子1
 第2个人，吃了包子2
 第3个人，吃了包子3
 第4个人，吃了包子4
 第5个人，吃了包子5
 第6个人，吃了包子6
 第7个人，吃了包子7
 第8个人，吃了包子8
 第9个人，吃了包子9

yield 3相当于return 控制的是函数的返回值
x=yield的另外一个特性，接受send传过来的值,赋值给x

例4

 def test():
     print('开始啦')
     firt=yield #return 1   first=None
     print('第一次',firt)
     yield 2
     print('第二次')

 t=test()
 res=t.__next__() #next(t)
 print(res)
 # t.__next__()
 # res=t.send(None)
 res=t.send('函数停留在first那个位置，我就是给first赋值的')
 print(res)

 开始啦
 None
 第一次 函数停留在first那个位置，我就是给first赋值的
 2