¿Cuándo suele aportar más asyncio?

Asyncio mejora uso del tiempo de espera en I/O concurrente; no es la solución principal para CPU intensivo.

Asincronía con asyncio: concurrencia eficiente para I/O en Python

Comprende `async/await`, event loop y tareas concurrentes para mejorar throughput en operaciones de red o disco sin bloquear.

¿Cuánto sabes de Python?

📘 Teoría

1) Modelo mental: coroutine + event loop

El event loop coordina tareas cooperativas; cada `await` abre espacio para otras tareas.

Una coroutine no se ejecuta por sí sola: debe ser esperada (`await`) o programada como tarea.

`asyncio.run(...)` crea y gestiona el loop principal para scripts simples.

Si una coroutine llama funciones bloqueantes (por ejemplo `time.sleep`), se rompe la ventaja asíncrona.

Coroutine mínima

import asyncio


async def saludo() -> None:
    await asyncio.sleep(0.2)
    print('hola async')


asyncio.run(saludo())

2) Ejecutar tareas concurrentes con gather

La ganancia aparece cuando esperas múltiples operaciones I/O independientes.

Con ejecución secuencial, tres llamadas de 1s tardan ~3s. Con `gather`, pueden completar cerca de ~1s total.

`gather` devuelve resultados en el orden de las tareas enviadas.

Maneja excepciones conscientemente (`return_exceptions=True`) si no quieres abortar todo el lote al primer fallo.

Concurrencia de tareas I/O

import asyncio


async def pedir(id_: int) -> str:
    await asyncio.sleep(1)
    return f'dato-{id_}'


async def main() -> None:
    resultados = await asyncio.gather(pedir(1), pedir(2), pedir(3))
    print(resultados)


asyncio.run(main())

3) Errores comunes y buenas prácticas

La asincronía mal aplicada complica más de lo que ayuda.

Si necesitas librerías síncronas en flujo async, evalúa wrappers específicos o ejecución en hilos/procesos según caso.

Medir latencia y throughput antes/después te ayuda a justificar complejidad añadida.

Asincronía es una herramienta de arquitectura, no un fin en sí mismo.

No mezcles funciones bloqueantes dentro de coroutines críticas.
Define límites de concurrencia (semaforos) si llamas APIs con rate limit.
Cancela tareas huérfanas y controla timeout por operación.
Mantén separación entre capa asíncrona y dominio de negocio.

Timeout defensivo

import asyncio


async def tarea_lenta() -> str:
    await asyncio.sleep(2)
    return 'ok'


async def main() -> None:
    try:
        res = await asyncio.wait_for(tarea_lenta(), timeout=1)
        print(res)
    except TimeoutError:
        print('timeout controlado')


asyncio.run(main())

1 1) Modelo mental: coroutine + event loop 2 2) Ejecutar tareas concurrentes con gather 3 3) Errores comunes y buenas prácticas