协程 & asyncio & 异步

最新推荐文章于 2023-05-10 11:16:52 发布

zss1+1

最新推荐文章于 2023-05-10 11:16:52 发布

阅读量97

点赞数 1

分类专栏：网络爬虫文章标签： python

本文链接：https://blog.csdn.net/weixin_39281866/article/details/120981776

版权

网络爬虫专栏收录该内容

7 篇文章 1 订阅

订阅专栏

协程 & asyncio & 异步

第一部分：协程
第二部分：asyncio模块进行异步编程
第三部分：实战案例

协程

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

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

def func1():     
    print(1)  
    ...
    print(2) 
def func2():    
    print(3)  
    ...
    print(4)
func1() 
func2()

实现协程的几种方法：

greenlet，早期模块
yield关键字
asyncio装饰器(py3.4)
async & await关键字(py3.5)[推荐]

greenlet实现协程

pip install greenlet

from greenlet import greenlet   
def func1():     
    print(1)        # 第2步：输出 1     
    gr2.switch()    # 第3步：切换到func2函数     
    print(2)        # 第6步：输出2   
    gr2.switch()    # 第7步：切换到func2函数，上一行位置继续执行  
def func2():     
    print(3)        # 第4步：输出3  
    gr1.switch()    # 第5步：切换到func1函数，从上一次执行的位置继续向后执行    
    print(4)        # 第8步：输出4  
    gr1 = greenlet(func1) 
    gr2 = greenlet(func2) 
    gr1.switch()    # 第1步：去执行 func1 函数

yield 关键字

def func1():     # 生成器函数
    yield 1             # 第1步：生成1     
    yield from func2()  # 第2步：跳转到func2     
    yield 4             # 第5步：生成4  
def func2():    
    yield 2             # 第3步：生成 2     
    yield 3             # 第4步：生成 3  
    
f1 = func1() 
for item in f1:     
    print(item)

asyncio装饰器

python3.4之后的版本

import asyncio   

@asyncio.coroutine  # 装饰器，3.8版本已弃用
def func1():  # 协程函数   
    print(1)     
    # 假设网络请求时遇到阻塞  
    # 网络IO请求：下载一张图片
    yield from asyncio.sleep(2)     # 遇到IO耗时操作，自动切换到tasks中其他任务     
    print(2)  

@asyncio.coroutine 
def func2():     
    print(3)    
    # 假设网络请求时遇到阻塞 
    # 网络IO请求：下载一张图片
    yield from asyncio.sleep(2)     # 遇到IO耗时操作，自动切换到tasks中其他任务     
    print(4)  
    
tasks = [     
    asyncio.ensure_future(func1()),                 
    asyncio.ensure_future(func2()) 
] 

# 执行协程函数
# loop.run_until_complete(fun1())  #执行一个协程函数
loop = asyncio.get_event_loop() 
loop.run_until_complete(asyncio.wait(tasks))  #同时执行两个协程函数

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

async & await关键字

python3.5之后的版本

import asyncio     

async def func1():  # 协程函数    
    print(1)    
    # 假设网络请求时遇到阻塞    
    # 网络IO请求：下载一张图片    
    await from asyncio.sleep(2) 
    # 遇到IO耗时操作，自动切换到tasks中其他任务          
    print(2)    
    
async def func2():         
    print(3)     
    # 假设网络请求时遇到阻塞   
    # 网络IO请求：下载一张图片   
    await from asyncio.sleep(2)     # 遇到IO耗时操作，自动切换到tasks中其他任务        
    print(4)        
    
tasks = [     
    asyncio.ensure_future(func1()),                     
    asyncio.ensure_future(func2()) 
]   
# 执行协程函数 
# loop.run_until_complete(fun1())  #执行一个协程函数 
loop = asyncio.get_event_loop()  
loop.run_until_complete(asyncio.wait(tasks))  #同时执行两个协程函数

协程的意义

在一个线程如果遇到IO等待时间，线程不会在等待时一直不动，而是会利用空闲时间去做其他事情。

案例：下载三张图片（网络io）

普通方式（同步）

import requests

def download_image(url, name, *args, **kwargs):
        print('start downloading:', url)  # 下载网络图片 
        request = requests.get(url, *args, **kwargs) 
        print('Download complete')  # 图片保存到本地文件   
        file_name = str(name)     
        with open(file_name, mode='wb') as file_object:  
            file_object.write(request.content) 

 if __name__ == '__main__':     
    url_list = []     # 添加图片url   
    for name, main_url in enumerate(url_list):   
        download_image(main_url, 'image%s' % name)  # 目前下载发送请求时候函数会一个一个等待

协程方式（以协程方式实现异步编程）

pip3 install aiohttp

import aiohttp
import asyncio


async def fetch(session, url, name):
    print('start downloading', url)
    async with session.get(url, verify_ssl=False) as response:
        content = await response.content.read()
        file_name = name
        with open(file_name, mode='wb') as file_object:
            file_object.write(content)
        print('Download complete')

async def main():
    async with aiohttp.ClientSession() as session:
        url_list = []   # 添加图片url
                        # 通过请求下载，异步全部同时下载，全部收到请求后全部安装
        task = [asyncio.create_task(fetch(session, url, name)) for name, url in enumerate(url_list)]
        await asyncio.wait(task)

if __name__ == '__main__':
    # asyncio.run(main())
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

异步编程

事件循环

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

"""
# 伪装代码

任务列表 = [任务1, 任务2, 任务3, ...]
# 正在执行io操作的情况下，任务为不可执行

while True:
    可执行任务列表 = 去任务列表中检查所有任务
    已完成任务列表 = 将'可执行任务'和'已完成任务'返回

    for 就绪任务 in 可执行任务列表:
        执行以就绪任务

    for 完成任务 in 已完成任务列表:
        在任务列表中移除，完成的任务

    if 所有任务完成:
        中止循环
"""

import asyncio

# 去生成一个事件循环
loop = asyncio.get_event_loop()

# 将任务放置到任务列表
loop.run_until_complete(任务)

快速上手

协程函数(python3.5)：asynic def 函数名

协程对象：执行协程函数得到的对象

async def fun():  # 协程函数
    pass
result = fun()  # 协程对象

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

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

import asyncio
async def fun():  # 协程函数
    print('hello python')
    pass
result = fun()  # 协程对象

# loop = asyncio.get_event_loop()
# loop.run_until_complete(result)
# python3.7及之后使用
asyncio.run(result)

asyncio.run() 在事件循环上监听 async 函数main的执行。等到 main 执行完了，事件循环才会终止。

await关键字

await + 可等待的对象（协程对象、Future、Task对象）

示例1：

import asyncio

async def func():
    print('来玩啊')
    resp = await asyncio.sleep(2)  # 模拟io等待，在io等待期间切换到其他任务执行
    print('finish', resp)
    pass

asyncio.run(func())

示例2：

import asyncio

async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
    return 'values'

async def func():
    print('执行协程函数内部代码')
    
    # 遇到IO操作挂起当前协程（任务），等IO操作完成后再继续往下执行，协程函数挂起时，事件循环可以去执行其他协程
    response = await others()  # other()为协程对象
    print('io请求的结果为',response)

asyncio.run(func())

示例3：

import asyncio

async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
    return 'values'

async def func():
    print('执行协程函数内部代码')
    
    # 遇到IO操作挂起当前协程（任务），等IO操作完成后再继续往下执行，协程函数挂起时，事件循环可以去执行其他任务
    response1 = await others()  # other()为协程对象
    print('io请求的结果为',response1)
    # 一个协程函数可以有多个await
    response2 = await others()  # other()为协程对象
    print('io请求的结果为',response2)

asyncio.run(func())

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

执行引擎遇到await命令，就会在异步任务开始执行之后，暂停当前 async 函数的执行，把执行权交给其他任务。等到异步任务结束，再把执行权交回 async 函数，继续往下执行。

Task对象

在事件循环中添加多个任务，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)  # 3, 4
    await asyncio.sleep(2)
    print(2)  # 5, 6
    return 'values'

async def main():  # 主线程
    print('start main')  # 1

    # 创建Task对象，当前执行func函数任务添加到事件循环
    task1 = asyncio.create_task(func())
    
    # 创建Task对象，当前执行func函数任务添加到事件循环
    task2 = asyncio.create_task(func())
    print('main end')  # 2
    
    # 当执行协程遇到IO操作时，会自动化切换其它任务
    # 此处await的等待相对应的协程全部执行完毕并获取结果
    value1 = await task1
    value2 = await task2
    print(value1, value2)  # 7

asyncio.run(main())

示例2（常用）：

import asyncio

async def func():
    print(1)  
    await asyncio.sleep(2)
    print(2)  
    return 'values'

async def main():  # 主线程
    print('start main') 

    task_list = [
        asyncio.create_task(func(), name='t1'),
        asyncio.create_task(func(), name='t2')
    ]
    print('main end') 
    
    # 当执行协程遇到IO操作时，会自动化切换其它任务
    done,pending = await asyncio.wait(task_list, timeout=None) 
    # timeout=None 等待所有任务执行结束
    # 完成的任务 done
    # 未完成的任务 pending
    # done为一个集合
    print(done)

asyncio.run(main())

示例3：

async def func():
    print(1)  
    await asyncio.sleep(2)
    print(2)  
    return 'values'

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

asyncio.Future对象

A Future is a special low-level awaitable object that represents an eventual result of an asynchronous operation.

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

示例1：

import asyncio

async def main():
    # 获取当前事件循环
    loop = asyncio.get_running_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_running_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())

concurrent.futures.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):
    # submit 拿出线程池一个线程执行函数
    fut = pool.submit(func, i)  # 返回一个future对象
    print(fut)

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

import time
import asyncio
import concurrent.futures

def func1():
    # 某个操作耗时
    time.sleep(2)
    return "work over"

async def main():
    # 获取当前事件循环
    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对象包装asyncio.future对象
    # 因为concurrent.futures.Future对象不支持await语法，所以需要包装为asyncio.Future对象才能使用。
    fut = loop.run_in_executor(None, func1)
    result = await fut
    print('default thread loop', 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+不支持异步模块

import asyncio
import requests

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36'
}


async def download_image(url):
    # 发送网络请求，下载图片(遇到网络下载图片的IO请求，自动化切换到其他任务)
    print('开始下载', url)
    loop = asyncio.get_event_loop()
    # requests模块不支持异步操作，所以就使用线程池来配合实现
    future = loop.run_in_executor(None, requests.get, url, headers)

    response = await future
    print('下载完成')
    # 图片保存到本地
    file_name = './pic/' + url.split('=')[-1] + '.jpg'
    with open(file_name, mode='wb') as file_object:
        file_object.write(response.content)
    response.close()


if __name__ == '__main__':
    url_list = [
    ]
    tasks = [download_image(url) for url in url_list]
    loop = asyncio.get_event_loop()
    loop.run_until_complete(asyncio.wait(tasks))

效果于之前的asyncio和aiohttp是一样的，但所消耗的资源会更多，但这是遇到不得已的情况才使用

异步迭代器

迭代器

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器

异步迭代器

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

异步可迭代对象

在async for 语句中被使用对象。必须通过它的_aiter_()方法返回一个asyncchonous.iterator。由PEP 492引入

import asyncio


class Reader(object):
    """ 自定义异步迭代器（同时也是异步可迭代对象） """
    def __init__(self):
        self.count = 0
    
    async def readline(self):
        # await asyncio.slep(1)
        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 is None :  # 触发一个异常
            raise StopAsyncIteration
        return val


async def main():
    obj = Reader()
    async for item in obj:  # async for 必须写在协程函数内
        print(item)


asyncio.run(main())

异步上下文管理器

上下文管理器

with open('test.txt') as f:
    print f.readlines()

上下文表达式：with open('test.txt') as f:
上下文管理器：open('test.txt')
f 不是上下文管理器，应该是资源对象。

如何写上下文管理器？

要自己实现这样一个上下文管理，要先知道上下文管理协议。

简单点说，就是在一个类里，实现了__enter__和__exit__的方法，这个类的实例就是一个上下文管理器。

例如这个示例：

class Resource():
    def __enter__(self):  # 1
        print('===connect to resource===')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('===close resource connection===')  # 3
        
    def operate(self):
        print('===in operation===')  # 2
        
with Resource() as res:
    res.operate()

在编写代码时，可以将资源的连接或者获取放在__enter__中，而将资源的关闭写在__exit__ 中。

为什么要用上下文管理器

可以以一种更加优雅的方式，操作（创建/获取/释放）资源，如文件操作、数据库连接；
可以以一种更加优雅的方式，处理异常；

异步上下文管理器

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

import asyncio


class AsyncContextManager:
    def __init__(self):
        self.conn = None
    
    async def do_something(self):
        # 异步操作数据库
        return 'values'

    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)

async def main():
    async with AsyncContextManager() as f:  # aysnc with 不能单独存在必须嵌套在async函数中
        result = await f.do_something()
        print(result)

asyncio.run(main())

uvloop

是asyncio事件循环的替代方案，效率更高

pip3 install uvloop

windows系统不支持

import asyncio
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

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

# 内部的事件循环自动化变成uvloop
asyncio.run(...)

注意：一个asgi(支持异步的网关接口) — > uvicorn 内部使用的就是nvloop

实战案例

异步redis

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

pip3 install aioredis

示例1：

import asyncio
import aioredis


async def execute(address, password):
    print('开始创建', address)
    # 网络IO操作：创建redis连接
    redis = await aioredis.create_redis(address, password)

    # 网络IO操作：在redis中设置哈希值car,内部在设置三个键值对，既：redis = {car: {key1:1, key2:2, key3:3}}
    await redis.hmset_dic('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:[ip:host]', 'user!password'))

示例2 (多任务)：

import asyncio
import aioredis


async def execute(address, password):
    print('开始创建', address)
    # 网络IO操作：创建redis连接
    redis = await aioredis.create_redis(address, password)

    # 网络IO操作：在redis中设置哈希值car,内部在设置三个键值对，既：redis = {car: {key1:1, key2:2, key3:3}}
    await redis.hmset_dic('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:[ip:host]', 'user!password'),
    execute('redis:[ip:host]', 'user!password')
]

asyncio.run(asyncio.wait(task_list))

异步MySql

pip3 install aiomysql

示例1：

import asyncio
import aiomysql

async def execute():
    # 网络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()
    
    # 网络IO操作：关闭链接
    await cur.close()
    conn.close()


asyncio.run(execute())

FastAPI框架异步

pip3 install fastapi
pip3 install uvicorn # asgi 内部计入uvloop

示例：

普通操作IO

import uvicorn
from fastapi import FastAPI
app = FastAPI()


@app.get('/')
def index():
    """普通操作接口"""
    # 某个IO操作10s就会一直等待，接下来的请求无法进入
    return {'message': 'hello word'}


if __name__ == '__main__':
    uvicorn.run('luffy:app', host='127.0.0.1', port=5000, log_level='info')

import asyncio
import uvicorn
import aioredis
from aioredis import Redis
from fastapi import FastAPI
app = FastAPI()
# 创建 redis 的连接池 
REDIS_POOL = aioredis.ConnectionsPool('redis:[ip:port]', password='root123', minsize=1, maxsize=10)

@app.get('/')
def index():
    """普通操作接口"""
    # 某个IO操作10s就会一直等待，接下来的请求无法进入
    return {'message': 'hello word'}


@app.get('/red'):
async def red():
    """异步接口"""
    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)
    return result

if __name__ == '__main__':
    uvicorn.run(' python_file_name:app', host='127.0.0.1', port=5000, log_level='info')

异步爬虫

pip3 install aiohttp

import aiohttp
import asyncio


async def fetch(session, url):
    print('发送请求', url)
    async with session.get(url, verify_ssl=False) as response:
        text = await response.text()
        print('已经获取:', url, len(text))
        return text

async def main():
    async with aiohttp.ClientSession() as session:
        url_list = []
        tasks = [asyncio.create_task(fetch(session, url) for url in url_list)]
        done, pending = await asyncio.wait(tasks)

if __name__ ==  "__main__":
    asyncio.run(main())

总结

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

zss1+1

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
协程 & asyncio & 异步

协程 & asyncio & 异步第一部分：协程第二部分：asyncio模块进行异步编程第三部分：实战案例协程协程不是计算机提供，而是由程序员人为创造。协程（coroutine）也是被称为微线程，是一种用户态的上下文切换技术，简而言之，其实就是通过一个线程实现代码模块相互切换执行。例如：def func1(): print(1) ... print(2) def func2(): print(3) ...
复制链接

扫一扫

专栏目录