Async/Await en Python : maîtrise la programmation asynchrone — Guide pratique

Pourquoi la programmation asynchrone change tout

Tu développes en Python et tu te demandes pourquoi certaines applications mettent 30 secondes à répondre alors qu’elles ne font « presque rien » ? Le coupable est souvent l’exécution synchrone : ton programme attend bêtement qu’une opération lente (requête HTTP, lecture fichier, appel base de données) se termine avant de passer à la suite.

La programmation asynchrone avec async/await résout ce problème : elle permet à ton code de continuer à s’exécuter pendant qu’il attend des opérations lentes. Résultat : des applications jusqu’à 10 fois plus rapides sans ajouter un seul thread.

Dans ce tutoriel, tu vas apprendre les bases de la programmation asynchrone en Python avec des exemples concrets et progressifs. Commençons !

Qu’est-ce que la programmation asynchrone ?

Imagine un chef cuisinier qui doit préparer un repas complet. En mode synchrone, il met l’eau à bouillir, reste devant la casserole jusqu’à ébullition, puis prépare la sauce, attend qu’elle mijote, puis coupe les légumes. Il passe 80 % de son temps à attendre.

En mode asynchrone, il met l’eau à bouillir et, pendant ce temps, coupe les légumes. Quand l’eau bout, il laisse les pâtes cuire et, pendant ce temps, prépare la sauce. Il fait progresser plusieurs tâches sans jamais attendre inactivement.

C’est exactement ce que fait async/await en Python : quand une opération est en attente (I/O), le programme exécute autre chose au lieu de bloquer.

Les bases : async et await

Commençons par le squelette théorique avant de passer à des exemples pratiques.

Une fonction asynchrone se déclare avec async def au lieu de def :

import asyncio

async def dire_bonjour():
    print("Bonjour...")
    await asyncio.sleep(1)  # Simule une attente (I/O)
    print("...le monde !")

# Pour exécuter une fonction async :
asyncio.run(dire_bonjour())

Les mots-clés essentiels :

• async def — déclare une fonction asynchrone (une « coroutine »)
• await — marque un point d’attente : le programme peut suspendre cette tâche et en exécuter une autre
• asyncio.run() — point d’entrée qui lance la boucle d’événements

Premier exemple : synchrone vs asynchrone

Prenons deux fonctions qui « attendent » 2 secondes chacune (simulant une requête réseau) :

Version synchrone (lent)

import time

def operation_lente(n):
    print(f"  Opération {n} commence...")
    time.sleep(2)  # Bloque tout !
    print(f"  Opération {n} terminée.")
    return n * 10

def main_sync():
    debut = time.time()
    resultats = []
    for i in range(4):
        resultats.append(operation_lente(i))
    duree = time.time() - debut
    print(f"Synchrone : {duree:.1f} secondes")
    return resultats

main_sync()
# Sortie : Synchrone : 8.0 secondes

Version asynchrone (rapide)

import asyncio

async def operation_lente_async(n):
    print(f"  Opération {n} commence...")
    await asyncio.sleep(2)  # Laisse la main à d'autres tâches
    print(f"  Opération {n} terminée.")
    return n * 10

async def main_async():
    debut = time.time()
    # Lance toutes les opérations en parallèle
    resultats = await asyncio.gather(
        operation_lente_async(0),
        operation_lente_async(1),
        operation_lente_async(2),
        operation_lente_async(3),
    )
    duree = time.time() - debut
    print(f"Asynchrone : {duree:.1f} secondes")
    return resultats

asyncio.run(main_async())
# Sortie : Asynchrone : 2.0 secondes

Avec asyncio.gather(), les 4 opérations s’exécutent en parallèle et le temps total passe de 8 secondes à seulement 2 secondes. Le gain est de 75 % !

Cas pratique : requêter plusieurs API simultanément

Voici un exemple concret qui utilise aiohttp pour appeler 5 API en même temps :

import asyncio
import aiohttp
import time

async def recuperer_url(session, url, n):
    print(f"🌐 Requête {n} : {url}")
    async with session.get(url) as response:
        data = await response.text()
        taille = len(data)
        print(f"✅ Requête {n} terminée : {taille} caractères")
        return {"url": url, "taille": taille}

async def main():
    urls = [
        "https://jsonplaceholder.typicode.com/posts",
        "https://jsonplaceholder.typicode.com/comments",
        "https://jsonplaceholder.typicode.com/albums",
        "https://jsonplaceholder.typicode.com/photos",
        "https://jsonplaceholder.typicode.com/todos",
    ]
    
    async with aiohttp.ClientSession() as session:
        taches = [recuperer_url(session, url, i) for i, url in enumerate(urls)]
        resultats = await asyncio.gather(*taches)
    
    total = sum(r["taille"] for r in resultats)
    print(f"\n📊 Total : {total} caractères récupérés depuis {len(urls)} APIs")
    return resultats

debut = time.time()
asyncio.run(main())
duree = time.time() - debut
print(f"⏱️ Temps total : {duree:.2f} secondes")

Si chaque requête prenait 1 seconde en synchrone, le total serait de 5 secondes. En asynchrone, le temps total est celui de la plus lente des requêtes (environ 1 seconde).

Gérer les erreurs avec try/await/except

La gestion d’erreurs en asynchrone utilise la même syntaxe familière :

import asyncio

async def requete_risquee(n):
    if n == 3:
        raise ValueError(f"Erreur simulée sur la requête {n}")
    await asyncio.sleep(1)
    return f"Résultat {n}"

async def main():
    taches = [requete_risquee(i) for i in range(5)]
    resultats = []
    
    for coro in asyncio.as_completed(taches):
        try:
            resultat = await coro
            resultats.append(resultat)
        except ValueError as e:
            print(f"⚠️ Exception capturée : {e}")
    
    print(f"Résultats obtenus : {resultats}")

asyncio.run(main())

Tu remarqueras qu’avec asyncio.as_completed(), tu récupères les résultats au fur et à mesure qu’ils arrivent (pas besoin d’attendre la fin de toutes les tâches).

Limiter le nombre de tâches concurrentes

Si tu lances 1000 requêtes simultanées, tu vas saturer ta connexion réseau (et l’API que tu appelles risque de te blacklister). La solution : un Semaphore (ou async with + limite) :

import asyncio

# Limiteur : 3 requêtes simultanées maximum
semaphore = asyncio.Semaphore(3)

async def requete_limitee(n):
    async with semaphore:  # Attend si 3 requêtes sont déjà en cours
        print(f"🚀 Démarrage requête {n}")
        await asyncio.sleep(1)
        print(f"✅ Fin requête {n}")
        return n

async def main():
    # Lance 10 requêtes, mais jamais plus de 3 à la fois
    taches = [requete_limitee(i) for i in range(10)]
    resultats = await asyncio.gather(*taches)
    print(f"Tous les résultats : {resultats}")

asyncio.run(main())

Tu verras que les requêtes démarrent par groupes de 3, chaque groupe attendant qu’une place se libère. C’est indispensable dès que tu travailles avec des API externes.

Les pièges à éviter

La programmation asynchrone en Python a quelques subtilités :

1. ❌ time.sleep() dans une fonction async — time.sleep() bloque tout le programme, même dans une coroutine. Utilise toujours await asyncio.sleep().

2. ❌ Oublier await — Si tu écris ma_fonction_async() sans await, tu obtiens un objet coroutine, pas le résultat. C’est une erreur fréquente.

3. ❌ Mélanger code synchrone et asynchrone — Appeler asyncio.run() plusieurs fois dans le même script peut causer des erreurs. Utilise une seule boucle d’événements.

4. ❌ Opérations CPU-intensive — L’asynchrone est fait pour les opérations I/O (réseau, fichiers, BDD). Pour du calcul pur, utilise multiprocessing ou concurrent.futures.

Quand utiliser async/await (et quand éviter)

Conclusion et prochaines étapes

La programmation asynchrone avec async/await est l’un des super-pouvoirs de Python moderne. Elle te permet d’écrire des applications plus rapides, plus réactives et plus efficaces sans complexité supplémentaire — juste en comprenant quand et comment déléguer l’attente.

Commence par utiliser asyncio.gather() dans tes prochains projets qui font des appels réseau. C’est le plus simple à intégrer et le gain est immédiat.

📘 Maîtrise les fondamentaux de Python — Si ce tutoriel t’a aidé, le cours complet Python : Les Fondamentaux couvre tout ce qu’il faut pour devenir autonome en programmation Python : variables, fonctions, POO, modules et projets pratiques. Découvrir le cours →

Photo de Julia M Cameron sur Pexels