Un guide pratique de la programmation asynchrone en Python

Bases de la programmation asynchrone

Le module « asyncio » de Python fournit l’infrastructure pour écrire du code simultané, en utilisant la syntaxe « async/await » pour rendre le code asynchrone aussi lisible que le code synchrone.

Concepts de base

• Event Loop : boucle d’événements, moteur d’exécution de programmes asynchrones
• Coroutine : coroutine, fonction définie à l’aide de async def
• Tâche : Tâche, une encapsulation de coroutines, utilisée pour la planification simultanée
• Futur : résultats futurs, indiquant les opérations inachevées

Utilisation de base

import asyncio

async def fetch_data(url: str) -> str:
    """模拟异步 HTTP 请求"""
    await asyncio.sleep(1)
    return f"Data from {url}"

async def main():
    # 串行执行：耗时 3 秒
    result1 = await fetch_data("https://api1.com")
    result2 = await fetch_data("https://api2.com")
    result3 = await fetch_data("https://api3.com")

    # 并发执行：耗时 1 秒
    results = await asyncio.gather(
        fetch_data("https://api1.com"),
        fetch_data("https://api2.com"),
        fetch_data("https://api3.com"),
    )

asyncio.run(main())

Contrôle de concurrence : Sémaphore

Lorsque vous devez limiter le nombre de simultanéités, asyncio.Semaphore est le meilleur choix :

async def crawl_with_limit(urls: list[str], limit: int = 10):
    semaphore = asyncio.Semaphore(limit)

    async def fetch(url: str):
        async with semaphore:
            return await fetch_data(url)

    tasks = [fetch(url) for url in urls]
    return await asyncio.gather(*tasks)

Application pratique

La programmation asynchrone est particulièrement utile dans les scénarios suivants :

1. Web Crawler : grand nombre de requêtes HTTP simultanées
2. Appel API : Agrégation de plusieurs services externes
3. File IO : un grand nombre d’opérations de lecture et d’écriture de fichiers
4. Requête de base de données : exécutez plusieurs requêtes simultanément

Astuce : Tous les scénarios ne sont pas adaptés aux tâches asynchrones, gourmandes en CPU, qui doivent utiliser plusieurs processus.

Résumer

La maîtrise de la programmation asynchrone en Python peut améliorer considérablement les performances des applications gourmandes en E/S. La clé est de comprendre comment fonctionne la boucle d’événements, d’utiliser le sémaphore de manière appropriée pour contrôler la concurrence et de choisir le mode de concurrence approprié.