Python Academy · Aula

Corrotinas e o laço de eventos

Defina corrotinas com async def e execute-as com asyncio.run().

Corrotinas e o laço de eventos é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 1 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.

O que é concorrência?

Asyncio fornece concorrência cooperativa: uma única thread gerencia muitas tarefas alternando entre elas sempre que uma está aguardando 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 — funções de corrotina

Funções definidas com async def são funções de corrotina. Chamá-las retorna um objeto de corrotina; elas só são executadas quando aguardadas ou agendadas.

import asyncio

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

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

O loop de eventos

O loop de eventos conduz a execução das corrotinas. asyncio.run(coro) cria um novo loop de eventos, executa a corrotina até a conclusão e fecha o loop.

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 a execução

await expr suspende a corrotina atual até que expr (outra corrotina ou um futuro) seja concluído. Enquanto isso, o loop de eventos executa outras tarefas.

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 a corrotina atual pelo tempo especificado sem bloquear o loop de eventos.

import asyncio

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

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

asyncio.run() como ponto de entrada

asyncio.run(coro) é o ponto de entrada padrão no nível superior. Nunca o chame de dentro de um loop de eventos em execução.

import asyncio

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

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

Verificando se está dentro de um loop de eventos

Use asyncio.get_running_loop() para detectar se um loop já está em execução (gera RuntimeError caso não esteja).

import asyncio

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

asyncio.run(inner())

Executando código bloqueante

Execute código limitado pela CPU ou com E/S bloqueante sem bloquear o loop de eventos usando 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())

Encadeamento de corrotinas

As corrotinas podem usar await com outras corrotinas, criando uma cadeia. O controle desce pela cadeia e retorna à medida que cada nível é concluído.

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

Identificando corrotinas

Use asyncio.iscoroutine(obj) ou asyncio.iscoroutinefunction(func) para inspecionar funções assíncronas em tempo de execução.

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 depuração do asyncio

Ative o modo de depuração para detectar corrotinas não aguardadas, callbacks lentos e outros problemas: defina PYTHONASYNCIODEBUG=1 ou passe debug=True para asyncio.run.

import asyncio

async def main():
    pass

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

# Or:
# PYTHONASYNCIODEBUG=1 python script.py

Verificação rápida

O que asyncio.run(coro) faz?

Recapitulação

Defina corrotinas com async def, execute-as com asyncio.run() e suspenda-as com await. O loop de eventos agenda corrotinas de forma cooperativa, executando outras enquanto uma aguarda E/S.

Perguntas Frequentes

A aula “Corrotinas e o laço de eventos” é grátis?

Sim — o texto completo de “Corrotinas e o laço de eventos” é 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 “Corrotinas e o laço de eventos”?

Defina corrotinas com async def e execute-as com asyncio.run(). 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 1 de 4.

Quanto tempo leva a aula “Corrotinas e o laço de eventos”?

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

Corrotinas e o laço de eventos
await, tarefas e agrupamento
Gerenciadores de contexto e iteradores assíncronos
Padrões de E/S assíncrona em produção

← Voltar para Python Academy