python协程编程实例_Python- 协程 & asyncio & 异步编程-CSDN博客

本文链接：https://blog.csdn.net/weixin_39605345/article/details/111442435

本文详细介绍了Python协程的概念，包括greenlet、yield关键字、asyncio装饰器和async/await语法的实现方式。并通过实际案例展示了如何利用asyncio进行异步编程，提高程序性能。此外，还探讨了异步编程的意义，如在网络IO密集型任务中避免阻塞，提升程序执行效率。最后，文章提供了多个实战案例，涉及下载图片、异步数据库操作和爬虫等场景，进一步阐述了协程和asyncio的实际应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

协程 & asyncio & 异步编程

越来越多的人都来问async异步相关问题，并且这一部分的知识点不太容易学习(异步非阻塞、asyncio)

异步相关话题和框架越来越多，例如：tornado、fastapi、django 3.x asgi 、aiohttp都在异步 -> 提升性能。

如何讲解？

第一部分：协程。

第二部分：asyncio模块进行异步编程。

第三部分：实战案例。

1.协程

协程不是计算机提供，程序员人为创造。

协程(Coroutine)，也可以被称为微线程，是一种用户态内的上下文切换技术。简而言之，其实就是通过一个线程实现代码块相互切换执行。例如：

deffunc1():print(1)

...print(2)deffunc2():print(3)

...print(4)

func1()

func2()

实现协程有这么几种方法：

greenlet，早期模块。

yield关键字。

asyncio装饰器(py3.4)

async、await关键字(py3.5)【推荐】

1.1 greenlet实现协程

pip3 install greenletfrom greenlet importgreenlet

deffunc1():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 函数

1.2 yield关键字

deffunc1():yield 1

yield fromfunc2()yield 2

deffunc2():yield 3

yield 4

f1=func1()for item inf1:print(item)

1.3 asyncio

在python3.4及之后的版本。

importasyncio

@asyncio.coroutinedeffunc1():print(1)#网络IO请求：下载一张图片

yield from asyncio.sleep(2) #遇到IO耗时操作，自动化切换到tasks中的其他任务

print(2)

@asyncio.coroutinedeffunc2():print(3)#网络IO请求：下载一张图片

yield from 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))

注意：遇到IO阻塞自动切换

1.4 async & await关键字

在python3.5及之后的版本。

importasyncio

asyncdeffunc1():print(1)#网络IO请求：下载一张图片

await asyncio.sleep(2) #遇到IO耗时操作，自动化切换到tasks中的其他任务

print(2)

asyncdeffunc2():print(3)#网络IO请求：下载一张图片

await 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))

2.协程意义

在一个线程中如果遇到IO等待时间，线程不会傻傻等，利用空闲的时候再去干点其他事。

案例：去下载三张图片(网络IO)。

普通方式(同步)

"""pip3 install requests"""importrequests

defdownload_image(url):print("开始下载:",url)#发送网络请求，下载图片

response =requests.get(url)print("下载完成")#图片保存到本地文件

file_name = url.rsplit('_')[-1]

with open(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 item inurl_list:

download_image(item)

协程方式(异步)

"""下载图片使用第三方模块aiohttp，请提前安装：pip3 install aiohttp"""

#!/usr/bin/env python#-*- coding:utf-8 -*-

importaiohttpimportasyncio

asyncdeffetch(session, url):print("发送请求：", url)

async with session.get(url, verify_ssl=False) as response:

content=await response.content.read()

file_name= url.rsplit('_')[-1]

with open(file_name, mode='wb') as file_object:

file_object.write(content)print('下载完成',url)

asyncdefmain():

async with aiohttp.ClientSession() as session:

tasks= [ asyncio.create_task(fetch(session, url)) for url inurl_list ]

await asyncio.wait(tasks)

if __name__ == '__main__':

asyncio.run( main() )

3.异步编程

3.1 事件循环

理解成为一个死循环，去检测并执行某些代码。

#伪代码

任务列表=[ 任务1, 任务2, 任务3,... ]

whileTrue:

可执行的任务列表，已完成的任务列表= 去任务列表中检查所有的任务，将'可执行'和'已完成'的任务返回for 就绪任务 in可执行的任务列表:

执行已就绪的任务for 已完成的任务 in已完成的任务列表:

在任务列表中移除已完成的任务

如果任务列表中的任务都已完成，则终止循环importasyncio

#去生成或获取一个事件循环

loop =asyncio.get_event_loop()

#将任务放到`任务列表`

loop.run_until_complete(任务)

3.2 快速上手

协程函数，定义函数时候 async def 函数名。

协程对象，执行协程函数() 得到的协程对象。

async deffunc():pass

result= func()

注意：执行协程函数创建协程对象，函数内部代码不会执行。

如果想要运行协程函数内部代码，必须要讲协程对象交给事件循环来处理。

importasyncio

asyncdeffunc():print("快来搞我吧！")

result=func()

#loop = asyncio.get_event_loop()#loop.run_until_complete( result )

asyncio.run( result ) #python3.7

3.3 await

await + 可等待的对象(协程对象、Future、Task对象 -> IO等待)

示例1：

importasyncio

asyncdeffunc():print("来玩呀")

response= await asyncio.sleep(2)print("结束",response)

asyncio.run( func() )

示例2：

importasyncio

asyncdefothers():print("start")

await asyncio.sleep(2)print('end')return '返回值'

asyncdeffunc():print("执行协程函数内部代码")

#遇到IO操作挂起当前协程(任务)，等IO操作完成之后再继续往下执行。当前协程挂起时，事件循环可以去执行其他协程(任务)。

response =await others()

print("IO请求结束，结果为：", response)

asyncio.run( func() )

示例3：

importasyncio

asyncdefothers():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() )

await就是等待对象的值得到结果之后再继续向下走。

3.4 Task对象

Tasksare used to schedule coroutines concurrently.

When a coroutine is wrapped into a Taskwith functions like asyncio.create_task()the coroutine is automatically scheduled to run soon。

白话：在事件循环中添加多个任务的。

Tasks用于并发调度协程，通过asyncio.create_task(协程对象)的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除了使用 asyncio.create_task()函数以外，还可以用低层级的 loop.create_task()或 ensure_future()函数。不建议手动实例化 Task 对象。

注意：asyncio.create_task()函数在 Python 3.7 中被加入。在 Python 3.7 之前，可以改用低层级的 asyncio.ensure_future()函数。

示例1：

importasyncio

asyncdeffunc():print(1)

await asyncio.sleep(2)print(2)return "返回值"

asyncdefmain():print("main开始")#创建Task对象，将当前执行func函数任务添加到事件循环。

task1 =asyncio.create_task( func() )#创建Task对象，将当前执行func函数任务添加到事件循环。

task2 =asyncio.create_task( func() )

print("main结束")

#当执行某协程遇到IO操作时，会自动化切换执行其他任务。

#此处的await是等待相对应的协程全都执行完毕并获取结果

ret1 =await task1

ret2=await task2print(ret1, ret2)

asyncio.run( main() )

示例2：

importasyncio

asyncdeffunc():print(1)

await asyncio.sleep(2)print(2)return "返回值"

asyncdefmain():print("main开始")

task_list=[

asyncio.create_task(func(), name='n1'),

asyncio.create_task(func(), name='n2')

]

print("main结束")

done, pending= await asyncio.wait(task_list, timeout=None)print(done)

asyncio.run(main())

示例3：

importasyncio

asyncdeffunc():print(1)

await asyncio.sleep(2)print(2)return "返回值"

task_list=[

func(),

]

done,pending=asyncio.run( asyncio.wait(task_list) )print(done)

3.5 asyncio.Future对象

A Futureis a special low-levelawaitable object that represents an eventual resultof an asynchronous operation.

Task继承Future，Task对象内部await结果的处理基于Future对象来的。

示例1：

async defmain():#获取当前事件循环

loop =asyncio.get_running_loop()

#创建一个任务(Future对象)，这个任务什么都不干。

fut =loop.create_future()

#等待任务最终结果(Future对象)，没有结果则会一直等下去。

await fut

asyncio.run( main() )

示例2：

importasyncio

asyncdefset_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() )

3.5 concurrent.futures.Future对象

使用线程池、进程池实现异步操作时用到的对象。

importtimefrom concurrent.futures importFuturefrom concurrent.futures.thread importThreadPoolExecutorfrom concurrent.futures.process importProcessPoolExecutor

deffunc(value):

time.sleep(1)print(value)return 123#创建线程池

pool = ThreadPoolExecutor(max_workers=5)

#创建进程池#pool = ProcessPoolExecutor(max_workers=5)

for i in range(10):

fut=pool.submit(func, i)print(fut)

以后写代码可能会存在交叉时间。例如：crm项目80%都是基于协程异步编程 + MySQL(不支持)【线程、进程做异步编程】。

importtimeimportasyncioimportconcurrent.futures

deffunc1():#某个耗时操作

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() )

案例：asyncio + 不支持异步的模块

importasyncioimportrequests

asyncdefdownload_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]

with open(file_name, mode='wb') as file_object:

file_object.write(response.content)

if __name__ == '__main__':

tasks= [ download_image(url) for url inurl_list]

loop=asyncio.get_event_loop()

loop.run_until_complete( asyncio.wait(tasks) )

3.7 异步迭代器

什么是异步迭代器

什么是异步可迭代对象？

importasyncio

classReader(object):"""自定义异步迭代器(同时也是异步可迭代对象)"""def __init__(self):

self.count=0

asyncdefreadline(self):#await asyncio.sleep(1)

self.count += 1

if self.count == 100:returnNonereturnself.count

def __aiter__(self):returnself

asyncdef __anext__(self):

val=await self.readline()if val ==None:raiseStopAsyncIterationreturnval

asyncdeffunc():

obj=Reader()

asyncfor item inobj:print(item)

asyncio.run( func() )

3.8 异步上下文管理器

importasyncio

classAsyncContextManager:def __init__(self):

self.conn=conn

asyncdefdo_something(self):#异步操作数据库

return 666

asyncdef __aenter__(self):#异步链接数据库

self.conn = await asyncio.sleep(1)returnself

asyncdef __aexit__(self, exc_type, exc, tb):#异步关闭数据库链接

await asyncio.sleep(1)

asyncdeffunc():

async with AsyncContextManager() as f:

result=await f.do_something()print(result)

asyncio.run( func() )

4.uvloop

是asyncio的事件循环的替代方案。事件循环 > 默认asyncio的事件循环。

pip3 install uvloopimportasyncioimportuvloop

asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

#编写asyncio的代码，与之前写的代码一致。

#内部的事件循环自动化会变为uvloop

asyncio.run(...)

注意：一个asgi -> uvicorn内部使用的就是uvloop

5.实战案例

5.1 异步redis

在使用python代码操作redis时，链接/操作/断开都是网络IO。

pip3 install aioredis

示例1：

#!/usr/bin/env python#-*- coding:utf-8 -*-

importasyncioimportaioredis

asyncdefexecute(address, password):print("开始执行", address)#网络IO操作：创建redis连接

redis = await aioredis.create_redis(address, password=password)

#网络IO操作：在redis中设置哈希值car，内部在设三个键值对，即： redis = { car:{key1:1,key2:2,key3:3}}

await redis.hmset_dict('car', key1=1, key2=2, key3=3)

#网络IO操作：去redis中获取值

result = await redis.hgetall('car', encoding='utf-8')print(result)

redis.close()#网络IO操作：关闭redis连接

await redis.wait_closed()

print("结束", address)

asyncio.run( execute('redis://47.93.4.198:6379', "root!2345") )

示例2：

importasyncioimportaioredis

asyncdefexecute(address, password):print("开始执行", address)

#网络IO操作：先去连接 47.93.4.197:6379，遇到IO则自动切换任务，去连接47.93.4.198:6379

redis = await aioredis.create_redis_pool(address, password=password)

#网络IO操作：遇到IO会自动切换任务

await redis.hmset_dict('car', key1=1, key2=2, key3=3)

#网络IO操作：遇到IO会自动切换任务

result = await redis.hgetall('car', encoding='utf-8')print(result)

redis.close()#网络IO操作：遇到IO会自动切换任务

await redis.wait_closed()

print("结束", address)

task_list=[

execute('redis://47.93.4.197:6379', "root!2345"),

execute('redis://47.93.4.198:6379', "root!2345")

]

asyncio.run(asyncio.wait(task_list))

5.2 异步MySQL

pip3 install aiomysql

示例1：

importasyncioimportaiomysql

asyncdefexecute():#网络IO操作：连接MySQL

conn = await aiomysql.connect(host='127.0.0.1', port=3306, user='root', password='123', db='mysql', )

#网络IO操作：创建CURSOR

cur =await conn.cursor()

#网络IO操作：执行SQL

await cur.execute("SELECT Host,User FROM user")

#网络IO操作：获取SQL结果

result =await cur.fetchall()print(result)

#网络IO操作：关闭链接

await cur.close()

conn.close()

asyncio.run(execute())

示例2：

#!/usr/bin/env python#-*- coding:utf-8 -*-

importasyncioimportaiomysql

asyncdefexecute(host, password):print("开始", host)#网络IO操作：先去连接 47.93.40.197，遇到IO则自动切换任务，去连接47.93.40.198:6379

conn = await aiomysql.connect(host=host, port=3306, user='root', password=password, db='mysql')

#网络IO操作：遇到IO会自动切换任务

cur =await conn.cursor()

#网络IO操作：遇到IO会自动切换任务

await cur.execute("SELECT Host,User FROM user")

#网络IO操作：遇到IO会自动切换任务

result =await cur.fetchall()print(result)

#网络IO操作：遇到IO会自动切换任务

await cur.close()

conn.close()print("结束", host)

task_list=[

execute('47.93.41.197', "root!2345"),

execute('47.93.40.197', "root!2345")

]

asyncio.run(asyncio.wait(task_list))

5.3 FastAPI框架

安装

pip3 install fastapi

pip3 install uvicorn (asgi内部基于uvloop)

示例： xxx.py

#!/usr/bin/env python#-*- coding:utf-8 -*-

importasyncio

importuvicornimportaioredisfrom aioredis importRedisfrom fastapi importFastAPI

app=FastAPI()

#创建一个redis连接池

REDIS_POOL = aioredis.ConnectionsPool('redis://47.193.14.198:6379', password="root123", minsize=1, maxsize=10)

@app.get("/")defindex():"""普通操作接口"""

return {"message": "Hello World"}

@app.get("/red")

asyncdefred():"""异步操作接口"""

print("请求来了")

await asyncio.sleep(3)#连接池获取一个连接

conn =await REDIS_POOL.acquire()

redis=Redis(conn)

#设置值

await redis.hmset_dict('car', key1=1, key2=2, key3=3)

#读取值

result = await redis.hgetall('car', encoding='utf-8')print(result)

#连接归还连接池

REDIS_POOL.release(conn)

returnresult

if __name__ == '__main__':

uvicorn.run("luffy:app", host="127.0.0.1", port=5000, log_level="info")

5.4 爬虫

pip3 install aiohttpimportaiohttpimportasyncio

asyncdeffetch(session, url):print("发送请求：", url)

async with session.get(url, verify_ssl=False) as response:

text=await response.text()print("得到结果：", url, len(text))returntext

asyncdefmain():

async with aiohttp.ClientSession() as session:

url_list=['https://python.org','https://www.baidu.com','https://www.pythonav.com']

tasks= [ asyncio.create_task(fetch(session, url)) for url inurl_list]

done,pending=await asyncio.wait(tasks)

if __name__ == '__main__':

asyncio.run( main() )

总结

最大的意义：通过一个线程利用其IO等待时间去做一些其他事情。