Python Academy · Lección

Coroutines y el bucle de eventos

Defina coroutines con async def y ejecútelas con asyncio.run().

Coroutines y el bucle de eventos es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

¿Qué es la concurrencia?

Asyncio proporciona concurrencia cooperativa: un solo subproceso gestiona muchas tareas alternando entre ellas cada vez que una espera E/S.

# Traditional: blocking I/O holds the whole thread
# Asyncio: while waiting for I/O, run other coroutines

import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)   # yield control
    print("World")

asyncio.run(main())

async def — Funciones de corrutina

Las funciones definidas con async def son funciones de corrutina. Al llamarlas, devuelven un objeto de corrutina; solo se ejecutan cuando se esperan con await o se programan.

import asyncio

async def greet(name):
    return f"Hello, {name}"

result = asyncio.run(greet("Alice"))
print(result)   # Hello, Alice

El bucle de eventos

El bucle de eventos dirige la ejecución de las corrutinas. asyncio.run(coro) crea un bucle de eventos nuevo, ejecuta la corrutina hasta completarla y cierra el bucle.

import asyncio

async def compute():
    await asyncio.sleep(0)
    return 42

value = asyncio.run(compute())
print(value)   # 42

# For advanced use:
loop = asyncio.new_event_loop()
result = loop.run_until_complete(compute())
loop.close()

await pausa la ejecución

await expr suspende la corrutina actual hasta que expr (otra corrutina o un future) se completa. Mientras tanto, el bucle de eventos ejecuta otras tareas.

import asyncio

async def task(name, delay):
    print(f"{name} starting")
    await asyncio.sleep(delay)
    print(f"{name} done")

async def main():
    await task("A", 2)
    await task("B", 1)   # sequential here

asyncio.run(main())

asyncio.sleep()

asyncio.sleep(seconds) suspende la corrutina actual durante el tiempo indicado sin bloquear el bucle de eventos.

import asyncio

async def heartbeat():
    while True:
        print("ping")
        await asyncio.sleep(1)

# asyncio.run(heartbeat())  # runs forever

Punto de entrada asyncio.run()

asyncio.run(coro) es el punto de entrada estándar de alto nivel. No lo llame nunca desde un bucle de eventos en ejecución.

import asyncio

async def main():
    print("running")

if __name__ == "__main__":
    asyncio.run(main())

Comprobación de si está dentro de un bucle de eventos

Use asyncio.get_running_loop() para detectar si ya hay un bucle en ejecución (genera RuntimeError si no lo hay).

import asyncio

async def inner():
    loop = asyncio.get_running_loop()
    print(f"Loop: {loop}")

asyncio.run(inner())

Ejecución de código bloqueante

Ejecute código limitado por la CPU o código de E/S bloqueante sin bloquear el bucle de eventos mediante loop.run_in_executor(None, func, *args).

import asyncio, time

def blocking():
    time.sleep(2)
    return "done"

async def main():
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, blocking)
    print(result)

asyncio.run(main())

Encadenamiento de corrutinas

Las corrutinas pueden hacer await de otras corrutinas, creando una cadena. El control baja por la cadena y vuelve a subir a medida que se completa cada nivel.

import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return {"value": 42}

async def process():
    data = await fetch_data()
    return data["value"] * 2

async def main():
    result = await process()
    print(result)   # 84

asyncio.run(main())

Identificación de corrutinas

Use asyncio.iscoroutine(obj) o asyncio.iscoroutinefunction(func) para inspeccionar funciones asíncronas durante la ejecución.

import asyncio

async def my_coro():
    pass

print(asyncio.iscoroutinefunction(my_coro))   # True
coro = my_coro()
print(asyncio.iscoroutine(coro))              # True
coro.close()   # clean up the un-awaited coroutine

Modo de depuración de asyncio

Active el modo de depuración para detectar corrutinas cuyo await no se ha realizado, callbacks lentos y otros problemas: establezca PYTHONASYNCIODEBUG=1 o pase debug=True a asyncio.run.

import asyncio

async def main():
    pass

asyncio.run(main(), debug=True)

# Or:
# PYTHONASYNCIODEBUG=1 python script.py

Comprobación rápida

¿Qué hace asyncio.run(coro)?

Resumen

Defina corrutinas con async def, ejecútelas con asyncio.run() y suspéndalas con await. El bucle de eventos programa las corrutinas de forma cooperativa y ejecuta otras mientras una espera E/S.

Preguntas frecuentes

¿La lección «Coroutines y el bucle de eventos» es gratis?

Sí — el texto completo de «Coroutines y el bucle de eventos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Coroutines y el bucle de eventos»?

Defina coroutines con async def y ejecútelas con asyncio.run(). Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Coroutines y el bucle de eventos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Coroutines y el bucle de eventos
await, tareas y recopilación
Gestores e iteradores de contexto asíncronos
Patrones de E/S asíncrona en producción

← Volver a Python Academy