How asyncio's Event Loop Schedules Tasks

Curso de Python Avanzado para Arquitectura de Proyectos y PyPI

Contenido del curso

Calidad de Código: Automatización y Validación

Rendimiento medición de velocidad y memoria

Programación concurrente con asyncio

Distribución y empaquetamiento

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:005:31

How asyncio's Event Loop Schedules Tasks

Curso de Python Avanzado para Arquitectura de Proyectos y PyPI

Clase 14 de 17

Clase 14 / 17

Recursos

The asyncio event loop is the engine that coordinates every coroutine in your Python program, deciding when to pause and resume tasks so multiple I/O operations can progress without blocking. If you are learning asynchronous programming, understanding how the event loop schedules work is the difference between writing code that feels async and code that actually runs concurrently.

Think of it as a conductor: it does not play any instrument, but it cues every musician to play at the right moment.

What does the event loop actually do under the hood?

The loop runs a continuous cycle with four predictable steps. Once you internalize them, the rest of asyncio stops feeling like magic.

Check ready tasks. It looks for coroutines that can run right now.
Run until await. Each task executes until it hits an await.
Pause and register. The paused task is stored, and the loop notes what it is waiting for.
Repeat. It goes back to step one.

This is what allows multiple network calls, file reads or API requests to make progress at the same time on a single thread.

What is the event loop in asyncio? It is the scheduler that runs coroutines, pauses them on await, and resumes them when their awaited operation is ready. You usually access it through asyncio.run.

How do I create my own event loop instead of using asyncio.run?

Most of the time you will write asyncio.run(main()) and let Python handle the loop for you. But you can also build it manually, which is useful when you need precise control.

Here is the manual flow shown in class. First, import asyncio and create the loop with asyncio.new_event_loop(), storing it in a variable like my_loop. Then tell asyncio which loop to use by calling asyncio.set_event_loop(my_loop).

After that, you wrap your execution in a try block and run your coroutine with my_loop.run_until_complete(task). The translation is literal: run until this task is complete. Finally, close the loop in a finally block, because an open loop consumes server resources.

python import asyncio

my_loop = asyncio.new_event_loop() asyncio.set_event_loop(my_loop)

try: my_loop.run_until_complete(main()) finally: my_loop.close()

When you execute this with python src/async_await.py, the output is identical to using asyncio.run. The difference is that now you hold a reference to the loop and can tweak it, attach more task sets, or skip others depending on your needs.

How do I enable debug mode on the event loop?

Once you have your own loop variable, you can call my_loop.set_debug(True) to turn on detailed diagnostics. For the messages to appear, you also need to switch your logger from INFO to DEBUG at the top of the file.

When you run the script again, asyncio will print logs from its internal module, including which selector it is using to pick tasks. That selector is what decides which coroutine runs next, and you can replace it or build a custom one if your use case demands it.

When should I turn on asyncio debug mode? Turn it on while developing or troubleshooting slow coroutines, unexpected blocking calls, or selector behavior. Keep it off in production because it adds overhead.

When should you manage the loop manually versus using asyncio.run?

Manual management is the right call in a few specific scenarios. Outside of those, the simpler API wins.

When you need fine grained control over the loop lifecycle.
When you integrate asyncio with another framework that expects to share or own the loop.
When you do advanced debugging, like enabling set_debug(True) to inspect selectors and scheduling.

For everything else, stick with asyncio.run. It is shorter, safer, and handles loop creation and cleanup automatically.

Is asyncio.run the same as creating a new event loop manually? Functionally yes for simple scripts. asyncio.run creates a fresh loop, runs your coroutine to completion, and closes it. The manual version exposes each of those steps so you can intervene.

Why does this cycle make concurrency possible?

The loop is simple but powerful. It checks ready tasks, runs each one until an await, pauses and registers it, and repeats. That tight cycle is exactly what lets multiple I/O operations progress concurrently on a single thread without blocking the program.

With this foundation you can start wiring asyncio into real projects. As a challenge, find a library that lets you query APIs asynchronously and try integrating it into your code. In the next class we will walk through that integration step by step. ¿Qué librería async vas a probar primero? Déjalo en los comentarios.

Resumen

Think of it as a conductor: it does not play any instrument, but it cues every musician to play at the right moment.

What does the event loop actually do under the hood?

The loop runs a continuous cycle with four predictable steps. Once you internalize them, the rest of asyncio stops feeling like magic.

Check ready tasks. It looks for coroutines that can run right now.
Run until await. Each task executes until it hits an await.
Pause and register. The paused task is stored, and the loop notes what it is waiting for.
Repeat. It goes back to step one.

This is what allows multiple network calls, file reads or API requests to make progress at the same time on a single thread.

What is the event loop in asyncio? It is the scheduler that runs coroutines, pauses them on await, and resumes them when their awaited operation is ready. You usually access it through asyncio.run.

How do I create my own event loop instead of using asyncio.run?

Most of the time you will write asyncio.run(main()) and let Python handle the loop for you. But you can also build it manually, which is useful when you need precise control.

python import asyncio

my_loop = asyncio.new_event_loop() asyncio.set_event_loop(my_loop)

try: my_loop.run_until_complete(main()) finally: my_loop.close()

How do I enable debug mode on the event loop?

When should I turn on asyncio debug mode? Turn it on while developing or troubleshooting slow coroutines, unexpected blocking calls, or selector behavior. Keep it off in production because it adds overhead.

When should you manage the loop manually versus using asyncio.run?

Manual management is the right call in a few specific scenarios. Outside of those, the simpler API wins.

When you need fine grained control over the loop lifecycle.
When you integrate asyncio with another framework that expects to share or own the loop.
When you do advanced debugging, like enabling set_debug(True) to inspect selectors and scheduling.

For everything else, stick with asyncio.run. It is shorter, safer, and handles loop creation and cleanup automatically.

Is asyncio.run the same as creating a new event loop manually? Functionally yes for simple scripts. asyncio.run creates a fresh loop, runs your coroutine to completion, and closes it. The manual version exposes each of those steps so you can intervene.

Why does this cycle make concurrency possible?

Gabriel Obregón

Hace un año

🎨Event Loop de asyncio

🔷 NÚCLEO DEL TEMA: EL EVENT LOOP

🧩 Qué es: El event loop es el motor central de asyncio. 🔊 Funciona como un director de orquesta: coordina, sincroniza y mantiene el ritmo de todas las corutinas.

📌 Su misión principal:

· Mantener las tareas en movimiento

· Evitar bloqueos

· Gestionar pausas y reanudaciones

🔷 CÓMO FUNCIONA EL LOOP (Vista Gráfica del Ciclo)

🔄 Ciclo en bucle:

➡️ 1. Escanea qué tareas están listas

➡️ 2. Ejecuta cada una hasta su await

➡️ 3. Pausa la tarea y registra qué está esperando

➡️ 4. Reanuda cuando la condición de espera se cumple

➡️ 5. Repite continuamente sin bloquear el programa

Imagen mental: ⚙️→⚙️→⚙️→⚙️ (cada engranaje es una tarea avanzando por turnos)

🔷 ASÍ AVANZAN LAS TAREAS (Vista Paso a Paso)

🟦 Selección de tareas pendientes

🟦 Avance de cada tarea hasta su await

🟦 Espera de evento, IO o señal

🟦 Reanudación automática cuando llega la señal

🟦 Progreso gradual sin hilos adicionales

🔷 DECISIÓN CLAVE: asyncio.run o loop manual

✔️ asyncio.run — Opción recomendada

Ideal cuando buscas: ✨ Simplicidad ✨ Seguridad ✨ Creación y cierre automático ✨ Código más limpio

Piensa en: Auto + piloto automático

🛠️ Loop manual — Opción avanzada

Úsalo cuando necesitas: 🔧 Control total del ciclo de vida 🔧 Integración con sistemas que ya tienen su propio loop 🔧 Inspección profunda del funcionamiento interno

Piensa en: Auto + transmisión manual + acceso al motor

🔷 CREAR TU PROPIO LOOP (Mapa Visual del Proceso)

🟩 1. Crear loop → new_event_loop

🟨 2. Registrar loop → set_event_loop

🟧 3. Ejecutar tarea → run_until_complete

🟥 4. Cerrar loop → close (siempre)

Diagrama mental: [crear] → [registrar] → [ejecutar] → [cerrar]

Código:

import asyncio

async def main():

return "ok"

loop = asyncio.new_event_loop()

asyncio.set_event_loop(loop)

try:

loop.set_debug(True)

loop.run_until_complete(main())

finally:

loop.close()

🔷 MODO DEBUG (Vista Sensorial de lo que ocurre dentro)

🔍 Activa loop.set_debug(True) para ver:

· Cambios internos del loop

· Qué tareas se seleccionan

· Cuándo avanzan

· Qué selector de IO está en uso

📡 Con logging en nivel debug, obtienes una “radiografía” del comportamiento interno de asyncio.

Calidad de Código: Automatización y Validación

Python That Lasts in Production

Configuración inicial del proyecto Platy News con Python

Ruff: Formatea automáticamente código Python con facilidad

Fixing Real Type Errors With MyPy

Ruff Linter: Catch Python Bugs Before Runtime

Configuración de pre-commit con Ruff y MyPy para validar código

Ejecución paralela de pruebas unitarias con pytest y coverage

Configuración de GitHub Actions para CI/CD con Python

Configuración de logging y Sentry para monitoreo en producción

Rendimiento medición de velocidad y memoria

Medición de rendimiento de código con Timeit en Python

Análisis de rendimiento en Python con cProfile y Snakeviz

Programación concurrente con asyncio

Programación asíncrona en Python con AsyncIO para operaciones I/O

Sintaxis async y await en Python para concurrencia eficiente

How asyncio's Event Loop Schedules Tasks

Migración de Request síncrono a HTTPX asíncrono en Python

Distribución y empaquetamiento

Automate Dev Tasks with Make Targets

Publicación de paquetes Python con UV y TestPyPI

How asyncio's Event Loop Schedules Tasks

Progreso del curso

Calidad de Código: Automatización y Validación

Rendimiento medición de velocidad y memoria

Programación concurrente con asyncio

Distribución y empaquetamiento

Recursos

Recursos