协程和生成器很像但还是有些许的不同，主要的不同之处在于：
生成器是数据生产者
协程是数据消费者
首先再看一下生成器
def fib():
a, b = 0, 1
while True:
yield a
a, b = b, a+b
然后可以使用for循环遍历
for i in fib():
print(i)
它是快速的，不会给内存带来很多压力因为它会动态生成值而不是将它们存储在列表中,现在，如果我们在上面的例子中使用yield，通常，就是一个协程。协程使用传给它的值。一个基本的例子如下：
def grep(pattern):
print("Searching for", pattern)
while True:
line = (yield)
if pattern in line:
print(line)
可以看到，协程中yield语句的形式。它不包含任何初始值，而是由我们额外提供。我们可以使用send方法来提供值给它。下面是个简单的例子:
def grep(pattern):
print("Searching for", pattern)
while True:
line = (yield)
if pattern in line:
print(line)
if __name__ == '__main__':
search = grep("cornator")
next(search) #output: ('Searching for', 'cornator')
search.send("I love px!")
search.send("I love px!")
search.send("I love px, cornator!") # output: I love px, cornator!
发送的值通过yield访问。使用next()方法的原因是，运行协程需要使用它。就像生成器，协程不会自动运行。而是作为next()和.send()方法的响应来运行它。因此，你需要运行next()来执行到yield表达式。
再看一例：
def averager():
total = 0.0
count = 0
average = None
while True:
term = yield average
total += term
count += 1
average = total/count
使用方法
>>> coro_avg = averager()
>>> next(coro_avg)
>>> coro_avg.send(10)
10.0
>>> coro_avg.send(30)
20.0
>>> coro_avg.send(5)
15.0
创建协程对象,调用 next 函数，预激协程.由于我们在使用协程之前都必须激活协程，所以，我们通常可以写一个装饰器，专门用于预激协程:
from functools import wraps
def coroutine(func):
"""装饰器：向前执行到第一个`yield`表达式，预激`func`"""
@wraps(func)
def primer(*args,**kwargs):
gen = func(*args,**kwargs)
next(gen)
return gen
return primer
这样我们就可以使用它了，使用方法如下：
from coroutil import coroutine #这里就是我们实现的装饰器函数
@coroutine
def averager():
total = 0.0
count = 0
average = None
while True:
term = yield average
total += term
count += 1
average = total/count
我们再使用该函数的时候就不用调用next方法了，而是直接使用。
coro_avg = averager()
coro_avg.send(10)
coro_avg.send(30)
顺便说一下yield from语法：
yield from x 表达式对x对象所做的第一件事就是调用iter(x),从中获取迭代器，因此，x可以是任何可迭代的对象。yield from的主要功能是打开双向通道，把最外面的调用方与最内层的子生成器连接起来，这样二者就可以直接发送和产出值，还可以直接传入异常。而不是在位于中间的协程中添加大量的处理异常的样板代码。有了这个结构，协程可以通过以前不可能的方式委托职责。
yield from 几大特征:
- 子生成器产出的值都直接传给委派生成器的调用方（即客户端代码）。
- 使用 send() 方法发给委派生成器的值都直接传给子生成器。如果发送的值是None，那么会调用子生成器的 next() 方法。如果发送的值不是 None，那么会调用子生成器的 send() 方法。如果调用的方法抛出StopIteration 异常，那么委派生成器恢复运行。任何其他异常都会向上冒泡，传给委派生成器。
- 生成器退出时，生成器（或子生成器）中的 return expr 表达式会触发StopIteration(expr) 异常抛出。
- yield from 表达式的值是子生成器终止时传给 StopIteration 异常的第一个参数。
- 传入委派生成器的异常，除了 GeneratorExit 之外都传给子生成器的 throw() 方法。如果调用 throw() 方法时抛出 StopIteration 异常，委派生成器恢复运行。StopIteration 之外的异常会向上冒泡，传给委派生成器。
- 如果把 GeneratorExit 异常传入委派生成器，或者在委派生成器上调用 close() 方法，那么在子生成器上调用 close() 方法，如果它有的话。如果调用 close() 方法导致异常抛出，那么异常会向上冒泡，传给委派生成器；否则，委派生成器抛出GeneratorExit 异常。
我们可以关闭协程通过调用.close()方法。
python3,中，协程可以使用asyncio模块实现，通过asnc def 声明语句或者使用生成器。async def 类型协程是在python3.5中加入的，版本支持的情况下，建议使用它。基于生成器的协程应该使用@asyncio.coroutine装饰器，尽管这不是强制的。
import asyncio
@asyncio.coroutine
def test():
print("never scheduled")
async def hello_world():
print("Hello World!")
loop = asyncio.get_event_loop()
asyncio.ensure_future(test())
# Blocking call which returns when the hello_world() coroutine is done
loop.run_until_complete(hello_world())
loop.close()
调用一个协程不在代码运行的时候开启，调用返回的协程对象不在任何事情，直到你的调度器开始执行。有两种基本的方式开启它的运行，调用await coroutine或者从其他coroutine中yield from coroutine，或者调度器执行ensure_future()函数或者 AbstractEventLoop.create_task()方法。
协程运行只有当事件轮休运行的时候运行。
import asyncio
async def compute(x, y):
print("Compute %s + %s ..." % (x, y))
await asyncio.sleep(1.0)
return x + y
async def print_sum(x, y):
result = await compute(x, y)
print("%s + %s = %s" % (x, y, result))
loop = asyncio.get_event_loop()
loop.run_until_complete(print_sum(1, 2))
loop.close()
添加回调函数
import asyncio
async def slow_operation(future):
await asyncio.sleep(1)
future.set_result('Future is done!')
def got_result(future):
print(future.result())
loop.stop()
loop = asyncio.get_event_loop()
future = asyncio.Future()
asyncio.ensure_future(slow_operation(future))
future.add_done_callback(got_result)
try:
loop.run_forever()
finally:
loop.close()
最后看一例：
@asyncio.coroutine
def supervisor():
spinner = asyncio.async(spin('thinking!'))
print('spinner object:', spinner)
result = yield from slow_function()
spinner.cancel()
return result
这里能安全地取消协程的原因是按照定义，协程只能在暂停的yield处取消，因此可以处理CancelledError异常，执行清除操作。