asyncio es el framework de Python para I/O concurrente mediante async/await. Ejecuta muchas operaciones de I/O de forma cooperativa en un único hilo a través de un bucle de eventos: eficiente para trabajo limitado por I/O con alta concurrencia (llamadas de red, servidores web) sin la sobrecarga de los hilos.
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
Una función async def es una corrutina; await la suspende en un punto de I/O, dejando que el bucle de eventos ejecute otras corrutinas mientras tanto, y luego la reanuda cuando la operación esperada se completa.
# ❌ 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 ejecuta corrutinas de forma concurrente: mientras una espera por I/O, las otras avanzan. Tres esperas de 1 segundo se solapan en ~1 segundo en total. Ese es el valor central: solapar muchas esperas de I/O en un solo hilo.
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)
Como es cooperativo y de un solo hilo, cualquier llamada bloqueante o intensiva en CPU congela todas las corrutinas. Usa APIs asíncronas que se puedan esperar con await, y delega el trabajo bloqueante o de CPU a 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 es el enfoque moderno para el I/O de alta concurrencia en Python, impulsando frameworks como FastAPI y permitiendo manejar eficientemente miles de conexiones simultáneas en un solo hilo, mucho más ligero que un hilo por conexión.
Comprender las corrutinas, await, la ejecución concurrente con gather y, sobre todo, la regla cardinal (nunca bloquear el bucle de eventos; delegar el trabajo de CPU o bloqueante) es esencial para escribir Python asíncrono con buen rendimiento.
Saber cuándo encaja (concurrencia limitada por I/O) frente a cuándo no (limitado por CPU → multiprocessing) es clave para usarlo con eficacia.
Una biblioteca de preguntas de entrevista de IT con respuestas detalladas — de Junior a Senior.
Donar