Day4-生成器generator

列表生成式

需求：列表[0,1,2,3,4,5,6,7,8,9]每个值加1，如何实现？

方法1：列表追加

 >>> a = [0,1,2,3,4,5,6,7,8,9]
 >>> b = []
 >>> for i in range(10):
 ...     b.append(i+1)
 ...
 >>> b
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 >>> a = b
 >>> a
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

方法2：原值修改enumerate

 >>> a = [0,1,2,3,4,5,6,7,8,9]
 >>> for index,i in enumerate(a):
 ...     a[index] += 1
 ...
 >>> a
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

方法3：map函数

 >>> a = [0,1,2,3,4,5,6,7,8,9]
 >>> a = map(lambda x:x+1,a)
 >>> a
 <map object at 0x000000000299FF60>
 >>> for i in a: print(i)
 ...
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

方法4：列表生成，作用：使代码更简洁

 >>> a = [i+1 for i in range(10)]
 >>> a
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成器

当list列表很大，比如100万条，只使用几个，而不是使用那么多，如果全部放进内容占用空间很大，使用一种机制：边循环边计算，称为生成器。

元组：

 >>> b = (i*2 for i in range(10))
 >>> b
 <generator object <genexpr> at 0x00000000029981A8>
 >>> for i in b:
 ...     print(i)
 ...
 0
 2
 4
 6
 8
 10
 12
 14
 16
 18

列表：

 >>> c = [i*2 for i in range(10)]
 >>> c
 [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

两者区别：最外层的[]和()，一个是list，一个是generator生成器。

如何打印其中的元素：

列表list：

 >>> c[9]
 18
 >>> len(c)
 10

元组generator：生成器使用元组，只有被调用了才会生成数据，调用哪生成哪。调用方法：next()

 >>> b[9] #生成器没有像列表一样的下标操作
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: 'generator' object is not subscriptable

 >>> b = (i*2 for i in range(10))
 >>> next(b)
 0
 >>> next(b)
 2
 >>> next(b)
 4
 >>> next(b)
 6
 >>> next(b)
 8
 >>> next(b)
 10
 >>> next(b)
 12
 >>> next(b)
 14
 >>> next(b)
 16
 >>> next(b)
 18
 >>> next(b) #next只记录当前位置，调用到最后一个再调用就会报错
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 StopIteration

next()方法调用到最后一个后再调用就会抛出StopIteration错误异常，正确的方法：

 >>> g = ( i*2 for i in range(10))
 >>> for n in g:
 ...     print(n)
 ...
 0
 2
 4
 6
 8
 10
 12
 14
 16
 18

举例1：斐波那契数列1,1,2,3,5,8,13...，函数代码为

 def fib(max):
     n, a, b = 0, 0, 1
     while n < max:
         print(b)
         a, b = b, a + b
         n = n + 1
     return 'done'

 fib(10)
 1
 1
 2
 3
 ...
 55

赋值语句：a,b = b,a+b  相当于 t=(b,a+b) a=t[0] b=t[1]

生成器写法：

 def fib(max):
     n, a, b = 0, 0, 1
     while n < max:
         #print(b)
         yield(b) #有yield关键字就不是普通函数，而是一个生成器generator
         a, b = b, a + b
         n = n + 1
     return '异常了' #11个next方法执行后，就会抛出异常Stop Iteration:异常了，所以return返回的是异常消息

 f=fib(10) #生成器必须被调用才能生效
 #print(f.__next__()) #使用next方法调用
 for i in f:  #正确调用方式如下
     print(i)

总结：有yield函数就是一个生成器，return返回异常消息。yield保存函数中断状态，想什么时候回来就什么时候回来。

生成器的作用：函数是顺序执行，遇到return或最后一行语句就结束执行；生成器在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。（断点执行下看看）

yield实现单线程情况下并发!!!

 举例2：典型的生产者消费者模型

 import time
 def consumer(name):
     print("%s准备吃包子了"%name)
     while True:
         baozi = yield #没有yield返回值，表示为空
         print("包子[%s]来了，被[%s]吃了"%(baozi,name))
 c = consumer("A")
 c.__next__()
 执行结果：
 A准备吃包子了

 再添加一行代码：
 c.__next__()
 包子[None]来了，被[A]吃了

 分析：
 第一次程序执行顺序：
 def consumer---c=consumer("A")使得c变成generator生成器---c.__next__()调用生成器--def consumer(name = "A")--print---while True---baozi=yield--返回为空退出，底下的print(包子被谁吃了)不执行

 第二次程序执行顺序：
 def consumer---c=consumer("A")使得c变成generator生成器---c.__next__()调用生成器--def consumer(name = "A")--print---while True---baozi=yield--第二个c.__next__()---baozi=yield---print(包子被谁吃了)---baozi=yield---返回为空退出

注：生成器只有g.__next()__方法调用，同t = next(g)一样。

执行结果：

A准备吃包子了
包子[None]来了，被[A]吃了

 import time
 def consumer(name):
     print("%s准备吃包子了"%name)
     while True:
         baozi = yield #没有yield返回值，表示为空
         print("包子[%s]来了，被[%s]吃了"%(baozi,name))
 c = consumer("A")
 c.__next__()

 b1 = "韭菜馅"
 c.send(b1)
 c.__next__()

 执行结果：
 A准备吃包子了
 包子[韭菜馅]来了，被[A]吃了
 包子[None]来了，被[A]吃了

 next和send区别？
 next只是调用yield，send不仅调用还给yield传值

最终代码：单线程下的并行效果叫协程。

 import time
 def consumer(name):
     print("%s准备吃包子了"%name)
     while True:
         baozi = yield #没有yield返回值，表示为空
         print("包子[%s]来了，被[%s]吃了"%(baozi,name))
 # c = consumer("A")
 # c.__next__()
 #
 # b1 = "韭菜馅"
 # c.send(b1)

 def producer(name):
     c = consumer('A') #两个消费者
     c2 = consumer('B')
     c.__next__() #调用，打印“准备吃包子”
     c2.__next__()
     print("开始准备做包子了")
     for i in range(10):
         time.sleep(1) #每1s钟做2个包子
         print("做了2个包子")
         c.send(i)
         c2.send(i)

 producer("alex")

 执行结果：
 A准备吃包子了
 B准备吃包子了
 开始准备做包子了

 做了2个包子
 包子[0]来了，被[A]吃了
 包子[0]来了，被[B]吃了
 ....
 做了2个包子
 包子[9]来了，被[A]吃了
 包子[9]来了，被[B]吃了

 分析：三行三行的打印，好像是并行的，类似nginx异步IO的效果