asyncio est le framework Python pour les I/O concurrents utilisant async/await. Il exécute de nombreuses opérations I/O de manière coopérative sur un single thread via une event loop — efficace pour le travail I/O-bound haute concurrence (appels réseau, serveurs web) sans la surcharge des threads.
import asyncio
async def fetch_data(id): # an async function = a coroutine
print(f"start {id}")
await asyncio.sleep(1) # await a non-blocking I/O operation (yields control)
print(f"done {id}")
return id
asyncio.run(fetch_data(1)) # run a coroutine from sync code
Une fonction async def est une coroutine ; await la suspend à un point I/O, permettant à l'event loop d'exécuter d'autres coroutines entretemps — puis la reprend quand l'opération attendue se termine.
# ❌ sequential — total time ≈ 3 seconds
async def slow():
await fetch_data(1) # wait 1s
await fetch_data(2) # then wait 1s
await fetch_data(3) # then wait 1s
# ✅ concurrent — total time ≈ 1 second (all run together)
async def fast():
await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
asyncio.gather exécute les coroutines concurremment — tandis qu'une attend I/O, les autres progressent. Trois attentes d'1 seconde se chevauchent en ~1 seconde au total. C'est la valeur centrale : chevaucher de nombreuses attentes I/O sur un seul thread.
Threading: OS-managed, preemptive, real threads (GIL-limited for CPU)
asyncio: single thread, COOPERATIVE — coroutines yield at `await` points
→ lighter weight (handle thousands of connections), no thread overhead,
but one CPU-heavy coroutine blocks everything (no preemption)
async def bad():
time.sleep(5) # ❌ BLOCKS the whole event loop (sync sleep)
result = heavy_compute() # ❌ CPU work freezes all coroutines
async def good():
await asyncio.sleep(5) # ✅ non-blocking
# offload CPU work to a thread/process pool
await loop.run_in_executor(None, heavy_compute)
Parce que c'est coopératif et single-threaded, tout appel bloquant/CPU-heavy gèle toutes les coroutines. Utilisez des APIs async awaitable, et déléguez le travail bloquant/CPU à un executor.
✓ High-concurrency I/O: web servers (FastAPI), web scraping, many API/DB calls,
websockets, real-time apps — thousands of concurrent connections efficiently
✗ CPU-bound work — use multiprocessing instead (asyncio doesn't help)
asyncio est l'approche moderne pour les I/O haute concurrence en Python, alimentant des frameworks comme FastAPI et permettant la gestion efficace de milliers de connexions simultanées sur un seul thread — beaucoup plus léger que thread-par-connexion.
Comprendre les coroutines, await, l'exécution concurrente avec gather, et surtout la règle cardinale (ne jamais bloquer l'event loop ; déléguer le travail CPU/bloquant) est essentiel pour écrire du Python async performant.
Savoir quand cela convient (concurrence I/O-bound) par rapport à quand cela ne convient pas (CPU-bound → multiprocessing) est clé pour l'utiliser efficacement.