yield有两个意思，一个是生产，一个是退让，对于Python生成器的yield来说，这两个含义都成立。yield这个关键字，既可以在生成器中产生一个值，传输给调用方，同时也可以从调用方那获取一个值，在生成器内部使用。此外，yield还会作出让步，暂停生成器，让调用方继续工作，直到调用方需要下一个数据时，调用方则陷入等待直到成器提供给调用方所需的数据，如此循环往复。乍一听，有点像多线程，不明白多线程的同学也不要紧张，可以简单的解释一下多线程
解释多线程之前，我们先解释一下进程，进程可以看成是电脑里运行的一个实例，比方说，我运行一个浏览器，是一个进程，运行QQ，同样也是进程，我用浏览器浏览网站，用浏览器听音乐和下载东西，可以看成浏览器这个进程，里面有3个线程同时在为我做浏览网站，播放音乐还有下载文件。而我用QQ和人聊天，同时我又用QQ给人传输文件，同样也是在QQ这个进程中，有两个线程在为我传输聊天内容，同时传输文件。当然，上述说的并不严谨，只是为了好理解，因为对于像浏览器或者QQ这样的进程，每时每秒可能有成百上千的线程在运行，有可能记录日志或者其他
而协程相比于线程，最大的区别在于，协程不需要像线程那样来回的中断切换，也不需要线程的锁机制，因为线程中断或者锁机制都会对性能问题造成影响，所以协程的性能相比于线程，性能有明显的提高，尤其在线程越多的时候，优势越明显
下面用个例子来看一下协程的运作：
def simple_coroutine():
for i in range(3):
x = yield i + 1 # <1>
print("从调用方获取的值:%s" % x)
my_coro = simple_coroutine() # <2>
first = next(my_coro) # <3>
for i in range(5): # <4>
try:
y = my_coro.send(i) # <5>
print("从生成器中获取的值:%s" % y)
except StopIteration:
print("生成器的值拉取完毕") # <6>
print("生成器最初获取的值:%s" % first)
运行结果：
从调用方获取的值:0 从生成器中获取的值:2 从调用方获取的值:1 从生成器中获取的值:3 从调用方获取的值:2 生成器的值拉取完毕 生成器的值拉取完毕 生成器的值拉取完毕 生成器最初获取的值:1
我们先来说一下程序的运行过程，先看程序中<2>处的代码，传统的概念中，我先执行了my_coro = simple_coroutine() 这块代码，所以会理所当然的认为， simple_coroutine() 这个方法要先执行完毕才能接着执行后续的代码，但实际上不是，因为yield会标明这个方法是一个生成器，所以在程序的最初，他不会先执行完毕 simple_coroutine() 方法，而是把my_coro 这个变量声明称一个生成器，跳过simple_coroutine() ，接着执行后续代码
Python将my_coro 声明称一个生成器后，调用了<3>处的next(my_coro) ，这个方法才开始会顺序执行simple_coroutine()方法中的代码，在Python解释器执行simple_coroutine()方法时，遇到yield关键字，生成器将会陷入等待，这时候解释器会跳到生成器之外，也就是<3>之后的代码，我们调用生成器的send()方法，并传输一个值，这时候Python解释器会从外部的代码重新跳回simple_coroutine() 方法，中在之前停留的地方继续执行
他会将外部传来的值赋给x变量，并顺序执行，直到遇到下一个yield，再像之前那样跳出方法外
由于生成器能提供的值有限，所以当simple_coroutine()方法中执行了3次循环，生成器已经没有多余的值可供调用方获取了，所以每次调用生成器的send()方法，都会抛出StopIteration异常
这里有一点要注意，要激活一个生成器，一定要调用next()方法，而不是调用生成器的send()方法，如果直接调用send()方法会报错
协程有四种状态，分别是
GEN_CREATED：等待执行
GEN_RUNNING：解释器执行
GEN_SUSPENDED：在yield表达式处暂停
GEN_CLOSED：执行结束
协程的状态可以用inspect.getgeneratorstate()函数来确定，来看下面的例子：
from inspect import getgeneratorstate
from time import sleep
import threading
def get_state(coro):
print("其他线程生成器状态:%s", getgeneratorstate(coro)) # <1>
def simple_coroutine():
for i in range(3):
sleep(0.5)
x = yield i + 1 # <1>
my_coro = simple_coroutine()
print("生成器初始状态:%s" % getgeneratorstate(my_coro)) # <2>
first = next(my_coro)
for i in range(5):
try:
my_coro.send(i)
print("主线程生成器初始状态:%s" % getgeneratorstate(my_coro)) # <3>
t = threading.Thread(target=get_state, args=(my_coro,))
t.start()
except StopIteration:
print("生成器的值拉取完毕")
print("生成器最后状态:%s" % getgeneratorstate(my_coro)) # <4>
执行结果：
生成器初始状态:GEN_CREATED 生成器状态:%s GEN_SUSPENDED 生成器状态:%s GEN_SUSPENDED 生成器的值拉取完毕 生成器的值拉取完毕 生成器的值拉取完毕 生成器最后状态:GEN_CLOSED
<2>处，在激活协程之前，协程的状态是GEN_CREATED，而执行next()之后，以及在调用生成器send()之间，我分主线程也就是调用方和多线程去观察协程的状态，结果状态都是GEN_SUSPENDED，也就是协程处于暂停的状态，我原本想用多线程去捕捉协程的运行态，结果即便是多线程捕捉协程也是GEN_SUSPENDED，而GEN_RUNNING也说明，只有带解释器在运行协程的时候，协程的状态才是GEN_RUNNING，最后是GEN_CLOSED，我们拉取完协程的值后，协程的状态就变为执行结束
示例：使用协程计算平均值
我们可以开发一个协程，不断的往协程发送值，并且让协程累计之前的值并计算平均值，如下：
from functools import wraps
def coroutine(func):
@wraps(func)
def primer(*args, **kwargs):
gen = func(*args, **kwargs)
next(gen)
return gen
return primer
@coroutine # <1>
def averager():
total = .0
count = 0
average = None
while True:
term = yield average
total += term
count += 1
average = total / count
try:
coro_avg = averager()
print(coro_avg.send(10))
print(coro_avg.send(20))
print(coro_avg.send(30))
coro_avg.close() # <2>
print(coro_avg.send(40))
except StopIteration:
print("协程已结束")
运行结果：
10.0 15.0 20.0 协程已结束
在<1>处，我们用一个装饰器来预先激活协程，而不是之后再调用方里执行一个next()函数。然后，我们不断往协程里传10、20、30，而协程不断累计传入的值，并计算所有值的平均值返回给调用方，最后，我们在<2>处调用协程的close()函数，关闭协程，再调用send()方法，会发现抛出StopIteration异常
当发送给协程不是数字，会导致协程内部有异常抛出
for i in range(1, 6):
try:
print(coro_avg.send(i))
if i % 3 == 0:
coro_avg.send('')
except StopIteration:
print("协程已结束")
except TypeError:
print("传入值异常")
运行结果：
1.0 1.5 2.0 传入值异常 协程已结束 协程已结束
我们设置，当i为3的时候，多传入一个空字符串，结果协程抛出类型错误，协程将运行状态改为结束，之后再往协程传值，都抛出StopIteration异常
我们可以让协程处理一些特定的异常，比如：
class DemoException(Exception): # <1>
pass
def demo_exec_handling():
print("coroutine started")
while True:
try:
x = yield # <2>
except DemoException: # <3>
print("DemoException handled")
else:
print("coroutine received:{}".format(x))
运行结果
>>> exec_coro = demo_exec_handling() >>> next(exec_coro) coroutine started >>> print(exec_coro.send(1)) coroutine received:1 None >>> exec_coro.send(2) coroutine received:2 >>> exec_coro.send(3) coroutine received:3 >>> exec_coro.throw(DemoException) DemoException handled >>> exec_coro.send(4) coroutine received:4 >>> exec_coro.throw(ZeroDivisionError) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 5, in demo_exec_handling ZeroDivisionError >>> exec_coro.send(5) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
<1>处的DemoException是用来测试协程的，首先我们可以看到，当yield右边没有任何式子时，返回给调用方的是一个None对象，其次如果我们调用throw()方法将异常传入协程，因为协程里有关于DemoException的捕捉，所以协程会继续执行，当我们继续传入ZeroDivisionError，则协程结束
让协程返回值
我们可以改造之前的averager()函数，使它可以返回一个对象，对象里有count和average两个属性
from collections import namedtuple
Result = namedtuple("Result", ["count", "average"])
def averager():
total = .0
count = 0
average = None
while True:
term = yield average
if term is None:
break
total += term
count += 1
average = total / count
return Result(count, average)
运行结果：
>>> coro_avg = averager()
>>> next(coro_avg)
>>> coro_avg.send(10)
10.0
>>> coro_avg.send(20)
15.0
>>> coro_avg.send(30)
20.0
>>> coro_avg.send(None)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration: Result(count=3, average=20.0)
当我们发送None的时候，协程结束，返回结果，一如既往，生成器会抛出StopIteration异常，异常对象的value属性保存着返回值，为了获取返回值，我们还要再修改一下代码
try:
coro_avg = averager()
next(coro_avg)
coro_avg.send(10)
coro_avg.send(20)
coro_avg.send(30)
coro_avg.send(None)
except StopIteration as exc:
result = exc.value
print(result)
运行结果：
Result(count=3, average=20.0)
结语：关于协程yield结构这一块，到此暂做结束，下一章会介绍协程的yield from结构，yield from结构会在内部自动捕获StopIteration异常，还会把协程的返回值变成yield from表达式的值，下一章节将会讨论yield from的结构和用法，谢谢大家