0Pricing
Python Academy · Aula

await, tarefas e agrupamento

Use await, asyncio.create_task e asyncio.gather para obter concorrência.

await, tarefas e agrupamento é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

await versus sequencial

Usar apenas await executa as corrotinas sequencialmente. Para executá-las concorrentemente, envolva-as em 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) agenda uma corrotina para ser executada como uma Task independente, concorrentemente com a corrotina atual.

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) executa corrotinas concorrentemente e retorna todos os resultados na ordem quando todas são concluídas.

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 com return_exceptions

Defina return_exceptions=True para que uma corrotina com falha retorne sua exceção como resultado, em vez de cancelar todo o 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=...) retorna dois conjuntos: done e pending. Use FIRST_COMPLETED para reagir ao primeiro 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()

Cancelamento de tarefas

Chame task.cancel() para solicitar o cancelamento. A tarefa recebe asyncio.CancelledError no próximo ponto 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+

Envolva um await com asyncio.timeout(seconds) para cancelar a operação se ela demorar demais.

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()

No Python < 3.11, use asyncio.wait_for(coro, timeout=N) para adicionar um tempo limite, gerando 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")

Nomes e inspeção de tarefas

Dê nomes às tarefas para facilitar a depuração com asyncio.create_task(coro, name="...") e inspecione-as com 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 cria um grupo estruturado de tarefas. Se alguma tarefa gerar uma exceção, todas serão canceladas.

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 limitação de taxa

Use asyncio.Semaphore(n) para limitar o número de operações simultâneas (por exemplo, chamadas de 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

Verificação rápida

Qual é a diferença entre await coro() e asyncio.create_task(coro())?

Recapitulação

Use create_task ou gather para executar operações simultaneamente. gather reúne todos os resultados; wait oferece um controle mais detalhado. Cancele tarefas com .cancel() e aplique tempos limite com wait_for ou asyncio.timeout.

Perguntas Frequentes

A aula “await, tarefas e agrupamento” é grátis?

Sim — o texto completo de “await, tarefas e agrupamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “await, tarefas e agrupamento”?

Use await, asyncio.create_task e asyncio.gather para obter concorrência. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “await, tarefas e agrupamento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Corrotinas e o laço de eventos
  2. await, tarefas e agrupamento
  3. Gerenciadores de contexto e iteradores assíncronos
  4. Padrões de E/S assíncrona em produção
← Voltar para Python Academy