python 协程和异步

参考教材:https://www.bilibili.com/video/BV1QP4y1U7Yv?p=7&spm_id_from=pageDriver&vd_source=54bee3ca5d930bf0b7f3639dba0ec04e

为什么要讲

异步非阻塞 asyncio
tornado fastapi django 3.0 asgi aiohttp 都在异步，提升性能

如何讲解

协程
asyncio 模块异步编程
实站案例

协程

协程不是计算机提供的，是程序员创造出来的。
协程是让一个线程在代码之间来回切换的事例

实现协程的几种方法

greenlet 早期
yield 关键字
asynico 装饰器(python 3.4 引入)
async await (python 3.5 )

1.1 green let 实现协程

from  greenlet import greenlet
def func1():
    print(1)
    gr2.switch()
    print(2)
    gr2.switch()
def func2():
    print(3)
    gr1.switch()
    print(4)
    gr1.switch()
gr1=greenlet(func1)
gr2=greenlet(func2)
gr1.switch()

1.2 YIELD 实现协程

def func1():
    yield 1
    yield from func2()
    yield 2
def func2():
    yield 3
    yield 4
f1=func1()
for item in f1:
    print(item)

1.3 asyncio模块

在python 3.4 及之后的版本 
import asyncio

@asyncio.coroutine
def func1():
    print(1)
    yield from asyncio.sleep(2)
    print(2)

@asyncio.coroutine
def func2():
    print(3)
    yield from asyncio.sleep(2)
    print(4)

task=[asyncio.ensure_future(func1()),asyncio.ensure_future(func2())]
loop=asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(task))

1.4 async 和await 关键字

import asyncio
import time


async def func1():
    print(1)
    await asyncio.sleep(2)
    print(2)


async def func2():
    print(3)
    await asyncio.sleep(2)
    print(4)

task=[asyncio.ensure_future(func1()),asyncio.ensure_future(func2())]
loop=asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(task))

总结

在每一个线程中如果遇到io等待的时间，线程就不会傻傻等，利用时间去干点别的事。
案例，去下载三张图片

普通方式(同步)

import requests
def download_url(url):
    print("开始下载",url)
    resp=requests.get(url)
    print("下载完成",url)
    filename=url.split('/')[-1]
    with open(f'image/{filename}',mode='wb') as f:
        f.write(resp.content)


if __name__ == '__main__':
    url_list=[
        'https://mm.ojbkcdn.com/a/20220516/ke55guufwks.jpg',
        'https://oss-img.ojbkcdn.com/tutuji/20230413/dx0rnvr5d0o.jpg',
        'https://oss-img.ojbkcdn.com/tutuji/20230206/ytqaocg524o.jpg'

    ]
    for url in url_list:
        download_url(url)

协程方式(异步)

import aiohttp
import asyncio

async def fetch(session,url):
    print("发送请求",url)
    async with session.get(url,verify_ssl=False) as  response:
        content=await response.content.read()
        file_name=url.split('/')[-1]
        with open(f'image/{file_name}',mode='wb') as f:
            f.write(content)
        f.close()

async def main():
    async  with aiohttp.ClientSession() as session:
        url_list = [
            'https://mm.ojbkcdn.com/a/20220516/ke55guufwks.jpg',
            'https://oss-img.ojbkcdn.com/tutuji/20230413/dx0rnvr5d0o.jpg',
            'https://oss-img.ojbkcdn.com/tutuji/20230206/ytqaocg524o.jpg'

        ]
        tasks=[asyncio.create_task(fetch(session,url)) for url in url_list]
        await  asyncio.wait(tasks)
if __name__ == '__main__':
    asyncio.run(main())

异步编程

事件循环

快速上手

协程函数 async def 函数名
协程对象执行协程函数()得到协程对象

async func(): #协程函数
    pass

result=func()  #协程对象

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

import asyncio
async def func():
   print("快来搞我吧")

result=func()
# 去生成获取一个事件循环
# loop=asyncio.get_event_loop()
# # 将任务放到任务列表
# loop.run_until_complete(result)
asyncio.run(result)
# asyncio.run(result) #python 3.7 版本支持 ,替换上面注释的两步

3.3 await

await + 可等待的对像(协程对象，future对象，task对象) 可以理解为io等待
示例1

import asyncio
async def func():
    print("来玩啊")
    reponse=await asyncio.sleep(2)
    print("结束")

asyncio.run(func() )

示例2

import asyncio

async def other():
    print("start")
    response=await asyncio.sleep(3)
    print("end")
    return '返回值'
async def func():
    print("执行协程函数内部代码")
    # 遇到io操作，挂起当前协程（任务），等IO操作完成后再继续往下执行，当前协程挂起时，事件循环可以去执行协程（任务）。
    response=await other()
    print("IO请求结束，结果为",response)

asyncio.run(func())

示例3

import asyncio

async def other():
    print("start")
    response=await asyncio.sleep(3)
    print("end")
    return '返回值'
async def func():
    print("执行协程函数内部代码")
    # 遇到io操作，挂起当前协程（任务），等IO操作完成后再继续往下执行，当前协程挂起时，事件循环可以去执行协程（任务）。
    response1=await other()
    print("IO请求结束，结果为",response1)
    response2 = await other()
    print("IO请求结束，结果为", response2)

asyncio.run(func())

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

Task 对象

在整件循环中添加多个任务
Task用于并发调度协程，通过asyncio.create_task(协程对象)的方式创建Task对象，这样可以让协程加入事件循环中等待调度执行。除了使用asyncio.create_task()函数外，还可以用低层级的loop.create_task()或ensure_future()函数，不建议手动实例化Task()对象。
注意：asyncio.create_task()函数在Python3.7中被加入。在python3.7之前，可以改用低层级的asyncio.ensure_future()函数，

示例1

import asyncio
async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return '返回值'
async def main():
    print("main开始")
    # 创建事件对象，将添加的任务执行事件循环
    task1=asyncio.create_task(func())
    task2=asyncio.create_task(func())
    print("main结束")
    net1=await task1
    net2=await task2
    print(net1,net2)
    # print(net1,net2)

asyncio.run(main())

示例2

import asyncio
async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return '返回值'
async def main():
    print("main开始")
    # 创建事件对象，将添加的任务执行事件循环
    task_list=[asyncio.create_task(func(),name='n1'),
               asyncio.create_task(func(),name='n2')]
    print("main结束")
    # print(net1,net2)
    done,pending=await asyncio.wait(task_list,timeout=None)

    print(done)
asyncio.run(main())

示例3

# 这段代码3.8可以运行，3.11 运行不了有报错
import asyncio
async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return '返回值'

task_list=[func(),func(),]
done,panding=asyncio.run(asyncio.wait(task_list))
print(done)

asyncio Future 对象

更偏向底层，不会直接用。
是task 的基类

Task继承Future对像，Task对象内部await结果的处理基于Future对象来的
示例1

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

示例2

import asyncio
async def set_after(fut):
    await asyncio.sleep(2)
    fut.set_result('666')
async def main():
    # 获取当前事件循环
    loop=asyncio.get_event_loop()
    # 创建一个future任务，没绑定任何行为，则这个任务永远不会有结果
    fut=loop.create_future()
    # 创建一个任务（Task对象），绑定了set_after函数，函数在2s之后会给fut赋值
    # 即手动设备Future的最终结果，那么fut就可以结束了
    await loop.create_task(set_after(fut))
    # 等待Future获取最终结果，否则就一直等下去
    data=await fut
    print(data)
asyncio.run(main())

Concurent.Future future对象

使用进程池、线程池异步操作时使用的对象

import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutor
def func(value):
    time.sleep(1)
    print(value)
# 使用线程池
pool=ThreadPoolExecutor(max_workers=5)
# 使用进程池
# pool=ProcessPoolExecutor(max_workers=5)
for i in range(10):
    fut=pool.submit(func,i)
    print(fut)

以后写代码可能会存在交叉使用，一般情况下是不会的。

import asyncio
import concurrent.futures
import time
from concurrent.futures import Future
def func1():
    time.sleep(2)
    return 'SB'
async def main():
    loop=asyncio.get_running_loop()
    # 1. Run in the default loop's executor（黑夜ThreadPoolExecutor）
    # 第一步：内部会先调用ThreadPoolExecutor的submit方法去线程池中申请一个线程去执行func1函数，并返回一个concurrent.futures.Futures对象
    # 第二步: 调用asyncio.wrap_fure将concurrent.future.Future对象包装为asycio.Future对象
    # 因为concurrent.futures.Futures对像不支持await语法，所以需要包装为ascio.Future对象，才能使用。

    # fut=loop.run_in_executor(None,func1)
    # result=await fut
    # print('defualt 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.9里面执行成功
    # 3. Run in a custom process pool：
    with concurrent.futures.ProcessPoolExecutor(max_workers=4) as pool:
        result=await loop.run_in_executor(pool,func1)
        print('custom process pool',result)

asyncio.run(main())

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

# 在3.9 版本上面测试可以
import asyncio
import requests
async def download_url(url):
    print("开始下载",url)
    # resp=requests.get(url)
    loop=asyncio.get_event_loop()
    future=loop.run_in_executor(None,requests.get,url)
    resp=await future
    print("下载完成",url)
    filename=url.split('/')[-1]
    with open(f'image/{filename}',mode='wb') as f:
        f.write(resp.content)


if __name__ == '__main__':
    url_list=[
        'https://mm.ojbkcdn.com/a/20220516/ke55guufwks.jpg',
        'https://oss-img.ojbkcdn.com/tutuji/20230413/dx0rnvr5d0o.jpg',
        'https://oss-img.ojbkcdn.com/tutuji/20230206/ytqaocg524o.jpg'

    ]
    tasks=[download_url(url) for url in url_list]
    loop=asyncio.get_event_loop()
    loop.run_until_complete(asyncio.wait(tasks))

异步迭代器

迭代器：实现了next和iter
可迭代对像：实现了__iter__方法，并且返回了一个可以迭代对象。
异步迭代器：实现了aiter方法,并且返回了一个可异步迭代对象

import asyncio

class Reader(object):
    def __init__(self):
        self.count=0
    async def readline(self):
        self.count=self.count+1
        if self.count==100:
            return None
        return self.count
    def __aiter__(self):
        return self
    async def __anext__(self):
        val=await self.readline()
        if val==None:
            raise StopIteration
        return val
async def func():
    obj=Reader()
    async for item in obj:
        print(item)
asyncio.run(func())

异步的上下文管理器

此种对你通过定义__aenter()__和__aexit()__方法来对async_with语句中的环境进行控制。由PEP492引入

import asyncio

class AsyncContextManager:
    def __init__(self):
        self.conn=conn
    async def do_something(self):
        # 异步操作数据库
        return 666
    async def __aenter__(self):
        # 异步连接数据库
        self.conn=await asyncio.sleep(1)
        return self
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        # 异常关闭数据库链接
        await asyncio.sleep(1)

obj=AsyncContextManager()
# async with obj:
#     pass
async def fun():
    async with AsyncContextManager() as f:
        result=await f.do_something()
        print(result)

asyncio.run(fun())

uvloop

是asyncio的替代循环方案
第三方库
事件循环的效率>默认asyncio的事件循环
pip install uvloop

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

asyncio.run(...)

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

实战应用案例

异步操作redis

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

import asyncio
import aioredis
async def execute(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

import asyncio
import aioredis
async def execute(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)

task_list=[
execute('redis://47.93.4.198:6379',"root!2345"),
execute('redis://47.93.4.197:6379',"root!2345")
]

asyncio.run(asyncio.wait(task_list))

异常MySQL

pip install aiomysql
示例1

import asyncio
import aiomysql 
async def execute(host,password)
    # 网络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()

示例2

import asyncio
import aiomysql 
async def execute(host,password)
    # 网络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() 
    print("结束",host)

task_list=[
execute=("47.93.40.197","root1234"),
execute=("47.93.40.198","root1234"),
]
asyncio.run(asyncio.wait(task_list))

posted @ 2023-05-25 12:39 lifei888 阅读(87) 评论(0) 编辑收藏举报

刷新页面返回顶部

lifei888