asyncio协程异步实战

最新推荐文章于 2024-08-13 08:33:11 发布
最新推荐文章于 2024-08-13 08:33:11 发布
阅读量549 收藏 2
点赞数
分类专栏： 笔记 文章标签： python 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44634704/article/details/109093803
版权

经典案例

import asyncio

async def print_hello():
    while 1:
        print('hello_word')
        await asyncio.sleep(1)    #这个sleep不同time.sleep  这个sleep是让出线程控制权,给事件循环中别的协程

async def print_googbye():
    while 1:
        print('goodbye')
        await asyncio.sleep(2)		#这个相当于模拟IO阻塞操作,让出线程控制权,交由事件循环中别的协程来处理

c1 = print_hello()
c2 = print_googbye()            #这个相当于是创建协程对象
loop = asyncio.get_event_loop()         #获取事件循环
loop.run_until_complete(asyncio.gather(c1,c2))  #吧协程对象添加到事件循环中去执行

网络请求的异步化
实例1

import asyncio
import random

async def cronschedule():
    page = 1
    await asyncio.sleep(1)
    while 1:
        job = cron_job(f'https://www.baidu.com/{page}')
        await job			#走到这里,需要等待job执行结束,才可以执行下一次
        page += 1			#这样写就阻塞线程,不能达到高并发的目的
        

async def cron_job(url):
    n = random.randint(1,3)
    await asyncio.sleep(n)
    print('下载结束:' + url)

asyncio.run(cronschedule())

实例二

import asyncio
import random

async def cronschedule():
    page = 1
    await asyncio.sleep(1)
    while 1:
        job = cron_job(f'https://www.baidu.com/{page}')
        asyncio.create_task(job)  		#注册到事件循环,我们必须将新协程分离出去,让它和协程并发
        #a = asyncio.ensure_future(job) #如果你对job的协程对象的返回值需要,则需要用这个方法
        await asyncio.sleep(0.01)  		#必须有await,交出线程控制权,不然死循环会一直占用线程
        page += 1

async def cron_job(url):
    n = random.randint(1,3)
    await asyncio.sleep(n)
    print('下载结束:' + url)

asyncio.run(cronschedule())		#肉眼可见的并发数很高

案例三

import asyncio
import functools
import random

def on_job_down(url,task):
    print('下载结束',url,task.result()) #task.result 可以拿到cron_job协程函数的返回值


async def cronschedule():
    page = 1
    await asyncio.sleep(1)
    while 1:
        url = f'https://www.baidu.com/{page}'
        job = cron_job(url)
        task = asyncio.create_task(job)  #注册到事件循环,我们必须将新协程分离出去,让它和协程并发
        #a = asyncio.ensure_future(job) #如果你对job的协程对象的返回值需要,则需要用这个方法
        task.add_done_callback(functools.partial(on_job_down,url)) #这个是回调函数
        await asyncio.sleep(0.01)  #必须有await,交出线程控制权,不然死循环会一直占用线程
        page += 1

async def cron_job(url):
    n = random.randint(1,3)
    await asyncio.sleep(n)
    print('下载结束:' + url)
    return '<html></html>'

asyncio.run(cronschedule())

异步和非异步模块混合案例

网络请求下载案例

import asyncio
import time

async def down_load(url):
    #发起网络请求、下载图片(遇到网络下载图片的IO请求,自动化切换到其他任务)
    print('开始下载')
    loop = asyncio.get_event_loop()

    #requests模块默认不支持异步操作,所以使用线程池来配合实现
    future = loop.run_in_executor(None,requests.get,url)
    response = await future
    print('下载完成')

    #图片保存本地
    file_name = time.time()
    with open(f'{file_name}.jpg','wb') as f:
        f.write(response.content)

if __name__ == '__main__':
    url_list = [
        'https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=2229640758,955716948&fm=26&gp=0.jpg',
        'https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=2637673594,2560483073&fm=26&gp=0.jpg',
        'https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=2393851800,1908382647&fm=26&gp=0.jpg'
    ]

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

异步操作Redis

在通过python代码操作redis时,连接/操作/断开都是网络IO。

案例1

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:{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','密码'))

案例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:{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','密码'),			#连接两个redis
    execute('redis://47.93.4.197:6379','密码')
]

asyncio.run(asyncio.wait(task_list))
#连接第一个redis遇到网络IO,会自动切换到第二个连接

异步操作Mysql

示例1

pip install aiomysql         -- 支持mysql的异步的模块


import asyncio
import aiomysql

async def execute(address,password):
    print('开始执行',address)
    #网络IO操作,创建redis连接
    conn = await aiomysql.connect(host='127.0.0.1',port=3306,user='root',password='123')

    #网络IO操作,创建CURSOR
    cur = await conn.cursor()

    #网络IO操作,执行SQL结果
    await cur.execute('SELECT HOST,USER FROM USER')

    #网络IO操作,获取SQL结果
    result = await cur.fechall()
    print(result)

    #网络IO操作,关闭连接
    await cur.close()
    conn.close()

asyncio.run(execute())

案例2(连接多个mysql)

import asyncio
import aiomysql

async def execute(host,password):
    print('开始执行',host)
    #网络IO操作,创建redis连接
    conn = await aiomysql.connect(host=host,port=3306,user='root',password=password,db='mysql')

    #网络IO操作,遇到IO会自动切换任务
    cur = await conn.cursor()

    #网络IO操作,执行SQL结果
    await cur.execute('SELECT HOST,USER FROM USER')

    #网络IO操作,获取SQL结果
    result = await cur.fechall()
    print(result)

    #网络IO操作,关闭连接
    await cur.close()
    conn.close()
    print('结束',host)
    
task_list = [
    execute('47.93.41.197','密码'),
    execute('47.93.41.198','密码')
]

asyncio.run(asyncio.wait(task_list))

异步FastApi框架

pip install fastapi uvicorn -i https://pypi.doubanio.com/simple     -- 装模块

案例1

import asyncio
import aioredis
import uvicorn
from fastapi import FastAPI

app = FastAPI()

#创建redis连接池
REDIS_POOL = aioredis.ConnectionsPool('redis://47.193.14.198:6379',password='密码',minsize=1,maxsize=10)

@app.get('/')
def index():
    '''普通操作接口'''
    return {'message':'hello world'}

@app.get('/red')
async def red():
    '''异步操作接口'''
    print('请求来了')
    await asyncio.sleep(3)
    #连接池获取一个连接
    conn = await REDIS_POOL.acquire()
    redis = aioredis.Redis(conn)

    #存值
    await redis.hmset_dict('car',key1=1,key2=2)

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

    #连接归还连接池
    REDIS_POOL.release(conn)
    return result

if __name__ == '__main__':
    uvicorn.run('1:app',host='127.0.0.1',port=5000,log_level='info')
    #这个1的意思,是这个文件的名

爬虫异步化

pip install aiohttp								--支持异步发送网络请求的模块

案例1

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)
        print(done,pending)
if __name__ == '__main__':
    asyncio.run(main())

总结:

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

像风一样的男人@
关注
专栏目录
TypeError: AsyncConnectionPool.__init__() got an unexpected keyword argument ‘socket_options‘解决方案
weixin_43178406的博客
12-13 5万+
本文主要介绍了TypeError: AsyncConnectionPool.__init__() got an unexpected keyword argument ‘socket_options’ 解决方案，希望能对使用stable diffusion的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
asyncPool:一个用多线程安排异步任务的库
06-25
异步池 什么？ 一个用多线程安排异步任务的库。 例如，您在一个数组中有多个数字，对于每个元素，您都希望请求一个 url，然后对结果执行一些操作。 如何？ 你可以这样写： var arr = [ 1 , 2 , 3 , 4 ] ; // the array contains 100 elements var asyncPool = require ( '../lib/index' ) ; asyncPool ( 1 , arr , function ( element , callback ) { requestUrl ( '/xxx?element=' + element , function ( serverData ) { console . log ( element , serverData ) ;
【Redis】aioredis|python异步使用redis防止重复创建连接池
哈哈哈哈哈哈哈
02-22 1051
单例模式是一种设计模式，确保一个类只有一个实例，并提供一个全局访问点。在 Python 中，可以通过new方法来控制实例的创建过程，以实现单例模式。通过单例模式实现的 Python Redis 连接池，能够有效地管理连接资源并提高应用性能。同时，该实现考虑了线程安全性和懒加载的特性，具有良好的可扩展性和简洁性。在实际应用中，可以根据需要对代码进行进一步定制和扩展，以满足不同的需求和场景。
async-pool 项目教程
最新发布
gitblog_01198的博客
08-13 755
async-pool 项目教程 async-poolRun multiple promise-returning & async functions with limited concurrency using native ES6/ES7项目地址:https://gitcode.com/gh_mirrors/as/async-pool 项目介绍 async-pool 是一个用于控制并发执行的 ...
Python异步编程_asyncio
m0_59485658的博客
03-02 896
异步编程的主要目的在于：通过一个线程利用其io等待时间达到用更少的资源去做更多的事的目的。
aioredis v2.0 新的使用方法，抛弃使用create_pool等旧方法
u011962601的博客
09-23 6855
aioredis v2.0 现在是 的完全兼容的 异步原生 实现 redis-py 。 重新编写了整个核心和公共 API 以遵循 redis-py 的实现 尽可能接近。 这意味着连接有一些重大变化 接口，但我们现在有一个在两者之间完全一致的接口 库，因此从 移植 redis-py 到 aioredis 应该（理论上）像 更改一些导入并添加 await在需要的地方声明。 Motivations ¶ 截至 2019 年 12 月，该图书馆已被废弃。 代码变得陈旧，问题 堆积如山，我们很快就过时了 Redi.
spider:基于 AsyncIO 的异步爬虫，采用缓存机制，高效、易用
05-16
本篇文章将深入探讨基于`AsyncIO`的异步爬虫设计与实现，并结合`aiohttp`库进行实战讲解。 **AsyncIO基础** AsyncIO是Python 3.4引入的一个标准库，它基于事件驱动模型，利用非阻塞I/O来提高并发性能。在传统的...
Python异步编程 asyncio小白速通
06-20
课程从前到后分别讲解：协程、实现协程、协程的意义、asyncio异步编程、await&async关键字、task对象、future对象、FastAPI框架异步案例、MySQL异步、Redis异步等，最后再结合驻留异步场景进行企业实战案例场景的...
19_基于asyncio模块实现异步爬虫.zip
08-23
本项目实战基于Python的`asyncio`模块实现了一个异步爬虫，旨在利用异步I/O来提高爬取网页数据的效率。下面我们将深入探讨`asyncio`模块以及如何在爬虫项目中应用它。 `asyncio`是Python标准库中的一个模块，主要...
超高速异步协程Python爬虫.zip
12-30
在Python编程领域，异步协程（Asyncio）是一种高效处理I/O密集型任务的技术，尤其在爬虫开发中有着广泛的应用。超高速异步协程Python爬虫的设计旨在利用Python的非阻塞特性，提高数据抓取的速度和效率。本压缩包文件...
Python中的asyncio代码详解
09-19
#### 四、asyncio实战案例分析 假设我们需要同时执行两个异步任务，其中一个任务需要等待 3 秒钟，另一个任务需要等待 1 秒钟。我们的目标是在尽可能短的时间内完成这两个任务。 ```python import asyncio import ...
用Python实现数据库连接池的详细指南
白帽阿叁的博客
11-29 3274
通过本文，读者将深入了解数据库连接池的实现原理和在Python中的具体应用。丰富的示例代码和全面的讲解将帮助读者更好地理解并成功实现一个高效可靠的数据库连接池。希望这篇文章能够成为读者学习和应用数据库连接池的有力指南。感兴趣的小伙伴，赠送全套Python学习资料，包含面试题、简历资料等具体看下方。一、Python所有方向的学习路线Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。二、Python必备开发工具。
aioredis 使用
菜鸟吴de博客
01-18 823
python 异步redis库 aioredis库使用
stablediffusion打开报错解决办法
mhack5200的博客
11-14 4698
【代码】stablediffusion打开报错解决办法。
aioredis -- 连接redis
MarkAdc的博客
02-07 5148
python对redis的异步操作
js 的异步并发控制
ghostlpx的博客
05-29 2322
一个极端业务场景引发的思考 在业务开发过程中，我们经常会遇到多个异步任务并发执行的情况，待所有异步任务结束之后再执行我们的业务逻辑。 通常情况下，我们会采用 ES6 标准下的Promise.all([promise1, promise2, promise3,...]).then( )方法来应对这样的场景需求， Promise.all 可以保证，promises 数组中所有 promise 对象都达到 resolve 状态，才执行 then 回调。 这样的 promise 对象可能是你发出的 http 请求，
async-pool实现控制并发请求
Dax1_的博客
08-10 1504
假设有6个待办任务要执行，而我们希望限制同时执行的任务个数，即最多只有2个任务能同时执行。当正在执行任务列表中的任何1个任务完成后，程序会自动从待办任务列表中获取新的待办任务并把该任务添加到正在执行任务列表中。...
【Python】使用 Python 中的 aioredis 实现后进先出队列
哈哈哈哈哈哈哈
03-10 611
在现代的分布式系统中，使用消息队列是一种常见的方式来实现异步通信和任务处理。Redis 是一种流行的内存数据库，它的列表数据结构非常适合用作消息队列。本文将介绍如何使用 Python 和 aioredis 库来连接 Redis 数据库，并实现一个基于 Redis 的连接池和一个先进后出队列。
asyncPool并发执行请求函数
屈小康
06-30 649
这样是可以完成的，但是当我们发送1000个请求，等待1000个请求完成后在进行操作，首先不说等待完成操作，就简简单单的http请求瞬间发生1000个，你猜浏览器会怎么样？身为开发者我们无法控制http请求的多少，但是我们能控制异步任务的数量，具体来说就是我们可以控制promise的实例化数量，用以避免高并发带来的问题。一个不太常见的极端场景，当我们为了某个操作需要发生异步请求的时候，等待所有异步请求都完成时进行某些操作。可以保证多个请求完成后进行操作，等待所有的。
Python异步编程：从协程到asyncio实战
# 协程与异步编程概述 ...总结来说，Python的协程和`asyncio`模块为异步编程提供了强大且灵活的工具。通过熟练掌握这些概念和技巧，开发者可以编写出高效、易维护的并发应用程序，尤其适用于I/O密集型场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

像风一样的男人@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值