[开篇五:Python零散知识拾荒之生成器]2019-02-15

生成器理解

  生成器算得上是Python语言中最吸引人的特性之一,生成器其实是一种特殊的迭代器,不过这种迭代器更加优雅,只需要一个yiled关键字。 生成器一定是迭代器(反之不成立),因此任何生成器也是以一种懒加载的模式生成值。
  使用生成器对延迟操作提供了支持。所谓延迟操作,是指在需要的时候才产生结果,而不是立即产生结果。


生成器两种结构

  可以延迟结果创建:生成器函数和生成器表达式。
  生成器比迭代器对象多了一些方法,它们包括send方法,throw方法和close方法。这些方法,主要是用于外部与生成器对象的交互。

  • 生成器函数:和其他函数编写方式相同,但是使用yield语句一次返回一个结果,在每个结果之间挂起当前状态,下次调用的时候会从当前状态继续。
#coding:utf-8
def test1():
    i=0
    while i<5:
        temp=yield i
        print temp,'inner'
        i+=1

a=test1()
print a
print '---start---'
print a.next()
print '-----------'
print a.send(45)
print '-----------'
print a.next()
print '-----------'
print a.next()
print '-----------'
print a.next()

result:

生成器函数

对上述结果以及过程的理解:
  对于普通的生成器,第一个next调用,相当于启动生成器,会从生成器函数的第一行代码开始执行,直到第一次执行完yield语句(第5行)后,跳出生成器函数。
  然后第二个next调用,进入生成器函数后,从yield语句的下一句语句(第6行)开始执行,然后重新运行到yield语句,执行后,跳出生成器函数,后面再次调用next,依次类推。
(1)生成器(generator)能够迭代的关键是它有一个next()方法,工作原理就是通过重复调用next()方法,直到捕获一个异常。
(2)带有 yield 的函数不再是一个普通函数,而是一个生成器generator。可用next()调用生成器对象来取值。next 两种方式 t.next() | next(t)。可用for 循环获取返回值(每执行一次,取生成器里面一个值)(基本上不会用next()来获取下一个返回值,而是直接使用for循环来迭代)。
(3)yield相当于 return 返回一个值,并且记住这个返回的位置,下次迭代时,代码从yield的下一条语句开始执行。
(4)send() 和next()一样,都能让生成器继续往下走一步(下次遇到yield停),但send()能传一个值,这个值作为yield表达式整体的结果,赋值后再顺序到yield(相当于正常yield前插入了一个send操作,send=给yield表达式赋值+正常yield逻辑)。
  ——换句话说,就是send可以强行修改上一个yield表达式值。比如函数中有一个yield赋值,a = yield 5,第一次迭代到这里会返回5,a还没有赋值。第二次迭代时,使用.send(10),那么,就是强行修改yield 5表达式的值为10,本来是5的,那么a=10

感受下yield返回值的过程(关注点:每次停在哪,下次又开始在哪)及send()传参的通讯过程,

思考None是如何产生的(第一次取值:yield 返回了 i 值 0,停在yield i,temp没赋到值(只有send才能给它复制 否则一直是None)。第二次取值,开始在print,temp没被赋值,故打印None,i加1,继续while判断,yield 返回了 i 值 1,停在yield i)

  • 生成器表达式:类似于列表解析,不同的是它返回的是一个可迭代对象而不是一个列表。
#coding=utf-8
gen_test=(x**2 for x in range(10) if x/2!=0)
print(gen_test)
for i in gen_test:
    print i
gen_test=(x**2 for x in range(10) if x/2!=0)
print(gen_test)
for i in gen_test:
    print i

result:

生成器表达式

协程---生产者消费者

Python对协程的支持是通过generator实现的。

在generator中,我们不但可以通过for循环来迭代,还可以不断调用next()函数获取由yield语句返回的下一个值。

但是Python的yield不但可以返回一个值,它还可以接收调用者发出的参数。

来看例子:

传统的生产者-消费者模型是一个线程写消息,一个线程取消息,通过锁机制控制队列和等待,但一不小心就可能死锁。

如果改用协程,生产者生产消息后,直接通过yield跳转到消费者开始执行,待消费者执行完毕后,切换回生产者继续生产,效率极高:

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        r = '200 OK'

def produce(c):
    c.send(None)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()

c = consumer()
produce(c)

res:

[PRODUCER] Producing 1...
[CONSUMER] Consuming 1...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 2...
[CONSUMER] Consuming 2...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 3...
[CONSUMER] Consuming 3...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 4...
[CONSUMER] Consuming 4...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 5...
[CONSUMER] Consuming 5...
[PRODUCER] Consumer return: 200 OK

注意到consumer函数是一个generator,把一个consumer传入produce后:

首先调用c.send(None)启动生成器;

  • ▲注意,每次的send()都会运行到yield语句,但赋值不会执行,只会有返回值,相当于return后就退出函数了,所以在返回值之后的赋值就不会执行了。

然后,一旦生产了东西,通过c.send(n)切换到consumer执行;

consumer通过yield拿到消息,处理,又通过yield把结果传回;

produce拿到consumer处理的结果,继续生产下一条消息;

produce决定不生产了,通过c.close()关闭consumer,整个过程结束。

整个流程无锁,由一个线程执行,produce和consumer协作完成任务,所以称为“协程”,而非线程的抢占式多任务。

最后套用Donald Knuth的一句话总结协程的特点:

“子程序就是协程的一种特例”。