0Pricing
Python Academy · Lección

await, tareas y recopilación

Utilice await, asyncio.create_task y asyncio.gather para la concurrencia.

await, tareas y recopilación es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 2 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.

await frente a ejecución secuencial

Usar await por sí solo ejecuta las corrutinas secuencialmente. Para ejecutarlas de forma concurrente, envuélvalas en Tasks.

import asyncio

async def main():
    # Sequential — total ~3 s
    await asyncio.sleep(2)
    await asyncio.sleep(1)

    # Concurrent using gather — total ~2 s
    await asyncio.gather(asyncio.sleep(2), asyncio.sleep(1))

asyncio.create_task()

asyncio.create_task(coro) programa una corrutina como una Task independiente que se ejecuta de forma concurrente con la corrutina actual.

import asyncio

async def work(n):
    await asyncio.sleep(n)
    return n

async def main():
    t1 = asyncio.create_task(work(2))
    t2 = asyncio.create_task(work(1))
    r1 = await t1
    r2 = await t2
    print(r1, r2)   # 2 1 (total ~2 s)

asyncio.run(main())

asyncio.gather()

asyncio.gather(*coros) ejecuta corrutinas de forma concurrente y devuelve todos los resultados en orden cuando se completan.

import asyncio

async def fetch(i):
    await asyncio.sleep(1)
    return f"data-{i}"

async def main():
    results = await asyncio.gather(fetch(1), fetch(2), fetch(3))
    print(results)  # ["data-1", "data-2", "data-3"] in ~1 s

asyncio.run(main())

gather con return_exceptions

Establezca return_exceptions=True para que una corrutina fallida devuelva su excepción como resultado en lugar de cancelar todo el gather.

import asyncio

async def risky(n):
    if n == 2: raise ValueError("bad")
    return n

async def main():
    results = await asyncio.gather(
        risky(1), risky(2), risky(3),
        return_exceptions=True
    )
    print(results)   # [1, ValueError("bad"), 3]

asyncio.wait()

asyncio.wait(tasks, return_when=...) devuelve dos conjuntos: done y pending. Use FIRST_COMPLETED para reaccionar al primer resultado.

import asyncio

async def slow(): await asyncio.sleep(3); return "slow"
async def fast(): await asyncio.sleep(1); return "fast"

async def main():
    tasks = {asyncio.create_task(slow()), asyncio.create_task(fast())}
    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
    for t in pending: t.cancel()

Cancelación de tareas

Llame a task.cancel() para solicitar la cancelación. La tarea recibe asyncio.CancelledError en su siguiente punto de await.

import asyncio

async def long_job():
    try:
        await asyncio.sleep(100)
    except asyncio.CancelledError:
        print("Cancelled!")
        raise   # re-raise is required

async def main():
    t = asyncio.create_task(long_job())
    await asyncio.sleep(1)
    t.cancel()
    await t

asyncio.timeout() — Python 3.11+

Envuelva un await con asyncio.timeout(seconds) para cancelar la operación si tarda demasiado.

import asyncio

async def main():
    try:
        async with asyncio.timeout(2):
            await asyncio.sleep(10)   # too slow
    except TimeoutError:
        print("Timed out!")

asyncio.wait_for()

En Python < 3.11, use asyncio.wait_for(coro, timeout=N) para añadir un tiempo de espera, lo que genera asyncio.TimeoutError.

import asyncio

async def slow(): await asyncio.sleep(5)

async def main():
    try:
        await asyncio.wait_for(slow(), timeout=2)
    except asyncio.TimeoutError:
        print("Timed out")

Nombres e inspección de tareas

Asigne nombres a las tareas para facilitar la depuración con asyncio.create_task(coro, name="...") e inspecciónelas con task.get_name().

import asyncio

async def worker(): await asyncio.sleep(1)

async def main():
    t = asyncio.create_task(worker(), name="worker-1")
    print(t.get_name())   # worker-1
    await t

TaskGroup — Python 3.11+

asyncio.TaskGroup crea un grupo estructurado de tareas. Si alguna tarea genera una excepción, todas se cancelan.

import asyncio

async def main():
    async with asyncio.TaskGroup() as tg:
        t1 = tg.create_task(asyncio.sleep(1))
        t2 = tg.create_task(asyncio.sleep(2))
    # all tasks done here

Semáforo para limitar la tasa

Use asyncio.Semaphore(n) para limitar el número de operaciones simultáneas, como las llamadas a API.

import asyncio

sem = asyncio.Semaphore(5)  # max 5 concurrent

async def limited_fetch(url):
    async with sem:
        await fetch(url)   # at most 5 at a time

Comprobación rápida

¿Cuál es la diferencia entre await coro() y asyncio.create_task(coro())?

Recapitulación

Use create_task o gather para la ejecución simultánea. gather recopila todos los resultados; wait ofrece un control más preciso. Cancele las tareas con .cancel() y aplique tiempos de espera con wait_for o asyncio.timeout.

Preguntas frecuentes

¿La lección «await, tareas y recopilación» es gratis?

Sí — el texto completo de «await, tareas y recopilación» 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 «await, tareas y recopilación»?

Utilice await, asyncio.create_task y asyncio.gather para la concurrencia. 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 2 de 4.

¿Cuánto tiempo toma la lección «await, tareas y recopilación»?

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

  1. Coroutines y el bucle de eventos
  2. await, tareas y recopilación
  3. Gestores e iteradores de contexto asíncronos
  4. Patrones de E/S asíncrona en producción
← Volver a Python Academy