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
certificado
Gratis
acceso
NIEVA

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.

Dudas frecuentes

Lo que suele preguntarse

Empieza cuando quieras

Reseñas

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!