Découvrez la puissance d'asyncio : permettre des opérations asynchrones transparentes

L'essence de la programmation asynchrone

Synchronisation traditionnelleProgrammation bloque le flux d'exécution de l'application jusqu'à ce qu'une opération soit terminée. Ceci est inefficace lors de la gestion de tâches gourmandes en E/S, car l'application doit attendre la fin de ces opérations, ce qui entraîne une latence et un gaspillage de ressources.

La programmation asynchrone surmonte cette limitation en utilisant des coroutines. Les coroutines sont des fonctions légères qui peuvent être suspendues et reprises à tout moment. Lorsqu'une coroutine rencontre une opération bloquante (telle qu'une requête réseau), elle peut suspendre l'exécution et laisser l'application gérer d'autres tâches. Lorsque l'opération de blocage est terminée, la coroutine peut reprendre l'exécution et continuer là où elle s'était arrêtée.

bibliothèque asyncio

asyncio est une bibliothèque de programmation asynchrone pour python qui fournit un ensemble complet d'outils pour écrire des applications de concurrence hautes performances. Il est basé sur des coroutines et des boucles d'événements, permettant aux développeurs d'effectuer des opérations asynchrones sans bloquer le thread principal.

Coroutine

En asyncio, les coroutines sont des fonctions déclarées à l'aide du mot-clé async def 关键字声明的函数。它们具有 aw<strong class="keylink">ai</strong>t. Ils ont une expression aw

t qui suspend l'exécution et attend la fin de l'opération asynchrone dans la coroutine. Par exemple : fetch_data 是一个协程，它使用 aiohttp

async def fetch_data(url):
async with aioHttp.ClientSession() as session:
async with session.get(url) as response:
return await response.JSON()

récupère les données de manière asynchrone à l'URL donnée.

asyncio s'appuie sur la boucle d'événements pour gérer l'exécution des coroutines. Une boucle d'événements est une boucle infinie qui commence par une coroutine et continue d'exécuter les coroutines jusqu'à ce qu'elles se terminent ou soient mises en pause. Il est responsable de la planification des coroutines et de la gestion des événements provenant du

ou d'autres sources.

L'écriture d'applications asynchrones à l'aide d'asyncio nécessite les étapes suivantes :
1. asyncio.new_event_loop()Créer une boucle d'événement :
Utilisez
2. pour créer une boucle d'événement. async defCréer une coroutine :
Utilisez le mot-clé
3. pour déclarer une coroutine. asyncio.create_task() 或 asyncio.ensure_future()Planification des coroutines :
Utilisez
4. pour planifier des coroutines dans la boucle d'événement. asyncio.run()Démarrez la boucle d'événements :
Utilisez

import asyncio

async def main():
# 异步获取数据
data = await fetch_data("https://example.com/data.json")

# 处理数据
print(data)

# 创建事件循环并启动它
asyncio.run(main())