GuíaAvanzado
Guía de Async y Concurrencia en Python
La concurrencia no acelera el trabajo: elimina el tiempo en que tu programa no estaba trabajando. Esa distinción entre esperar (red, disco, un servicio externo) y calcular (procesador al 100%) es la que decide toda esta guía y la que casi nadie tiene clara antes de empezarla. Trabajas sobre un solo caso realista —Faro, un servicio que vigila el precio de 300 productos en 12 tiendas en línea y hoy tarda 40 minutos porque hace todo de forma secuencial— y lo llevas, módulo a módulo, a un recolector concurrente de unos 2 minutos. Aprendes el modelo mental real de `async`/`await` (por qué `async def` por sí solo no acelera nada), a lanzar y controlar cientos de tareas con límites de cortesía para no tumbar al otro lado, a manejar fallas parciales y cancelación, a usar hilos cuando el código bloqueante es ajeno y no se puede reescribir (como una librería de terceros), y a usar procesos cuando el trabajo es cómputo puro que ningún `async` ni ningún hilo va a acelerar por el GIL. La guía cierra con los problemas que solo aparecen en producción con volumen y tiempo real —memoria, conexiones, apagado ordenado, depuración de bugs intermitentes— y con un proyecto final donde defiendes con números qué herramienta usaste en cada capa y qué dejaste deliberadamente secuencial.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Distinguir con precisión trabajo de espera de trabajo de cómputo, midiendo con `time.perf_counter()` y `time.process_time()` en vez de adivinar
- Entender qué es realmente una corrutina, qué hace `await` y por qué `async def` no acelera nada por sí solo, solo cuando hay algo más con qué solaparlo
- Lanzar y coordinar cientos de tareas concurrentes con `asyncio.TaskGroup`, `asyncio.Semaphore` para limitar la carga por recurso, y tiempos de espera con `asyncio.timeout`
- Manejar fallas parciales, excepciones dentro de tareas y cancelación cooperativa, decidiendo con criterio cuándo abortar todo y cuándo continuar con lo que sí funcionó
- Usar hilos (`asyncio.to_thread`) para integrar código bloqueante ajeno que no se puede reescribir, sin congelar el bucle de eventos
- Reconocer y evitar condiciones de carrera en datos compartidos entre hilos
- Usar procesos (`ProcessPoolExecutor`) para paralelizar cómputo real, calculando antes el costo de arranque y de paso de datos entre procesos
- Reconocer los problemas que solo aparecen con volumen y tiempo en producción: fugas de memoria, agotamiento de conexiones, apagado que deja trabajo a medias, bugs que solo ocurren una de cada cien corridas
- Elegir con criterio entre `async`, hilos y procesos según la naturaleza real del trabajo, en vez de aplicar concurrencia por reflejo
- Medir la mejora de un sistema concurrente de forma honesta y defender por escrito qué partes se dejaron secuenciales y por qué
Antes de empezar
Qué necesitas traer
Es para ti si...
- Desarrolladores Python de nivel intermedio que ya usaron `async`/`await` por instrucción de un framework (FastAPI, por ejemplo) pero nunca entendieron por qué funciona
- Devs con un script o servicio lento por hacer muchas llamadas de red una tras otra, que sospechan que la concurrencia ayudaría pero no saben por dónde empezar
- Equipos que necesitan integrar una librería de terceros que bloquea y no tiene versión asíncina, sin congelar el resto de su aplicación
- Personas preparando entrevistas técnicas donde se pregunta por el GIL, la diferencia entre concurrencia y paralelismo, o cuándo usar hilos frente a procesos
- Cualquiera que haya escrito código con `asyncio` que "funciona" pero nunca fue medido, y quiere saber si de verdad está ganando algo
Requisitos y materiales
- Saber Python: funciones, clases, excepciones, y haber escrito programas que llaman a una API o leen archivos
- No se requiere experiencia previa con asincronía, hilos ni procesos
- Conviene haber sentido el problema que resuelve esta guía: un script que tarda minutos haciendo peticiones una por una mientras la computadora no hace nada
- No es necesario conocer FastAPI ni ningún framework: se explica el porqué de `async def` en un framework sin enseñar el framework
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Presentación del módulo: el problema que resuelve la concurrencia
- 2. Dónde se va el tiempo de tu programa
- 3. Trabajo de espera y trabajo de cómputo
- 4. Concurrencia no es paralelismo
- 5. El GIL en cristiano
- 6. Las tres herramientas y cuándo sirve cada una
- 7. Medir antes de elegir
- 8. Proyecto: diagnostica dónde espera tu programa
- 1. Presentación del módulo: qué es realmente una corrutina
- 2. `async def` no hace nada rápido por sí solo
- 3. `await`: ceder el turno, no esperar sentado
- 4. El bucle de eventos como repartidor de turnos
- 5. La corrutina que nadie esperó
- 6. Tu primer programa asíncrono de verdad
- 7. Por qué un `sleep` bloqueante arruina todo
- 8. Proyecto: convierte un script secuencial
- 1. Presentación del módulo: de una en una a todas juntas
- 2. Tareas: poner algo a correr sin esperarlo
- 3. Esperar a un grupo de tareas
- 4. Grupos de tareas y por qué son la forma recomendada
- 5. Limitar cuántas corren a la vez
- 6. Resultados que llegan en desorden
- 7. Tiempos de espera y qué hacer cuando se agotan
- 8. Proyecto: 300 consultas en el tiempo de una
- 1. Presentación del módulo: los errores cambian de forma
- 2. Excepciones dentro de tareas concurrentes
- 3. Una falla entre trescientas: seguir o abortar
- 4. Cancelación: cómo se detiene una tarea
- 5. Limpiar al salir aunque te cancelen
- 6. Reintentar sin tumbar al otro lado
- 7. Errores que solo aparecen con concurrencia
- 8. Proyecto: haz robusto tu recolector
- 1. Presentación del módulo: cuándo async no alcanza
- 2. Qué es un hilo y qué comparte
- 3. Código bloqueante que no puedes reescribir
- 4. Sacar el bloqueo del bucle de eventos
- 5. Datos compartidos y la condición de carrera
- 6. Candados y por qué se usan lo menos posible
- 7. Cuándo hilos le ganan a async
- 8. Proyecto: integra una librería bloqueante
- 1. Presentación del módulo: el trabajo que sí quema CPU
- 2. Por qué los hilos no ayudan con el cómputo
- 3. Procesos: memoria separada, costo de arranque
- 4. Repartir trabajo entre procesos
- 5. Pasar datos entre procesos y lo que cuesta
- 6. Cuándo NO vale la pena paralelizar
- 7. Mezclar async con procesos
- 8. Proyecto: acelera el cálculo del reporte
- 1. Presentación del módulo: lo que cambia cuando corre en serio
- 2. Ser buen ciudadano con el sistema del otro
- 3. Conexiones: abrir, reusar y cerrar bien
- 4. Presión de memoria con miles de tareas
- 5. Depurar código concurrente
- 6. Registrar lo que pasa cuando pasa a la vez
- 7. Apagar ordenadamente
- 8. Proyecto: prepara Faro para producción
- 1. Presentación del módulo: juntar las tres herramientas
- 2. Diseñar el flujo antes de escribirlo
- 3. La capa de espera: consultas concurrentes
- 4. La capa de cómputo: el reporte en procesos
- 5. La capa bloqueante: la librería que no cede
- 6. Medir la mejora de verdad
- 7. Qué NO hiciste concurrente y por qué
- 8. Proyecto final: Faro de 40 minutos a 2
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!