Python快速学习第十二天--生成器和协程

yield指令,可以暂停一个函数并返回中间结果。使用该指令的函数将保存执行环境,并且在必要时恢复。

生成器比迭代器更加强大也更加复杂,需要花点功夫好好理解贯通。

看下面一段代码:

[python] view plain copy

  1. def gen():  
  2. for x in xrange(4):  
  3.         tmp = yield x  
  4. if tmp == 'hello':  
  5. print 'world'
  6. else:  
  7. print str(tmp)  

     只要函数中包含yield关键字,该函数调用就是生成器对象。

[python] view plain copy

  1. g=gen()  
  2. print g   #<generator object gen at 0x02801760>
  3. print isinstance(g,types.GeneratorType) #True

    我们可以看到,gen()并不是函数调用,而是产生生成器对象。

   生成器对象支持几个方法,如gen.next() ,gen.send() ,gen.throw()等。

[python] view plain copy

  1. print g.next() # 0

    调用生成器的next方法,将运行到yield位置,此时暂停执行环境,并返回yield后的值。所以打印出的是0,暂停执行环境。

[python] view plain copy

  1. print g.next() #None  1

     再调用next方法,你也许会好奇,为啥打印出两个值,不急,且听我慢慢道来。

     上一次调用next,执行到yield 0暂停,再次执行恢复环境,给tmp赋值(注意:这里的tmp的值并不是x的值,而是通过send方法接受的值),由于我们没有调用send方法,所以

tmp的值为None,此时输出None,并执行到下一次yield x,所以又输出1.

      到了这里,next方法我们都懂了,下面看看send方法。

[python] view plain copy

  1. print g.send('hello') #world  2

      上一次执行到yield 1后暂停,此时我们send('hello'),那么程序将收到‘hello',并给tmp赋值为’hello',此时tmp=='hello'为真,所以输出'world',并执行到下一次yield 2,所以又打印出2.(next()等价于send(None))

      当循环结束,将抛出StopIteration停止生成器。

      看下面代码:

[python] view plain copy

  1. def stop_immediately(name):  
  2. if name == 'skycrab':  
  3. yield 'okok'
  4. else:  
  5. print 'nono'
  6. s=stop_immediately('sky')  
  7. s.next()  

正如你所预料的,打印出’nono',由于没有额外的yield,所以将直接抛出StopIteration。

[python] view plain copy

  1. nono  
  2. Traceback (most recent call last):  
  3.   File "F:\python workspace\Pytest\src\cs.py", line 170, in <module>  
  4.     s.next()  
  5. StopIteration  

      看下面代码,理解throw方法,throw主要是向生成器发送异常。

[python] view plain copy

  1. def mygen():  
  2. try:  
  3. yield 'something'
  4. except ValueError:  
  5. yield 'value error'
  6. finally:  
  7. print 'clean' #一定会被执行
  8. gg=mygen()  
  9. print gg.next() #something
  10. print gg.throw(ValueError) #value error  clean

协程

协程,又称微线程,纤程。英文名Coroutine。

协程的概念很早就提出来了,但直到最近几年才在某些语言(如Lua)中得到广泛应用。

子程序,或者称为函数,在所有语言中都是层级调用,比如A调用B,B在执行过程中又调用了C,C执行完毕返回,B执行完毕返回,最后是A执行完毕。

所以子程序调用是通过栈实现的,一个线程就是执行一个子程序。

子程序调用总是一个入口,一次返回,调用顺序是明确的。而协程的调用和子程序不同。

协程看上去也是子程序,但执行过程中,在子程序内部可中断,然后转而执行别的子程序,在适当的时候再返回来接着执行。

注意,在一个子程序中中断,去执行其他子程序,不是函数调用,有点类似CPU的中断。比如子程序A、B:

def A():
    print '1'
    print '2'
    print '3'

def B():
    print 'x'
    print 'y'
    print 'z'

假设由协程执行,在执行A的过程中,可以随时中断,去执行B,B也可能在执行过程中中断再去执行A,结果可能是:

1
2
x
y
3
z

但是在A中是没有调用B的,所以协程的调用比函数调用理解起来要难一些。

看起来A、B的执行有点像多线程,但协程的特点在于是一个线程执行,那和多线程比,协程有何优势?

最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换,而是由程序自身控制,因此,没有线程切换的开销,和多线程比,线程数量越多,协程的性能优势就越明显。

第二大优势就是不需要多线程的锁机制,因为只有一个线程,也不存在同时写变量冲突,在协程中控制共享资源不加锁,只需要判断状态就好了,所以执行效率比多线程高很多。

因为协程是一个线程执行,那怎么利用多核CPU呢?最简单的方法是多进程+协程,既充分利用多核,又充分发挥协程的高效率,可获得极高的性能。

Python对协程的支持还非常有限,用在generator中的yield可以一定程度上实现协程。虽然支持不完全,但已经可以发挥相当大的威力了。

来看例子:

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

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

import time

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

def produce(c):
    c.next()
    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()

if __name__=='__main__':
    c = consumer()
    produce(c)

执行结果:

[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后:

  1. 首先调用c.next()启动生成器;
  2. 然后,一旦生产了东西,通过c.send(n)切换到consumer执行;
  3. consumer通过yield拿到消息,处理,又通过yield把结果传回;
  4. produce拿到consumer处理的结果,继续生产下一条消息;
  5. produce决定不生产了,通过c.close()关闭consumer,整个过程结束。

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

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

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

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Java架构沉思录

聊聊设计模式之代理模式

前言 代理模式的目的是提供一个代理来控制对一个对象的访问。那么,我们为什么需要控制对一个对象的访问呢?或者说控制对一个对象的访问有什么好处呢?在日常工作中,大...

2695
来自专栏Golang语言社区

Go语言并发编程总结

Golang :不要通过共享内存来通信,而应该通过通信来共享内存。这句风靡在Go社区的话,说的就是 goroutine中的 channel ....... 他在...

2719
来自专栏逍遥剑客的游戏开发

MPQ文件系统优化

1726
来自专栏程序你好

C# API中的模型和它们的接口设计

932
来自专栏web开发

JavaSript模块规范 - AMD规范与CMD规范介绍

JavaSript模块化     在了解AMD,CMD规范前,还是需要先来简单地了解下什么是模块化,模块化开发?     模块化是指在解决某一个复杂问题或者...

2376
来自专栏Golang语言社区

Go语言并发编程总结

Golang :不要通过共享内存来通信,而应该通过通信来共享内存。这句风靡在Go社区的话,说的就是 goroutine中的 channel ....... 他在...

3087
来自专栏刘望舒

设计模式(十五)状态模式

前言 建议在阅读本文前先阅读设计模式(十一)策略模式这篇文章,虽说状态模式和策略模式的结构几乎是相同的,但是它们所解决的问题是不同的,读完这两篇文章你就会有了答...

2016
来自专栏JavaEdge

JSP必备知识点servlet VS CGI如何实现 servlet 单线程模式servlet 页面间对象传递的方法有几种jsp VS servlet<jsp:include page=”includ

3666
来自专栏游戏开发那些事

【Linux下进程机制】从一道面试题谈linux下fork的运行机制

      已知从这个程序执行到这个程序的所有进程结束这个时间段内,没有其它新进程执行。

1842
来自专栏C/C++基础

腾讯2016春季校园实习招聘技术岗初试(一面)问题汇总(CC++后台)

2016.4.11日广州参加了腾讯的CC++后台技术一面,安全技术类的面试。面试官人很温和,经历了大概70分钟的问答,特将遇到的面试问题汇总如下,自己总结学习,...

831

扫码关注云+社区

领取腾讯云代金券