这篇文章主要介绍了python中怎么实现协程的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇python中怎么实现协程文章都会有所收获，下面我们一起来看看吧。

协程(Coroutine)，又称微线程，纤程。(协程是一种用户态的轻量级线程)

作用：在执行 A 函数的时候，可以随时中断，去执行 B 函数，然后中断B函数，继续执行 A 函数 （可以自动切换），但这一过程并不是函数调用（没有调用语句），过程很像多线程，然而协程只有一个线程在执行

通俗的理解：在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定

在实现多任务时, 线程切换从系统层面远不止保存和恢复 CPU上下文这么简单。 操作系统为了程序运行的高效性每个线程都有自己缓存Cache等等数据，操作系统还会帮你做这些数据的恢复操作。 所以线程的切换非常耗性能。但是协程的切换只是单纯的操作CPU的上下文，所以一秒钟切换个上百万次系统都抗的住。

必须在只有一个单线程里实现并发

修改共享数据不需加锁

用户程序里自己保存多个控制流的上下文栈

一个协程遇到 IO 操作自动切换到其它协程

由于自身带有上下文和栈，无需线程上下文切换的开销,属于程序级别的切换，操作系统完全感知不到，因而更加轻量级

无需原子操作的锁定及同步的开销

方便切换控制流，简化编程模型

单线程内就可以实现并发的效果，最大限度地利用 cpu，且可扩展性高，成本低

无法利用多核资源：协程的本质是个单线程,它不能同时将 单个 CPU 的多个核用上,协程需要和进程配合才能运行在多 CPU 上

进行阻塞（Blocking）操作（如 IO 时）会阻塞掉整个程序

计算型的操作，利用协程来回切换执行，没有任何意义，来回切换并保存状态 反倒会降低性能。

greenlet，是一个第三方模块，用于实现协程代码（Gevent协程就是基于greenlet实现）

yield，生成器，借助生成器的特点也可以实现协程代码。

asyncio，在Python3.4中引入的模块用于编写协程代码。

async & awiat，在Python3.5中引入的两个关键字，结合asyncio模块可以更方便的编写协程代码（推荐）。

协程实现的方式有多种，目前最流行的方式就是async&await，其他的方式了解即可，本文就介绍最流行的一种方式

使用协程需要了解2个，事件循环和定义协程函数

事件循环是一种处理多并发量的有效方式，可以理解为死循环，循环过程中去检测并执行某些代码，我们来看下面的伪代码

任务列表=[任务1，任务2，任务3............]whileTrue:可执行的任务列表，已完成的任务列表=去任务列表中检查所有的任务，将'可执行'和'已完成'的任务返回for就绪任务in可执行的任务列表：执行已就绪的任务for已完成的任务in已完成的任务列表：在任务列表中移除已完成的任务如果任务列表中的任务都已完成，则终止循环

上面的伪代码的意思：获取事件循环中，然后不断监听任务列表，有任务就执行，执行完成的任务就移除，直到任务列表中的所有任务都完成，终止循环

使用事件循环的好处：使得程序员不用控制任务的添加、删除和事件的控制

代码中的写法如下：

importasyncio#获取事件循环loop=asyncio.get_event_loop()#将任务放到`任务列表`，监听事件循环loop.run_until_complete(任务)#关闭事件loop.close()协程函数和协程对象

想要定义协程函数，格式：async def 函数名协程对象：执行协程函数()得到的协程对象

#定义协程函数asyncdeffunc():pass#创建协程对象result=func()

注意：执行协程函数，创建协程对象，函数代码是不会运行的，如果想要运行协程函数的内部代码，必须要将协程对象交给事件循环来处理，看如下代码

importasyncioasyncdeffunc():print("你好")result=func()#方式1loop=asyncio.get_event_loop()loop.run_until_complete(result)#方式2asyncio.run(result)#python3.7写法await

await是一个只能在协程函数中使用的关键字，用于遇到IO操作时挂起 当前协程（任务），当前协程（任务）挂起过程中 事件循环可以去执行其他的协程（任务），当前协程IO处理完成时，可以再次切换回来执行await之后的代码。

举例：我们创建了2个任务，一个下载图片，一个下载视频，我们先执行下载图片任务，这时遇到io操作，正常情况下会等待图片下载完，但await可以先挂起下载图片任务，然后自动切换到下载视频任务

使用方法：await + 可等待对象（协程对象、Future对象、Task对象）

案例1

importasyncioasyncdeffunc():print("执行协程函数内部代码")#遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。#当前协程挂起时，事件循环可以去执行其他协程（任务）。response=awaitasyncio.sleep(2)print("IO请求结束，结果为：",response)result=func()asyncio.run(result)

案列2

importasyncioasyncdefothers():print("start")#④打印startawaitasyncio.sleep(2)#⑤等待耗时2秒，这过程中可以切换到其他协程中去print("end")#⑥打印endreturn'返回值'asyncdeffunc():print("执行协程函数内部代码")#②执行协程函数，打印print代码response=awaitothers()#③等待协程函数othersprint(f"io请求结束，结果为{response}")#⑦等待others结束后打印print语句if__name__=='__main__':asyncio.run(func())#①协程函数放入事件循环中运行

上述的所有示例都只是创建了一个任务，即：事件循环的任务列表中只有一个任务，所以在IO等待时无法演示切换到其他任务效果。在程序想要创建多个任务对象，需要使用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

importasyncioasyncdeffunc():print(1)awaitasyncio.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=awaittask1ret2=awaittask2print(ret1,ret2)asyncio.run(main())

案例await+任务列表（用的最多）

importasyncioasyncdeffunc():print(1)awaitasyncio.sleep(2)print(2)return"返回值"asyncdefmain():print("main开始")#创建协程，将协程封装到Task对象中并添加到事件循环的任务列表中，等待事件循环去执行（默认是就绪状态）。#在调用task_list=[asyncio.create_task(func()),asyncio.create_task(func())]print("main结束")#当执行某协程遇到IO操作时，会自动化切换执行其他任务。#此处的await是等待所有协程执行完毕，并将所有协程的返回值保存到done#如果设置了timeout值，则意味着此处最多等待的秒，完成的协程返回值写入到done中，未完成则写到pending中。done,pending=awaitasyncio.wait(task_list)print(done)asyncio.run(main())

注意：asyncio.wait源码内部会对列表中的每个协程执行ensure_future从而封装为Task对象，所以在和wait配合使用时task_list的值为[func(),func()]也是可以的。

asyncio中的Future对象是一个相对更偏向底层的可对象，通常我们不会直接用到这个对象，而是直接使用Task对象来完成任务的并和状态的追踪。（ Task 是 Futrue的子类 ）

Future为我们提供了异步编程中的 最终结果 的处理（Task类也具备状态处理的功能）

案例1

asyncdefmain():#获取当前事件循环loop=asyncio.get_running_loop()#创建一个任务（Future对象），这个任务什么都不干。fut=loop.create_future()#等待任务最终结果（Future对象），没有结果则会一直等下去。awaitfutasyncio.run(main())

结果就是程序一直在等待，无法结束

案例2

importasyncioasyncdefset_after(fut):awaitasyncio.sleep(2)fut.set_result("666")asyncdefmain():#获取当前事件循环loop=asyncio.get_running_loop()#创建一个任务（Future对象），没绑定任何行为，则这个任务永远不知道什么时候结束。fut=loop.create_future()#创建一个任务（Task对象），绑定了set_after函数，函数内部在2s之后，会给fut赋值。#即手动设置future任务的最终结果，那么fut就可以结束了。awaitloop.create_task(set_after(fut))#等待Future对象获取最终结果，否则一直等下去data=awaitfutprint(data)asyncio.run(main())

Future对象本身函数进行绑定，所以想要让事件循环获取Future的结果，则需要手动设置。而Task对象继承了Future对象，其实就对Future进行扩展，他可以实现在对应绑定的函数执行完成之后，自动执行set_result，从而实现自动结束。

虽然，平时使用的是Task对象，但对于结果的处理本质是基于Future对象来实现的。

在Python的concurrent.futures模块中也有一个Future对象，这个对象是基于线程池和进程池实现异步操作时使用的对象。

importtimefromconcurrent.futuresimportFuturefromconcurrent.futures.threadimportThreadPoolExecutorfromconcurrent.futures.processimportProcessPoolExecutordeffunc(value):time.sleep(1)print(value)pool=ThreadPoolExecutor(max_workers=5)#或pool=ProcessPoolExecutor(max_workers=5)foriinrange(10):fut=pool.submit(func,i)print(fut)

两个Future对象是不同的，他们是为不同的应用场景而设计，例如：concurrent.futures.Future不支持await语法 等。

在Python提供了一个将futures.Future对象包装成asyncio.Future对象的函数asynic.wrap_future。

接下里你肯定问：为什么python会提供这种功能？

其实，一般在程序开发中我们要么统一使用asycio的协程实现异步操作、要么都使用进程池和线程池实现异步操作。但如果 协程的异步和 进程池/线程池的异步 混搭时，那么就会用到此功能了。

importtimeimportasyncioimportconcurrent.futuresdeffunc1():#某个耗时操作time.sleep(2)return"OK"asyncdefmain():loop=asyncio.get_running_loop()#方式1.Runinthedefaultloop'sexecutor(默认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=awaitfutprint('defaultthreadpool',result)#方式2.Runinacustomthreadpool:#withconcurrent.futures.ThreadPoolExecutor()aspool:#result=awaitloop.run_in_executor(#pool,func1)#print('customthreadpool',result)#方式3.Runinacustomprocesspool:#withconcurrent.futures.ProcessPoolExecutor()aspool:#result=awaitloop.run_in_executor(#pool,func1)#print('customprocesspool',result)asyncio.run(main())

应用场景：当项目以协程式的异步编程开发时，如果要使用一个第三方模块，而第三方模块不支持协程方式异步编程时，就需要用到这个功能，例如requests模块：

importasyncioimportrequestsasyncdefdownload_image(url):#发送网络请求，下载图片（遇到网络下载图片的IO请求，自动化切换到其他任务）print("开始下载:",url)loop=asyncio.get_event_loop()#requests模块默认不支持异步操作，所以就使用线程池来配合实现了。future=loop.run_in_executor(None,requests.get,url)response=awaitfutureprint('下载完成')#图片保存到本地文件file_name=url.rsplit('_')[-1]withopen(file_name,mode='wb')asfile_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)forurlinurl_list]loop=asyncio.get_event_loop()loop.run_until_complete(asyncio.wait(tasks))异步迭代器什么是异步迭代器？

实现了__aiter__()和__anext__()方法的对象。__anext__必须返回一个awaitable对象。async for会处理异步迭代器的__anext__()方法所返回的可等待对象，直到其引发一个StopAsyncIteration异常。

可在async for语句中被使用的对象。必须通过它的__aiter__()方法返回一个asynchronous iterator。

importasyncioclassReader(object):"""自定义异步迭代器（同时也是异步可迭代对象）"""def__init__(self):self.count=0asyncdefreadline(self):#awaitasyncio.sleep(1)self.count+=1ifself.count==100:returnNonereturnself.countdef__aiter__(self):returnselfasyncdef__anext__(self):val=awaitself.readline()ifval==None:raiseStopAsyncIterationreturnvalasyncdeffunc():#创建异步可迭代对象async_iter=Reader()#asyncfor必须要放在asyncdef函数内，否则语法错误。asyncforiteminasync_iter:print(item)asyncio.run(func())

异步迭代器其实没什么太大的作用，只是支持了async for语法而已。

此种对象通过定义__aenter__()和__aexit__()方法来对async with语句中的环境进行控制

importasyncioclassAsyncContextManager:def__init__(self):self.conn=Noneasyncdefdo_something(self):#异步操作数据库return666asyncdef__aenter__(self):#异步链接数据库self.conn=awaitasyncio.sleep(1)returnselfasyncdef__aexit__(self,exc_type,exc,tb):#异步关闭数据库链接awaitasyncio.sleep(1)asyncdeffunc():asyncwithAsyncContextManager()asf:result=awaitf.do_something()print(result)asyncio.run(func())

这个异步的上下文管理器还是比较有用的，平时在开发过程中 打开、处理、关闭 操作时，就可以用这种方式来处理。

uvloop是asyncio中的事件循环的替代方案，替换后可以使得asyncio性能提高。事实上，uvloop要比nodejs、gevent等其他python异步框架至少要快2倍，性能可以比肩Go语言。

安装uvloop

pip3installuvloop

在项目中想要使用uvloop替换asyncio的事件循环也非常简单，只要在代码中这么做就行。

importasyncioimportuvloopasyncio.set_event_loop_policy(uvloop.EventLoopPolicy())#编写asyncio的代码，与之前写的代码一致。#内部的事件循环自动化会变为uvloopasyncio.run(...)

注意：知名的asgi uvicorn内部就是使用的uvloop的事件循环。

当通过python去操作redis时，链接、设置值、获取值 这些都涉及网络IO请求，使用asycio异步的方式可以在IO等待时去做一些其他任务，从而提升性能。

安装Python异步操作redis模块

pip3installaioredis

案例:连接多个redis做操作（遇到IO会切换其他任务，提供了性能）

importasyncioimportaioredisasyncdefexecute(address,password):print("开始执行",address)#网络IO操作：先去连接77.95.4.197:6379，遇到IO则自动切换任务，去连接77.95.4.198:6379redis=awaitaioredis.create_redis_pool(address,password=password)#网络IO操作：遇到IO会自动切换任务awaitredis.hmset_dict('car',key1=1,key2=2,key3=3)#网络IO操作：遇到IO会自动切换任务result=awaitredis.hgetall('car',encoding='utf-8')print(result)redis.close()#网络IO操作：遇到IO会自动切换任务awaitredis.wait_closed()print("结束",address)task_list=[execute('redis://77.95.4.197:6379',"123456"),execute('redis://77.95.4.198:6379',"123456")]asyncio.run(asyncio.wait(task_list))异步MySQL

当通过python去操作MySQL时，连接、执行SQL、关闭都涉及网络IO请求，使用asycio异步的方式可以在IO等待时去做一些其他任务，从而提升性能。

安装Python异步操作redis模块

pip3installaiomysql

案例

importasyncioimportaiomysqlasyncdefexecute(host,password):print("开始",host)#网络IO操作：先去连接77.95.40.197，遇到IO则自动切换任务，去连接77.95.40.198:6379conn=awaitaiomysql.connect(host=host,port=3306,user='root',password=password,db='mysql')#网络IO操作：遇到IO会自动切换任务cur=awaitconn.cursor()#网络IO操作：遇到IO会自动切换任务awaitcur.execute("SELECTHost,UserFROMuser")#网络IO操作：遇到IO会自动切换任务result=awaitcur.fetchall()print(result)#网络IO操作：遇到IO会自动切换任务awaitcur.close()conn.close()print("结束",host)task_list=[execute('77.95.40.197',"123456"),execute('77.95.40.198',"123456")]asyncio.run(asyncio.wait(task_list))爬虫

在编写爬虫应用时，需要通过网络IO去请求目标数据，这种情况适合使用异步编程来提升性能，接下来我们使用支持异步编程的aiohttp模块来实现。

安装aiohttp模块

pip3installaiohttp

案例

importaiohttpimportasyncioasyncdeffetch(session,url):print(f"发送请求：{url}")asyncwithsession.get(url,verify_ssl=False)asresponse:text=awaitresponse.text()print("得到结果：",url,len(text))asyncdefmain():asyncwithaiohttp.ClientSession()assession:url_list=["http://www.baidu.com","http://www.taobao.com","http://www.jd.com"]tasks=[asyncio.create_task(fetch(session,url))forurlinurl_list]awaitasyncio.wait(tasks)if__name__=='__main__':asyncio.run(main())

关于“python中怎么实现协程”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“python中怎么实现协程”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注亿速云行业资讯频道。