1 协程
协程（Coroutine），也可以被称为微线程，是一种用户态内的上下文切换技术。简而言之，其实就是通过一个线程实现代码块相互切换执行。例如：
deffunc1():print(1)...print(2)deffunc2():print(3)...print(4)
func1()
func2()上述代码是普通的函数定义和执行，按流程分别执行两个函数中的代码，并先后会输出：1、2、3、4。但如果介入协程技术那么就可以实现函数见代码切换执行，最终输入：1、3、2、4 。
在Python中有多种方式可以实现协程，例如：
- greenlet，是一个第三方模块，用于实现协程代码（Gevent协程就是基于greenlet实现）
- yield，生成器，借助生成器的特点也可以实现协程代码。
- asyncio，在Python3.4中引入的模块用于编写协程代码。
- async & awiat，在Python3.5中引入的两个关键字，结合asyncio模块可以更方便的编写协程代码。
1.1 greenlet
greentlet是一个第三方模块，需要提前安装 pip3 install greenlet才能使用。
from greenletimport greenletdeffunc1():print(1)# 第1步：输出 1
gr2.switch()# 第3步：切换到 func2 函数print(2)# 第6步：输出 2
gr2.switch()# 第7步：切换到 func2 函数，从上一次执行的位置继续向后执行deffunc2():print(3)# 第4步：输出 3
gr1.switch()# 第5步：切换到 func1 函数，从上一次执行的位置继续向后执行print(4)# 第8步：输出 4
gr1= greenlet(func1)
gr2= greenlet(func2)
gr1.switch()# 第1步：去执行 func1 函数注意：switch中也可以传递参数用于在切换执行时相互传递值。
1.2 yield
基于Python的生成器的yield和yield form关键字实现协程代码。
deffunc1():yield1yieldfrom func2()yield2deffunc2():yield3yield4
f1= func1()for itemin f1:print(item)1.3 asyncio
在Python3.4之前官方未提供协程的类库，一般大家都是使用greenlet等其他来实现。在Python3.4发布后官方正式支持协程，即：asyncio模块。
import asyncio
@asyncio.coroutinedeffunc1():print(1)yieldfrom asyncio.sleep(2)# 遇到IO耗时操作，自动化切换到tasks中的其他任务print(2)
@asyncio.coroutinedeffunc2():print(3)yieldfrom asyncio.sleep(2)# 遇到IO耗时操作，自动化切换到tasks中的其他任务print(4)
tasks=[
asyncio.ensure_future( func1()),
asyncio.ensure_future( func2())]
loop= asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))注意：基于asyncio模块实现的协程比之前的要更厉害，因为他的内部还集成了遇到IO耗时操作自动切花的功能。
1.4 async & awit
async & awit 关键字在Python3.5版本中正式引入，基于他编写的协程代码其实就是 上一示例 的加强版，让代码可以更加简便。
Python3.8之后@asyncio.coroutine 装饰器就会被移除，推荐使用async & awit 关键字实现协程代码。
import asyncioasyncdeffunc1():print(1)await asyncio.sleep(2)print(2)asyncdeffunc2():print(3)await asyncio.sleep(2)print(4)
tasks=[
asyncio.ensure_future(func1()),
asyncio.ensure_future(func2())]
loop= asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))1.5 小结
关于协程有多种实现方式，目前主流使用是Python官方推荐的asyncio模块和async&await关键字的方式，例如：在tonado、sanic、fastapi、django3 中均已支持。
接下来，我们也会针对 asyncio模块 + async & await 关键字进行更加详细的讲解。
2.协程的意义
通过学习，我们已经了解到协程可以通过一个线程在多个上下文中进行来回切换执行。
但是，协程来回切换执行的意义何在呢？
- 计算型的操作，利用协程来回切换执行，没有任何意义，来回切换并保存状态 反倒会降低性能。
- IO型的操作，利用协程在IO等待时间就去切换执行其他任务，当IO操作结束后再自动回调，那么就会大大节省资源并提供性能，从而实现异步编程（不等待任务结束就可以去执行其他代码）。
2.1 爬虫案例
例如：用代码实现下载 url_list 中的图片。
- 方式一：同步编程实现
"""
下载图片使用第三方模块requests，请提前安装：pip3 install requests
"""import requestsdefdownload_image(url):print("开始下载:",url)# 发送网络请求，下载图片
response= requests.get(url)print("下载完成")# 图片保存到本地文件
file_name= url.rsplit('_')[-1]withopen(file_name, mode='wb')as file_object:
file_object.write(response.content)if __name__=='__main__':
url_list=['https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg','https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg','https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg']for itemin url_list:
download_image(item)- 方式二：基于协程的异步编程实现
"""
下载图片使用第三方模块aiohttp，请提前安装：pip3 install aiohttp
"""#!/usr/bin/env python# -*- coding:utf-8 -*-import aiohttpimport asyncioasyncdeffetch(session, url):print("发送请求：", url)asyncwith session.get(url, verify_ssl=False)as response:
content=await response.content.read()
file_name= url.rsplit('_')[-1]withopen(file_name, mode='wb')as file_object:
file_object.write(content)asyncdefmain():asyncwith aiohttp.ClientSession()as session:
url_list=['https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg','https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg','https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg']
tasks=[asyncio.create_task(fetch(session, url))for urlin url_list]await asyncio.wait(tasks)if __name__=='__main__':
asyncio.run(main())上述两种的执行对比之后会发现，基于协程的异步编程 要比 同步编程的效率高了很多。因为：
- 同步编程，按照顺序逐一排队执行，如果图片下载时间为2分钟，那么全部执行完则需要6分钟。
- 异步编程，几乎同时发出了3个下载任务的请求（遇到IO请求自动切换去发送其他任务请求），如果图片下载时间为2分钟，那么全部执行完毕也大概需要2分钟左右就可以了。
2.2 小结
协程一般应用在有IO操作的程序中，因为协程可以利用IO等待的时间去执行一些其他的代码，从而提升代码执行效率。
生活中不也是这样的么，假设 你是一家制造汽车的老板，员工点击设备的【开始】按钮之后，在设备前需等待30分钟，然后点击【结束】按钮，此时作为老板的你一定希望这个员工在等待的那30分钟的时间去做点其他的工作。
3.异步编程
基于async & await关键字的协程可以实现异步编程，这也是目前python异步相关的主流技术。
想要真正的了解Python中内置的异步编程，根据下文的顺序一点点来看。
3.1 事件循环
事件循环，可以把他当做是一个while循环，这个while循环在周期性的运行并执行一些任务，在特定条件下终止循环。
# 伪代码
任务列表=[ 任务1, 任务2, 任务3,...]while True:
可执行的任务列表，已完成的任务列表= 去任务列表中检查所有的任务，将'可执行'和'已完成'的任务返回for 就绪任务 in 已准备就绪的任务列表:
执行已就绪的任务for 已完成的任务 in 已完成的任务列表:
在任务列表中移除 已完成的任务
如果 任务列表 中的任务都已完成，则终止循环在编写程序时候可以通过如下代码来获取和创建事件循环。
import asyncio
loop= asyncio.get_event_loop()3.2 协程和异步编程
协程函数，定义形式为 async def 的函数。
协程对象，调用 协程函数 所返回的对象。
# 定义一个协程函数asyncdeffunc():pass# 调用协程函数，返回一个协程对象
result= func()注意：调用协程函数时，函数内部代码不会执行，只是会返回一个协程对象。
3.2.1 基本应用
程序中，如果想要执行协程函数的内部代码，需要 事件循环 和 协程对象 配合才能实现，如：
import asyncioasyncdeffunc():print("协程内部代码")# 调用协程函数，返回一个协程对象。
result= func()# 方式一# loop = asyncio.get_event_loop() # 创建一个事件循环# loop.run_until_complete(result) # 将协程当做任务提交到事件循环的任务列表中，协程执行完成之后终止。# 方式二# 本质上方式一是一样的，内部先 创建事件循环 然后执行 run_until_complete，一个简便的写法。# asyncio.run 函数在 Python 3.7 中加入 asyncio 模块，
asyncio.run(result)这个过程可以简单理解为：将协程当做任务添加到 事件循环 的任务列表，然后事件循环检测列表中的协程是否 已准备就绪（默认可理解为就绪状态），如果准备就绪则执行其内部代码。
3.2.2 await
await是一个只能在协程函数中使用的关键字，用于遇到IO操作时挂起 当前协程（任务），当前协程（任务）挂起过程中 事件循环可以去执行其他的协程（任务），当前协程IO处理完成时，可以再次切换回来执行await之后的代码。代码如下：
示例1：
import asyncioasyncdeffunc():print("执行协程函数内部代码")# 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。# 当前协程挂起时，事件循环可以去执行其他协程（任务）。
response=await asyncio.sleep(2)print("IO请求结束，结果为：", response)
result= func()
asyncio.run(result)示例2：
import asyncioasyncdefothers():print("start")await asyncio.sleep(2)print('end')return'返回值'asyncdeffunc():print("执行协程函数内部代码")# 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。当前协程挂起时，事件循环可以去执行其他协程（任务）。
response=await others()print("IO请求结束，结果为：", response)
asyncio.run( func())示例3：
import asyncioasyncdefothers():print("start")await asyncio.sleep(2)print('end')return'返回值'asyncdeffunc():print("执行协程函数内部代码")# 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。当前协程挂起时，事件循环可以去执行其他协程（任务）。
response1=await others()print("IO请求结束，结果为：", response1)
response2=await others()print("IO请求结束，结果为：", response2)
asyncio.run( func())上述的所有示例都只是创建了一个任务，即：事件循环的任务列表中只有一个任务，所以在IO等待时无法演示切换到其他任务效果。
在程序想要创建多个任务对象，需要使用Task对象来实现。
3.2.3 Task对象
Tasks用于并发调度协程，通过asyncio.create_task(协程对象)的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除了使用 asyncio.create_task() 函数以外，还可以用低层级的 loop.create_task() 或 ensure_future() 函数。不建议手动实例化 Task 对象。
本质上是将协程对象封装成task对象，并将协程立即加入事件循环，同时追踪协程的状态。
注意：asyncio.create_task() 函数在 Python 3.7 中被加入。在 Python 3.7 之前，可以改用低层级的 asyncio.ensure_future() 函数。
示例1：
import asyncioasyncdeffunc():print(1)await asyncio.sleep(2)print(2)return"返回值"asyncdefmain():print("main开始")# 创建协程，将协程封装到一个Task对象中并立即添加到事件循环的任务列表中，等待事件循环去执行（默认是就绪状态）。
task1= asyncio.create_task(func())# 创建协程，将协程封装到一个Task对象中并立即添加到事件循环的任务列表中，等待事件循环去执行（默认是就绪状态）。
task2= asyncio.create_task(func())print("main结束")# 当执行某协程遇到IO操作时，会自动化切换执行其他任务。# 此处的await是等待相对应的协程全都执行完毕并获取结果
ret1=await task1
ret2=await task2print(ret1, ret2)
asyncio.run(main())示例2：
import asyncioasyncdeffunc():print(1)await asyncio.sleep(2)print(2)return"返回值"asyncdefmain():print("main开始")# 创建协程，将协程封装到Task对象中并添加到事件循环的任务列表中，等待事件循环去执行（默认是就绪状态）。# 在调用
task_list=[
asyncio.create_task(func(), name="n1"),
asyncio.create_task(func(), name="n2")]print("main结束")# 当执行某协程遇到IO操作时，会自动化切换执行其他任务。# 此处的await是等待所有协程执行完毕，并将所有协程的返回值保存到done# 如果设置了timeout值，则意味着此处最多等待的秒，完成的协程返回值写入到done中，未完成则写到pending中。
done, pending=await asyncio.wait(task_list, timeout=None)print(done, pending)
asyncio.run(main())注意：asyncio.wait 源码内部会对列表中的每个协程执行ensure_future从而封装为Task对象，所以在和wait配合使用时task_list的值为[func(),func()] 也是可以的
示例3：
import asyncioasyncdeffunc():print("执行协程函数内部代码")# 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。当前协程挂起时，事件循环可以去执行其他协程（任务）。
response=await asyncio.sleep(2)print("IO请求结束，结果为：", response)
coroutine_list=[func(), func()]# 错误：coroutine_list = [ asyncio.create_task(func()), asyncio.create_task(func()) ]# 此处不能直接 asyncio.create_task，因为将Task立即加入到事件循环的任务列表，# 但此时事件循环还未创建，所以会报错。# 使用asyncio.wait将列表封装为一个协程，并调用asyncio.run实现执行两个协程# asyncio.wait内部会对列表中的每个协程执行ensure_future，封装为Task对象。
done,pending= asyncio.run( asyncio.wait(coroutine_list))3.2.4 asyncio.Future对象
asyncio中的Future对象是一个相对更偏向底层的可对象，通常我们不会直接用到这个对象，而是直接使用Task对象来完成任务的并和状态的追踪。（ Task 是 Futrue的子类 ）
Future为我们提供了异步编程中的 最终结果 的处理（Task类也具备状态处理的功能）。
示例1：
asyncdefmain():# 获取当前事件循环
loop= asyncio.get_running_loop()# # 创建一个任务（Future对象），这个任务什么都不干。
fut= loop.create_future()# 等待任务最终结果（Future对象），没有结果则会一直等下去。await fut
asyncio.run(main())示例2：
import asyncioasyncdefset_after(fut):await asyncio.sleep(2)
fut.set_result("666")asyncdefmain():# 获取当前事件循环
loop= asyncio.get_running_loop()# 创建一个任务（Future对象），没绑定任何行为，则这个任务永远不知道什么时候结束。
fut= loop.create_future()# 创建一个任务（Task对象），绑定了set_after函数，函数内部在2s之后，会给fut赋值。# 即手动设置future任务的最终结果，那么fut就可以结束了。await loop.create_task(set_after(fut))# 等待 Future对象获取 最终结果，否则一直等下去
data=await futprint(data)
asyncio.run(main())Future对象本身函数进行绑定，所以想要让事件循环获取Future的结果，则需要手动设置。而Task对象继承了Future对象，其实就对Future进行扩展，他可以实现在对应绑定的函数执行完成之后，自动执行set_result，从而实现自动结束。
虽然，平时使用的是Task对象，但对于结果的处理本质是基于Future对象来实现的。
扩展：支持 await 对象语 法的对象课成为可等待对象，所以 协程对象、Task对象、Future对象 都可以被成为可等待对象。
3.2.5 futures.Future对象
在Python的concurrent.futures模块中也有一个Future对象，这个对象是基于线程池和进程池实现异步操作时使用的对象。
import timefrom concurrent.futuresimport Futurefrom concurrent.futures.threadimport ThreadPoolExecutorfrom concurrent.futures.processimport ProcessPoolExecutordeffunc(value):
time.sleep(1)print(value)
pool= ThreadPoolExecutor(max_workers=5)# 或 pool = ProcessPoolExecutor(max_workers=5)for iinrange(10):
fut= pool.submit(func, i)print(fut)两个Future对象是不同的，他们是为不同的应用场景而设计，例如：concurrent.futures.Future不支持await语法 等。
其实，一般在程序开发中我们要么统一使用 asycio 的协程实现异步操作、要么都使用进程池和线程池实现异步操作。但如果 协程的异步和 进程池/线程池的异步 混搭时，那么就会用到此功能了。
import timeimport asyncioimport concurrent.futuresdeffunc1():# 某个耗时操作
time.sleep(2)return"SB"asyncdefmain():
loop= asyncio.get_running_loop()# 1. Run in the default loop's executor ( 默认ThreadPoolExecutor )# 第一步：内部会先调用 ThreadPoolExecutor 的 submit 方法去线程池中申请一个线程去执行func1函数，并返回一个concurrent.futures.Future对象# 第二步：调用asyncio.wrap_future将concurrent.futures.Future对象包装为asycio.Future对象。# 因为concurrent.futures.Future对象不支持await语法，所以需要包装为 asycio.Future对象 才能使用。
fut= loop.run_in_executor(None, func1)
result=await futprint('default thread pool', result)# 2. Run in a custom thread pool:# with concurrent.futures.ThreadPoolExecutor() as pool:# result = await loop.run_in_executor(# pool, func1)# print('custom thread pool', result)# 3. Run in a custom process pool:# with concurrent.futures.ProcessPoolExecutor() as pool:# result = await loop.run_in_executor(# pool, func1)# print('custom process pool', result)
asyncio.run(main())应用场景：当项目以协程式的异步编程开发时，如果要使用一个第三方模块，而第三方模块不支持协程方式异步编程时，就需要用到这个功能，例如：
import asyncioimport requestsasyncdefdownload_image(url):# 发送网络请求，下载图片（遇到网络下载图片的IO请求，自动化切换到其他任务）print("开始下载:", url)
loop= asyncio.get_event_loop()# requests模块默认不支持异步操作，所以就使用线程池来配合实现了。
future= loop.run_in_executor(None, requests.get, url)
response=await futureprint('下载完成')# 图片保存到本地文件
file_name= url.rsplit('_')[-1]withopen(file_name, mode='wb')as file_object:
file_object.write(response.content)if __name__=='__main__':
url_list=['https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg','https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg','https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg']
tasks=[download_image(url)for urlin url_list]
loop= asyncio.get_event_loop()
loop.run_until_complete( asyncio.wait(tasks))3.2.6 异步迭代器
什么是异步迭代器
实现了–aiter–() 和–anext–() 方法的对象。–anext– 必须返回一个 awaitable 对象。async for 会处理异步迭代器的–anext–() 方法所返回的可等待对象，直到其引发一个 StopAsyncIteration 异常。
什么是异步可迭代对象？
可在 async for 语句中被使用的对象。必须通过它的–aiter–() 方法返回一个 asynchronous iterator。
import asyncioclassReader(object):""" 自定义异步迭代器（同时也是异步可迭代对象） """def__init__(self):
self.count=0asyncdefreadline(self):# await asyncio.sleep(1)
self.count+=1if self.count==100:returnNonereturn self.countdef__aiter__(self):return selfasyncdef