协程

对于上面的问题，我们希望去解决这样几个问题：

采用同步的方式去编写异步的代码，使代码的可读性高，更简便。
使用单线程去切换任务（就像单线程间函数之间的切换那样，速度超快）

　　　　　　（1）线程是由操作系统切换的，单线程的切换意味着我们需要程序员自己去调度任务。

　　　　　　（2）不需要锁，并发性高，如果单线程内切换函数，性能远高于线程切换，并发性更高。

例如我们在做爬虫的时候：

def get_url(url):
    html = get_html(url) # 此处网络下载IO操作比较耗时，希望切换到另一个函数去执行
    infos = parse_html(html)
# 下载url中的html
def get_html(url):
    pass
# 解析网页
def parse_html(html):
    pass

意味着我们需要一个可以暂停的函数，对于此函数可以向暂停的地方穿入值。（回忆我们的生成器函数就可以满足这两个条件）所以就引入了协程。

生成器进阶

生成器不仅可以产出值，还可以接收值，用send()方法。注意：在调用send()发送非None值之前必须先启动生成器，可以用①next()②send(None)两种方式激活

def gen_func():
    html = yield 'http://www.baidu.com' # yield 前面加=号就实现了1：可以产出值2：可以接受调用者传过来的值
    print(html)
    yield 2
    yield 3
    return 'bobby'
if __name__ == '__main__':
    gen = gen_func()
    url = next(gen)
    print(url)
    html = 'bobby'
    gen.send(html) # send方法既可以将值传递进生成器内部，又可以重新启动生成器执行到下一yield位置。

打印结果：
http://www.baidu.com
bobby

close()方法。

def gen_func():
    yield 'http://www.baidu.com' # yield 前面加=号就实现了1：可以产出值2：可以接受调用者传过来的值
    yield 2
    yield 3
    return 'bobby'
if __name__ == '__main__':
    gen = gen_func()
    url = next(gen)
    gen.close()
    next(gen)

输出结果：
StopIteration

特别注意：调用close.()之后，生成器在往下运行的时候就会产生出一个GeneratorExit，单数如果用try捕获异常的话，就算捕获了遇到后面还有yield的话，还是不能往下运行了，因为一旦调用close方法生成器就终止运行了（如果还有next，就会会产生一个异常）所以我们不要去try捕捉该异常。（此注意可以先忽略）

def gen_func():
    try:
        yield 'http://www.baidu.com' 
    except GeneratorExit:
        pass
    yield 2
    yield 3
    return 'bobby'
if __name__ == '__main__':
    gen = gen_func()
    print(next(gen))
    gen.close()
    next(gen)

输出结果：
RuntimeError: generator ignored GeneratorExit

调用throw()方法。用于抛出一个异常。该异常可以捕捉忽略。

def gen_func():
    yield 'http://www.baidu.com' # yield 前面加=号就实现了1：可以产出值2：可以接受调用者传过来的值
    yield 2
    yield 3
    return 'bobby'
if __name__ == '__main__':
    gen = gen_func()
    print(next(gen))
    gen.throw(Exception, 'Download Error')

输出结果：
 Download Error

yield from

先看一个函数：from itertools import chain

from itertools import chain
my_list = [1,2,3]
my_dict = {'frank':'yangchao', 'ailsa':'liuliu'}
for value in chain(my_list, my_dict, range(5,10)):  chain()方法可以传入多个可迭代对象，然后分别遍历之。
    print(value)

打印结果：
1
2
3
frank
ailsa
5
6
7
8
9

此函数可以用yield from 实现：yield from功能 1：从一个可迭代对象中将值逐个返回。

my_list = [1,2,3]
my_dict = {'frank':'yangchao', 'ailsa':'liuliu'}
def chain(*args, **kwargs):
    for itemrable in args:
        yield from itemrable
for value in chain(my_list, my_dict, range(5,10)):
    print(value)

看如下代码：

def gen():
    yield 1

def g1(gen):
    yield from gen

def main():
    g = g1(gen)
    g.send(None)

代码分析：此代码中main调用了g1， main就叫作调用方， g1叫做委托方， gen 叫做子生成器yield from将会在调用方main与子生成器gen之间建立一个双向通道。（意味着可以直接越过委托方）

例子：当委托方middle()中使用yield from 的时候，调用方main直接和子生成器sales_sum形成数据通道。

final_result = {}
def sales_sum(pro_name):
    total = 0
    nums = []
    while True:
        x = yield
        print(pro_name+'销量', x)
        if not x:
            break
        total += x
        nums.append(x)
    return total, nums #程序运行到return的时候，会将return的返回值返回给委托方，即middle中的final_result[key]
def middle(key):
    while True: #相当于不停监听sales_sum是否有返回数据，（本例中有三次返回）
        final_result[key] = yield from sales_sum(key)
        print(key +'销量统计完成！！')
def main():
    data_sets = {
        '面膜':[1200, 1500, 3000],
        '手机':[88, 100, 98, 108],
        '衣服':[280, 560,778,70],
    }

    for key, data_set in data_sets.items():
        print('start key', key)
        m = middle(key)
        m.send(None) # 预激生成器
        for value in data_set:
            m.send(value)
        m.send(None)# 发送一个None使sales_sum中的x值为None退出while循环
    print(final_result)
if __name__ == '__main__':
    main()

结果：
start key 面膜
面膜销量 1200
面膜销量 1500
面膜销量 3000
面膜销量 None
面膜销量统计完成！！
start key 手机
手机销量 88
手机销量 100
手机销量 98
手机销量 108
手机销量 None
手机销量统计完成！！
start key 衣服
衣服销量 280
衣服销量 560
衣服销量 778
衣服销量 70
衣服销量 None
衣服销量统计完成！！
{'面膜': (5700, [1200, 1500, 3000]), '手机': (394, [88, 100, 98, 108]), '衣服': (1688, [280, 560, 778, 70])}

　　也许有人会好奇，为什么不能直接用main()函数直接去调用sales_sum呢？加一个委托方使代码复杂化了。看以下直接用main()函数直接去调用sales_sum代码：

def sales_sum(pro_name):
    total = 0
    nums = []
    while True:
        x = yield
        print(pro_name+'销量', x)
        if not x:
            break
        total += 1
        nums.append(x)
    return total, nums

if __name__ == '__main__':
    my_gen = sales_sum('面膜')
    my_gen.send(None)
    my_gen.send(1200)
    my_gen.send(1500)
    my_gen.send(3000)
    my_gen.send(None)

输出结果：
面膜销量 1200
面膜销量 1500
面膜销量 3000
面膜销量 None
Traceback (most recent call last):
  File "D:/MyCode/Cuiqingcai/Flask/test01.py", line 56, in <module>
    my_gen.send(None)
StopIteration: (3, [1200, 1500, 3000])

从上述代码可以看出，即使数据return结果出来了，还是会返回一个exception，由此可以看出yield from的一个最大优点就是当子生成器运行时候出现异常，yield from可以直接自动处理这些异常。

yield from 功能总结：

子生成器生产的值，都是直接给调用方；调用发通过.send()发送的值都是直接传递给子生成器，如果传递None，会调用子生成器的next()方法，如果不是None，会调用子生成器的sen()方法。
子生成器退出的时候，最后的return EXPR，会触发一个StopIteration（EXPR）异常
yield from 表达式的值，是子生成器终止时，传递给StopIteration异常的第一个参数。
如果调用的时候出现了StopIteration异常，委托方生成器恢复运行，同时其他的异常向上冒泡。
传入委托生成器的异常里，除了GeneratorExit之后，其他所有异常全部传递给子生成器的.throw()方法；如果调用.throw()的时候出现StopIteration异常，那么就恢复委托生成器的运行，其他的异常全部向上冒泡
如果在委托生成器上调用.close()或传入GeneratorExit异常，会调用子生成器的.close()方法，没有就不调用，如果在调用.close()时候抛出了异常，那么就向上冒泡，否则的话委托生成器跑出GeneratorExit 异常。

来源：https://www.cnblogs.com/yc3110/p/10443108.html

标签

python协程