Tutoriel Python AsyncIO : un guide complet de Python asynchrone

Bienvenue dans l'ultime Tutoriel Python AsyncIO! Si vous êtes un programmeur/développeur désireux de maîtriser la programmation asynchrone et de renforcer vos compétences Python, vous êtes au bon endroit.

Dans ce guide, nous approfondirons les tenants et les aboutissants d'asyncio. À la fin du guide, vous aurez compris :

• Qu'est-ce que l'asyncio ?
• Avantages/Cas d'utilisation
• Comment fonctionne asyncio sous le capot
• Comment travailler avec asyncio avec des exemples concrets
• Limites/Conseils de dépannage

Prêt? Allons-y !

Qu'est-ce qu'AsyncIO en Python

AsyncIO est la bibliothèque intégrée de Python pour écrire du code asynchrone à l'aide de async et await mots-clés.

Si vous êtes complètement nouveau dans la programmation asynchrone, il peut être utile de penser à jongler avec plusieurs balles simultanément au lieu d'attendre que chaque balle touche le sol avant d'en ramasser une autre.

la boucle d'événements à thread unique a atterri dans Python 3.4 sous PEP 3156, tout en adoptant également le moderne async/await syntaxe formalisée dans PEP 492, pour montrer comment les coroutines jonglent avec des milliers de tâches liées aux E/S sans bloquer un thread. Une fois que vous aurez compris, vous commencerez à voir la beauté d’écrire du code capable de gérer plusieurs tâches simultanément. Python asyncio vous ouvrira vraiment les yeux sur une manière de coder plus efficace, comme nous l'explorerons tout au long de ce didacticiel.

Pourquoi devriez-vous envisager d'utiliser Python AsyncIO

Python AsyncIO n'est pas seulement un mot à la mode ; cela résout des problèmes du monde réel. Imaginez que votre programme doive attendre des ressources externes, comme télécharger des fichiers, interroger des bases de données ou effectuer des appels d'API.

Sans AsyncIO, ces opérations bloquent l'intégralité de votre programme jusqu'à ce qu'elles soient terminées. Avec AsyncIO, cependant, vous pouvez assurer le bon fonctionnement d’autres parties de votre application en attendant.

Voici une analogie simple : imaginez-vous en train de préparer le dîner. Vous ne resteriez pas les bras croisés pendant que l'eau bout : vous hacheriez des légumes ou prépareriez des épices simultanément. AsyncIO permet à vos programmes de faire exactement cela.

Avantages clés de Python AsyncIO

• Opérations d'E/S efficaces : AsyncIO brille lorsqu'il s'agit d'opérations réseau, d'E/S de fichiers ou de requêtes de base de données. Vous pouvez exécuter plusieurs opérations simultanément sans attendre que chacune se termine individuellement.
• La simplicité plutôt que les fils : Au lieu de jongler avec les threads et de vous soucier des conditions de concurrence, la syntaxe async/wait rend votre code plus linéaire et plus facile à suivre. Croyez-moi, une fois que vous l'aurez utilisé, vous ne voudrez plus jamais y retourner.
• Meilleure gestion des ressources : Avec la programmation asynchrone, vous pouvez gérer des milliers de tâches avec une surcharge minimale. Ceci est particulièrement utile pour les applications Web évolutives.
• Réactivité : Fini les applications gelées ! Votre interface utilisateur reste vive et réactive, même lorsque vous effectuez des tâches lourdes en arrière-plan. Personne n’aime cliquer sur un bouton puis regarder un rouet pendant des heures.

J'ai appris cela de première main lors de la conversion d'un robot d'exploration Web bloquant en un robot asynchrone. L’amélioration des performances a été spectaculaire et m’a fait apprécier l’élégance de cette belle fonctionnalité.

Cas d'utilisation réels de Python AsyncIO

Décomposons quelques avantages et cas d'utilisation pratiques :

• Applications en temps réel : La programmation asynchrone vous permet de gérer en douceur les mises à jour en temps réel, qu'il s'agisse d'applications de chat ou de flux en direct.
• Serveurs à haute concurrence : Construire des serveurs qui gèrent de nombreuses connexions client devient beaucoup plus gérable.
• Web Scraping et appels API : AsyncIO est parfait pour effectuer plusieurs appels API simultanément, réduisant ainsi les temps d'attente et augmentant l'efficacité.
• Applications GUI : Même dans les applications graphiques, la programmation asynchrone empêche l'interface utilisateur de se bloquer lors d'opérations d'E/S lourdes.
• Informatique: Gérer de grands ensembles de données et effectuer des tâches simultanément.

Si vous vous êtes déjà demandé comment les frameworks Web modernes comme FastAPI atteignent une vitesse fulgurante, la réponse réside dans Python AsyncIO.

Astuce 💡 : Explorez des concepts plus avancés en Python pour passer au niveau supérieur !

Comment utiliser AsyncIO en Python

Passons maintenant à un didacticiel pratique pour vous familiariser avec Python asyncio. Je vais vous expliquer un exemple simple montrant comment cela fonctionne et comment l'utiliser pour gérer plusieurs tâches.

Comment fonctionne Python asyncio ?

Chaque programme asyncio commence par une boucle d'événements. Considérez-le comme le chef d'orchestre qui planifie et exécute vos tâches asynchrones.

Boucle d'événement: Le planificateur principal d'AsyncIO qui gère et exécute les coroutines, gère la préparation des E/S et les minuteries pour reprendre chaque coroutine lorsque sa tâche attendue est prête. (Apprendre encore plus)

Commençons par un exemple de code très basique :

async def hello_async():
    print("Hello, ")
    await asyncio.sleep(1) # Other tasks can execute in the meantime (wait 1 second)
    print("AsyncIO!")

if __name__ == "__main__":
    asyncio.run(hello_async())Code language: PHP (php)

Dans ce code, le hello_async la coroutine imprime un message, attend une seconde de manière asynchrone (en utilisant await asyncio.sleep(1)), puis imprime un autre message. C'est l'essence même de la programmation asynchrone : attendre sans bloquer d'autres tâches. Pas vraiment époustouflant, mais cela montre les bases.

Coroutine: Une fonction spéciale définie avec async def qui peut suspendre son exécution à await points, permettant à d'autres coroutines de s'exécuter jusqu'à ce que l'opération attendue soit terminée. (Apprendre encore plus)

Voici comment le programme ci-dessus fonctionne étape par étape :

• async def say_hello(): Nous définissons une coroutine appelée hello_async.
• await asyncio.sleep(1): C'est ici que la magie opère. asyncio.sleep(1) est un objet « attendu » qui met la coroutine en pause pendant 1 seconde, mais surtout, il ne bloque pas l'intégralité du programme. Python peut faire autre chose en attendant (s'il y avait autre chose à faire).
• asyncio.run(hello_async()): C'est comme ça qu'en fait tu courir votre code asyncio. asyncio.run() démarre la « boucle d’événements », qui est comme le cerveau de asynciogérant toutes vos coroutines.

Comprendre la boucle d'événements

Voici comment fonctionne le mécanisme de boucle d'événements sous le capot :

Exécuter plusieurs tâches simultanément

Comme nous l'avons mentionné au début de ce didacticiel, la véritable puissance de Python asyncio devient évidente lorsque vous exécutez plusieurs tâches simultanément. Découvrez cet exemple :

import asyncio

async def task(name, duration):
    print(f"Task {name} started, will take {duration} seconds.")
    await asyncio.sleep(duration)
    print(f"Task {name} finished.")

async def main():
    # Scheduling multiple tasks concurrently
    tasks = [
        asyncio.create_task(task("A", 2)),
        asyncio.create_task(task("B", 1)),
        asyncio.create_task(task("C", 3))
    ]
    await asyncio.gather(*tasks)

if __name__ == '__main__':
    asyncio.run(main())Code language: PHP (php)

Remarquez comment les tâches s'exécutent simultanément, mais leurs résultats apparaissent en fonction des temps d'exécution. La tâche B se termine plus rapidement même si elle démarre plus tard !

Exemple Python AsyncIO du monde réel – Un simple grattoir Web

Appliquons ce que nous avons appris pour créer quelque chose de pratique : un simple web scraper utilisant aiohttpune bibliothèque populaire pour les requêtes HTTP asynchrones. (vous devrez courir pip install aiohttp si vous ne l'avez pas déjà installé dans votre environnement Python)

import asyncio
import aiohttp

async def fetch_data(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        "https://api.github.com",
        "https://www.python.org",
        "https://docs.python.org/3/library/asyncio.html"
    ]
    async with aiohttp.ClientSession() as session:
        tasks = [asyncio.create_task(fetch_data(session, url)) for url in urls]
        responses = await asyncio.gather(*tasks)
        for i, response in enumerate(responses):
            print(f"Response from URL {i+1}: {len(response)} characters fetched.")

if __name__ == '__main__':
    asyncio.run(main())Code language: JavaScript (javascript)

En utilisant aiohttp avec Python asyncio, j'ai pu réduire considérablement le temps d'attente global. Cet extrait est un excellent point de départ pour tous ceux qui cherchent à créer des applications Web asynchrones ou des récupérateurs de données. Pour plus de détails, consultez le documentation aiohttp.