#El problema que aprenderás a resolver
Un programa consulta veinte servicios. Algunos contestan pronto, otro se queda esperando y uno devuelve un error. El programa debe aprovechar las esperas, conservar los resultados útiles y terminar sin dejar conexiones o tareas olvidadas. Hacer todas las llamadas a la vez solo resuelve una pequeña parte del problema.
Este recorrido explica primero cómo progresa una corrutina, después quién es responsable de sus tareas y por último qué límites necesita un sistema real. Llegarás a un comprobador de endpoints con cliente compartido, cola acotada, plazos, cancelación, salida estructurada y pruebas reproducibles. El código y las decisiones están en estas páginas; el proyecto no depende de descargar una carpeta.
#Qué necesitas al empezar
Python básico: funciones, listas, diccionarios, bucles, excepciones e imports. Se presentan las estructuras menos elementales antes de utilizarlas: contextos asíncronos, grupos de tareas, clases de datos y generadores. No necesitas conocer un framework web.
Los ejemplos están verificados con Python 3.12.3 y HTTPX 0.28.1. TaskGroup y asyncio.timeout existen desde Python 3.11; usamos 3.12 como base coherente. No dependemos de Queue.shutdown, incorporado después, ni de APIs experimentales. Las pausas iniciales son simulaciones identificadas; las pruebas finales utilizan HTTP real contra un servidor local.
python3 --version
python3 -m venv .venv
source .venv/bin/activate
python -m pip install httpx==0.28.1
Un entorno virtual aísla las bibliotecas de este ejercicio del resto de tus proyectos. En Windows se activa con .venv\Scripts\activate. Los primeros cuatro capítulos solo necesitan la biblioteca estándar; HTTPX se introduce en el quinto. Si tu sistema no ofrece python3, usa el ejecutable de Python 3.12 que tengas instalado.
#Un recorrido con preguntas concretas
| Etapa | Pregunta que debes poder contestar |
|---|---|
| Modelo de ejecución | ¿Qué espera, qué ejecuta CPU y cuándo puede avanzar otra tarea? |
| Propiedad y fallos | ¿Quién recoge cada resultado y qué debe pasar si una operación falla? |
| Recursos y capacidad | ¿Cuántos trabajos, conexiones, bytes y segundos puede consumir el programa? |
| Operación | ¿Cómo se detiene, cómo se observa y cómo se demuestra que no pierde control? |
| Proyecto final | ¿Cómo encajan esas decisiones en un programa pequeño pero completo? |
No tienes que aprender todas las primitivas de asyncio para trabajar bien. Debes reconocer qué garantía aporta cada una y qué garantía no aporta. Un semáforo limita entradas simultáneas; no limita cuántas tareas has creado. Un timeout deja de esperar; no deshace un efecto remoto.
#Cómo comprobar que lo entiendes
Cada capítulo tiene una comprobación observable. Ejecuta primero el caso correcto, cambia una decisión y predice el resultado antes de volver a ejecutarlo. Por ejemplo, sustituir await asyncio.sleep() por time.sleep() debe cambiar la progresión de las otras tareas, no solo una cifra de rendimiento.
El mini proyecto se reparte en tres páginas: contrato y servidor de laboratorio, motor concurrente y pruebas de comportamiento. Son partes de una misma implementación y puedes leerlas sin ejecutar nada. Los casos de éxito, timeout, error HTTP, cuerpo excesivo y cancelación aparecen explicados junto al código que los produce.
#Hasta dónde llega el curso
Aprenderás a construir clientes concurrentes, tareas de fondo con dueño, consumidores limitados y servicios que puedan cerrarse de forma predecible. También sabrás cuándo usar hilos o procesos y cuándo una cola en memoria deja de ser suficiente.
Quedan fuera la implementación de un event loop, servidores HTTP escritos a mano para producción y coordinadores distribuidos. Si el trabajo debe sobrevivir a la caída del proceso, necesitarás persistencia y recuperación, no más llamadas a create_task. Ese límite se explica al diseñar el servicio.