python中yield用法

最新推荐文章于 2024-07-23 10:19:17 发布

vickyleexy

最新推荐文章于 2024-07-23 10:19:17 发布

阅读量1.1k

点赞数 2

分类专栏： python 文章标签： python

python 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

参考：http://blog.163.com/l_greatsea/blog/static/2049860442013220113640476/
　　　http://www.cnblogs.com/fangyuan1004/p/4571304.html
　　　http://www.cnblogs.com/tqsummer/archive/2010/12/27/1917927.html
　　　http://blog.csdn.net/alvine008/article/details/43410079

迭代器

　在Python中，for循环可以用于Python中的任何类型，包括列表、元祖等等，实际上，for循环可用于任何“可迭代对象”，这其实就是迭代器。

　　迭代器是一个实现了迭代器协议的对象，Python中的迭代器协议就是有next方法的对象会前进到下一结果，而在一系列结果的末尾是，则会引发StopIteration。任何这类的对象在Python中都可以用for循环或其他遍历工具迭代，迭代工具内部会在每次迭代时调用next方法，并且捕捉StopIteration异常来确定何时离开。

　　使用迭代器一个显而易见的好处就是：每次只从对象中读取一条数据，不会造成内存的过大开销。

　　比如要逐行读取一个文件的内容，利用readlines()方法，我们可以这么写：

　　for line in open("test.txt").readlines():
    print line

　　这样虽然可以工作，但不是最好的方法。因为他实际上是把文件一次加载到内存中，然后逐行打印。当文件很大时，这个方法的内存开销就很大了。
　　利用file的迭代器，我们可以这样写：

　　for line in open("test.txt"):   #use file iterators
    print line

这是最简单也是运行速度最快的写法，他并没显式的读取文件，而是利用迭代器每次读取下一行。

生成器(constructor)

　　生成器函数在Python中与迭代器协议的概念联系在一起。简而言之，包含yield语句的函数会被特地编译成生成器。当函数被调用时，他们返回一个生成器对象，这个对象支持迭代器接口。函数也许会有个return语句，但它的作用是用来yield产生值的。
　　不像一般的函数会生成值后退出，生成器函数在生成值后会自动挂起并暂停他们的执行和状态，他的本地变量将保存状态信息，这些信息在函数恢复时将再度有效。

>>> def g(n):
...     for i in range(n):
...             yield i **2
...
>>> for i in g(5):
...     print i,":",
...
0 : 1 : 4 : 9 : 16 :

要了解他的运行原理，可用next方法看看。

　　yield关键字用来定义生成器（Generator），其具体功能是可以当return使用，从函数里返回一个值，不同之处是用yield返回之后，可以让函数从上回yield返回的地点继续执行。也就是说，yield返回函数，交给调用者一个返回值，然后再“瞬移”回去，让函数继续运行，直到吓一条yield语句再返回一个新的值。
　　使用yield返回后，调用者实际得到的是一个迭代器对象，迭代器的值就是返回值，而调用该迭代器的next()方法会导致该函数恢复yield语句的执行环境继续往下跑，直到遇到下一个yield为止，如果遇不到yield，就会抛出异常表示迭代结束。
例子：

>>> def test_yield():
...     yield 1
...     yield 2
...     yield (1,2)
...
>>> a = test_yield()
>>> a.next()
1
>>> a.next()
2
>>> a.next()
(1, 2)
>>> a.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
StopIteration

在运行完全部next之后，生成器抛出了一个StopIteration异常，迭代终止。

yield基本用法

典型的例子：

　　斐波那契（Fibonacci）數列是一个非常简单的递归数列，除第一个和第二个数外，任意一个数都可由前两个数相加得到。1 2 3 5 8……

def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        yield b 
        # print b 
        a, b = b, a + b 
        n = n + 1

　　yield 的作用就是把一个函数变成一个generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个生成器，如调用fab函数，不会执行该函数，而是返回一个iterable迭代对象！

　　在for循环执行时，每次循环都会相当于执行生成器的next函数，才开始执行fab函数的内部代码，执行到yield b时，fab函数就返回一个迭代值，然后挂起。

　　下次迭代时，代码从yield b的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到yield。
更多的yield例子：

#!/usr/bin/python
def a():
    print ("do a() will not print out")
    yield 5
a()
print ("===============test a()")

def b():
    print ("list generator will in def , print here...")
    yield 5
g_obj = b()
print ("===============g_obj test b: %s" % g_obj)
print ("just generator obj, not in b def")
print ("list_g: %s" % list(g_obj))

def c():
    print ("next() will here... test generator next(), next attrbute not in python3, python2.6 is exist")
    yield 5
    print ("test generator next2")
g_obj = c()
print ("===============g_obj test c: %s" % g_obj)
#g_obj.next()
#print ("dir g_obj: %s " % dir(g_obj))


def d():
    global m
    global n
    print ("send() will here... test generator send()")
    m = yield 5
    print ("send input is m : %s" % m)
    n = yield 6
    print ("test generator send2")

g_obj = d()
print ("===============g_obj test d: %s" % g_obj)
s_return1 = g_obj.send(None)
s_return2 = g_obj.send("send twice")
print ("the next send input will be the result of last yield, just like m is : %s, s_return1 is : %s, s_return2 is : %s" % (m, s_return1, s_return2))
print ("not next send so n is undefind, n is : %s" % n)

运行结果：

===============test a()
===============g_obj test b: <generator object b at 0x7f740b7fc750>
just generator obj, not in b def
list generator will in def , print here...
list_g: [5]
===============g_obj test c: <generator object c at 0x7f740b7fc7e0>
===============g_obj test d: <generator object d at 0x7f740b7fc750>
send() will here... test generator send()
send input is m : send twice
the next send input will be the result of last yield, just like m is : send twice, s_return1 is : 5, s_return2 is : 6
Traceback (most recent call last):
  File "./yield0.py", line 40, in <module>
    print ("not next send so n is undefind, n is : %s" % n)
NameError: name 'n' is not defined

send用法说明：

关于输入：send的输入是本次遇到yield时，先赋值给yield表达式的结果。有点难懂，详细说明。

如m = yield 5，这个表达式，是分两次yield完成的，第一次执行后一半，即返回5，下次send时，才执行前一半，即把后一次send的输入赋值给m。
所以，第一次使用send，输入必须是None，开启生成器，因为本次遇到yield后，yield返回后，就完结了，并没有一个执行到赋值给m的过程。m的初值是第二个send()输入参数。
最后一个最后一个send，把输入给了上一次yield表达式，所以最后一个n=yield 6，语句执行后，n是未定义的。

关于输出：比较简单，就是yield的结果。如s_return = send(None)，由于yield 5，所以s_return= 5

send(msg) 与 next()

　　了解了next()如何让包含yield的函数执行后，我们再来看另外一个非常重要的函数send(msg)。其实next()和send()在一定意义上作用是相似的，区别是send()可以传递yield表达式的值进去，而next()不能传递特定的值，只能传递None进去。因此，我们可以看做c.next() 和 c.send(None) 作用是一样的。来看这个例子：

def h():  
print 'Wen Chuan',  
m = yield 5 # Fighting!  
print m  
d = yield 12  
print 'We are together!'  
c = h()  
c.next() #相当于c.send(None)  
c.send('Fighting!') #(yield 5)表达式被赋予了'Fighting!'

输出的结果为：  
Wen Chuan Fighting!

　　需要提醒的是，第一次调用时，请使用next()语句或是send(None)，不能使用send发送一个非None的值，否则会出错的，因为没有Python yield语句来接收这个值。

send(msg) 与 next()的返回值

def h():  
print 'Wen Chuan',  
m = yield 5 # Fighting!  
print m  
d = yield 12  
print 'We are together!'  
c = h()  
m = c.next() #m 获取了yield 5 的参数值 5  
d = c.send('Fighting!') #d 获取了yield 12 的参数值12  
print 'We will never forget the date', m, '.', d

输出结果：  
Wen Chuan Fighting!  
We will never forget the date 5 . 12

throw() 与 close()中断 Generator

中断Generator是一个非常灵活的技巧，可以通过throw抛出一个GeneratorExit异常来终止Generator。Close()方法作用是一样的，其实内部它是调用了throw(GeneratorExit)的。我们看：

def close(self):  
try:  
self.throw(GeneratorExit)  
except (GeneratorExit, StopIteration):  
pass  
else:  
raise RuntimeError("generator ignored GeneratorExit")  
# Other exceptions are not caught

因此，当我们调用了close()方法后，再调用next()或是send(msg)的话会抛出一个异常：

Traceback (most recent call last):  
File "/home/evergreen/Codes/yidld.py", line 14, in <module> 
d = c.send('Fighting!') #d 获取了yield 12 的参数值12  
StopIteration

使用yield实现协程

举例：生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产。

#!/usr/bin/python

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

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

c = consumer()
produce(c)

运行结果：

[PRODUCER] Consumer first return: 
[PRODUCER] Producing 1...
[CONSUMER] Consuming 1...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 2...
[CONSUMER] Consuming 2...
[PRODUCER] Consumer return: 200 OK

协程的说明：

注意到consumer函数是一个generator，把一个consumer传入produce后：

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

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

yield from基本用法

从python3.3新增语法yield from，在python3.4中asyncio的微线程的实现依赖此语法。

先从generator中套generator的需求入手。

举例：生成器调用子生成器，父生成器输入什么，调用完子生成器后，同样返回什么。

def i_yield_whatever_input_is():
    input = 0
    while True:
        print("1: before gi yield input=%s" % input)
        input = yield input
        print("2: after gi yield input=%s" % input)

def wrap_generator1():
    for i in i_yield_whatever_input_is():
        print("3: before g1 yield i=%s" % i)
        yield i

g = wrap_generator1()
print("4: after send None return: %s" % g.send(None))
print("4: after send 1 return: %s" % g.send(1))
print("4: after send 2 return: %s" % g.send(2))

未到达预期的运行结果：

1: before gi yield input=0
3: before g1 yield i=0
4: after send None return: 0
2: after gi yield input=None
1: before gi yield input=None
3: before g1 yield i=None
4: after send 1 return: None
2: after gi yield input=None
1: before gi yield input=None
3: before g1 yield i=None
4: after send 2 return: None

显然不是预期“输入什么，返回什么”。由于send的输入到wrap_generator后，无法输入给子生成器，因此，子生成器i_yield_whatever_input_is的输入是None，只能yield None。

　　使用yield from，可以将send的输入，传递给子生成器，父生成器代码修改如下：

def wrap_generator2():
    yield from i_yield_whatever_input_is()

g = wrap_generator2()
print("4: after send None return: %s" % g.send(None))
print("4: after send 1 return: %s" % g.send(1))
print("4: after send 2 return: %s" % g.send(2))

达到预期的运行结果：

1: before gi yield input=0
4: after send None return: 0
2: after gi yield input=1
1: before gi yield input=1
4: after send 1 return: 1
2: after gi yield input=2
1: before gi yield input=2
4: after send 2 return: 2

使用yield from实现asyncio

简单的例子（两个函数并发执行，函数内部的sleep不互相阻塞其它函数）：

#!/usr/bin/python
import asyncio
import threading

@asyncio.coroutine
def hello():
    print("2.1 befor yield from asyncio sleep")
    r = yield from asyncio.sleep(2)
    print("2.1 after yield from asyncio sleep")

def hello2():
    print("2.2 befor yield from asyncio sleep")
    r = yield from asyncio.sleep(5)
    print("2.2 after yield from asyncio sleep")

loop = asyncio.get_event_loop()
print ("1. after get event loop")

#loop.run_until_complete(hello())

tasks = [hello2(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
print ("2. after run")

loop.close()
print ("3. after close")

运行结果：

1. after get event loop
2.2 befor yield from asyncio sleep
2.1 befor yield from asyncio sleep
===等待两个函数sleep返回===
2.1 after yield from asyncio sleep
2.2 after yield from asyncio sleep
2. after run
3. after close

复杂的例子(并发同时访问多个WEB服务器)：

#!/usr/bin/python
import asyncio

@asyncio.coroutine
def wget(host):
    print("wget %s..." % host)
    connect = asyncio.open_connection(host, 80)
    reader, writer = yield from connect
    header = 'GET / HTTP/1.0\r\nHost: %s\r\n\r\n' % host
    writer.write(header.encode('utf-8')) #向服务器发送请求
    yield from writer.drain()
    while True:
        line = yield from reader.readline() #读取服务器返回的数据
        if line == b'\r\n':
            break
        print('%s header > %s' % (host, line.decode('utf-8').rstrip()))
    writer.close()

loop = asyncio.get_event_loop()
tasks = [wget(host) for host in ['www.baidu.com', 'www.sina.com'，'www.taobao.com']]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

运行结果：并发访问，服务器一旦返回，立即打印到屏幕。

wget www.baidu.com...
wget www.taobao.com...
wget www.sina.com...
www.baidu.com header > HTTP/1.1 200 OK
www.baidu.com header > Date: Fri, 12 Jun 2015 03:17:20 GMT
www.baidu.com header > Content-Type: text/html
www.baidu.com header > Content-Length: 14613
www.baidu.com header > Last-Modified: Wed, 03 Sep 2014 02:48:32 GMT
www.baidu.com header > Connection: Close
www.baidu.com header > Vary: Accept-Encoding
www.baidu.com header > Set-Cookie: BAIDUID=052DF57419E7322485FE496F7CFD60DF:FG=1; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
www.baidu.com header > Set-Cookie: BIDUPSID=052DF57419E7322485FE496F7CFD60DF; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
www.baidu.com header > Set-Cookie: PSTM=1434079040; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
www.baidu.com header > Set-Cookie: BDSVRTM=0; path=/
www.baidu.com header > P3P: CP=" OTI DSP COR IVA OUR IND COM "
www.baidu.com header > Server: BWS/1.1
www.baidu.com header > X-UA-Compatible: IE=Edge,chrome=1
www.baidu.com header > Pragma: no-cache
www.baidu.com header > Cache-control: no-cache
www.baidu.com header > BDPAGETYPE: 1
www.baidu.com header > BDQID: 0x82714a2100005cd6
www.baidu.com header > BDUSERID: 0
www.baidu.com header > Accept-Ranges: bytes
www.sina.com header > HTTP/1.1 301 Moved Permanently
www.sina.com header > Server: nginx
www.sina.com header > Date: Fri, 12 Jun 2015 03:15:36 GMT
www.sina.com header > Content-Type: text/html
www.sina.com header > Location: http://www.sina.com.cn/
www.sina.com header > Expires: Fri, 12 Jun 2015 03:17:36 GMT
www.sina.com header > Cache-Control: max-age=120
www.sina.com header > Age: 104
www.sina.com header > Content-Length: 178
www.sina.com header > X-Cache: HIT from ja180-186.sina.com.cn
www.sina.com header > Connection: close
www.taobao.com header > HTTP/1.1 200 OK
www.taobao.com header > Server: Tengine
www.taobao.com header > Date: Fri, 12 Jun 2015 03:17:20 GMT
www.taobao.com header > Content-Type: text/html; charset=gbk
www.taobao.com header > Connection: close
www.taobao.com header > Vary: Accept-Encoding
www.taobao.com header > Set-Cookie: CAT=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; Max-Age=0
www.taobao.com header > Set-Cookie: thw=cn; Path=/; Domain=.taobao.com; Expires=Sat, 11-Jun-16 03:17:20 GMT;