PYTHON ASYNC
asyncio & coroutines

La programmation asynchrone permet à ton programme de faire autre chose pendant qu'il attend (réseau, fichier, timer) au lieu de rester bloqué. En Python, c'est le module asyncio qui gère ça : un seul thread, une event loop, et des coroutines qui se passent la main aux moments d'attente.

Pourquoi ? Parce que dans un programme classique, requests.get() ou time.sleep() gèlent TOUT. Si tu dois faire 100 requêtes API, tu les fais une par une. Avec async, tu les lances toutes et tu récupères les résultats au fur et à mesure.

import asyncio                          # le module standard, rien à installer


async def charger_niveau(nom: str, duree: float) -> str:
    # async def → cette fonction est une coroutine
    print(f"Chargement de {nom}...")
    await asyncio.sleep(duree)          # attente NON bloquante : la loop fait autre chose
    print(f"{nom} prêt !")
    return nom                           # une coroutine peut retourner une valeur


async def main() -> None:
    # await seul = séquentiel (1.0s + 0.5s = 1.5s au total)
    await charger_niveau("Map", 1.0)
    await charger_niveau("Sons", 0.5)

    # gather = concurrent (max(1.0, 0.5) = 1.0s au total !)
    resultats = await asyncio.gather(
        charger_niveau("Map", 1.0),
        charger_niveau("Sons", 0.5),
    )
    print(resultats)                     # ['Map', 'Sons'] — ordre des arguments conservé


asyncio.run(main())                      # démarre la event loop — UN SEUL run par programme

Le projet type : un générateur qui yield 10 nombres aléatoires, une compréhension qui les collecte, et la mesure de runtime qui prouve la concurrence.

#!/usr/bin/env python3
"""Générateur async, compréhension async et mesure de runtime."""
import asyncio
import random
import time
from typing import AsyncGenerator, List


async def async_generator() -> AsyncGenerator[float, None]:
    """Yield 10 nombres aléatoires, en attendant 1s entre chaque."""
    for _ in range(10):
        await asyncio.sleep(1)          # await possible ENTRE les yields
        yield random.uniform(0, 10)     # yield → générateur async


async def async_comprehension() -> List[float]:
    """Collecte les 10 nombres via une compréhension async."""
    return [n async for n in async_generator()]   # ≈ 10 secondes


async def measure_runtime() -> float:
    """Lance 4 compréhensions EN PARALLÈLE et mesure le temps total."""
    debut = time.perf_counter()
    await asyncio.gather(*(async_comprehension() for _ in range(4)))
    return time.perf_counter() - debut    # ≈ 10s, PAS 40s !

# ── DÉCLARER ────────────────────────────────────────────
async def quete() -> str: ...      # coroutine (ne tourne pas toute seule)

# ── EXÉCUTER ────────────────────────────────────────────
asyncio.run(main())                # point d'entrée : démarre la event loop
await quete()                      # exécute et attend (rend la main pendant)

# ── CONCURRENCE ─────────────────────────────────────────
await asyncio.gather(a(), b())     # tout en même temps, résultats dans l'ordre
t = asyncio.create_task(c())       # démarre en fond MAINTENANT
await t                            # récupère le résultat plus tard
asyncio.as_completed(tasks)        # itère par ordre de FIN

# ── GÉNÉRATEURS & COMPRÉHENSIONS ────────────────────────
async def gen(): yield x            # générateur async (await possible entre yields)
async for x in gen(): ...          # consomme sans bloquer la loop
[x async for x in gen()]           # compréhension async (dans un async def)

# ── ATTENTES ────────────────────────────────────────────
await asyncio.sleep(1)             # pause non bloquante (PAS time.sleep !)
await asyncio.wait_for(f(), 5)     # timeout → asyncio.TimeoutError

# ── LA RÈGLE D'OR ───────────────────────────────────────
# I/O (réseau, disque, timer)  → asyncio
# Calcul CPU                   → multiprocessing
# Code simple sans attente     → reste synchrone !