Python Academy · Aula

Gerenciadores de contexto e iteradores assíncronos

Implemente os protocolos async with e async for.

Gerenciadores de contexto e iteradores assíncronos é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 3 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.

Instrução async with

Use async with para gerenciadores de contexto cuja configuração ou finalização envolva aguardar operações de E/S. O objeto gerenciado deve implementar __aenter__ e __aexit__.

import asyncio

class AsyncFile:
    async def __aenter__(self):
        print("open")
        return self
    async def __aexit__(self, *args):
        print("close")

async def main():
    async with AsyncFile() as f:
        print("using")

asyncio.run(main())

aenter e aexit

Ambos são corrotinas. __aenter__ é aguardado na entrada; __aexit__ é aguardado na saída, mesmo que tenha ocorrido uma exceção.

import asyncio

class DBSession:
    async def __aenter__(self):
        self.conn = await async_connect()
        return self.conn

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            await self.conn.rollback()
        else:
            await self.conn.commit()
        await self.conn.close()
        return False

@asynccontextmanager

contextlib.asynccontextmanager permite escrever gerenciadores de contexto assíncronos como funções geradoras assíncronas.

from contextlib import asynccontextmanager
import asyncio

@asynccontextmanager
async def managed_resource():
    print("acquire")
    try:
        yield {"status": "ready"}
    finally:
        print("release")

async def main():
    async with managed_resource() as r:
        print(r["status"])

asyncio.run(main())

Instrução async for

async for itera sobre um iterável assíncrono — aquele que implementa __aiter__ e __anext__. Cada iteração pode envolver operações de E/S.

import asyncio

class AsyncCounter:
    def __init__(self, n): self.n, self.i = n, 0
    def __aiter__(self): return self
    async def __anext__(self):
        if self.i >= self.n: raise StopAsyncIteration
        await asyncio.sleep(0)
        self.i += 1
        return self.i

async def main():
    async for val in AsyncCounter(3):
        print(val)

asyncio.run(main())

Geradores assíncronos

Uma função async def que contém yield é um gerador assíncrono. Use async for para consumi-lo.

import asyncio

async def ticker(n):
    for i in range(n):
        await asyncio.sleep(1)
        yield i

async def main():
    async for val in ticker(3):
        print(val)   # 0, 1, 2 with 1-s pauses

asyncio.run(main())

aiofiles para E/S assíncrona de arquivos

A biblioteca aiofiles envolve operações de arquivo em gerenciadores de contexto e iteradores assíncronos.

# pip install aiofiles
import aiofiles, asyncio

async def main():
    async with aiofiles.open("data.txt", "r") as f:
        async for line in f:
            print(line.strip())

Sessão de cliente aiohttp

aiohttp.ClientSession é um gerenciador de contexto assíncrono para fazer solicitações HTTP simultâneas.

# pip install aiohttp
import aiohttp, asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.json()

asyncio.run(fetch("https://api.example.com/data"))

Vários gerenciadores de contexto assíncronos

Empilhe várias cláusulas async with em uma linha (a forma entre parênteses do Python 3.10 ou posterior).

import asyncio

async def main():
    async with (
        open_db() as db,
        open_cache() as cache,
    ):
        data = await db.fetch("SELECT 1")
        await cache.set("key", data)

AsyncExitStack

contextlib.AsyncExitStack gerencia um conjunto dinâmico de gerenciadores de contexto assíncronos.

from contextlib import AsyncExitStack
import asyncio

async def main():
    async with AsyncExitStack() as stack:
        conn1 = await stack.enter_async_context(connect("db1"))
        conn2 = await stack.enter_async_context(connect("db2"))
        await process(conn1, conn2)

Testando código assíncrono com pytest-asyncio

pytest-asyncio permite escrever funções de teste assíncronas com o marcador @pytest.mark.asyncio.

# pip install pytest-asyncio
import pytest, asyncio

async def fetch(): return 42

@pytest.mark.asyncio
async def test_fetch():
    result = await fetch()
    assert result == 42

Resumo do protocolo de iterador assíncrono

Um objeto é um iterável assíncrono se tiver __aiter__. Ele é um iterador assíncrono se também tiver __anext__. Os geradores assíncronos implementam ambos automaticamente.

import asyncio

async def gen():
    yield 1
    yield 2

async def main():
    g = gen()
    print(await g.__anext__())   # 1
    print(await g.__anext__())   # 2

Verificação rápida

Quais métodos especiais um objeto deve implementar para ser usado com async with?

Recapitulação

Use async with para recursos que precisam de configuração ou finalização assíncronas. Use async for para iteráveis que produzem valores de forma assíncrona. Os geradores assíncronos simplificam a criação de iteradores assíncronos. Bibliotecas como aiofiles e aiohttp fornecem operações assíncronas nativas para arquivos e HTTP.

Perguntas Frequentes

A aula “Gerenciadores de contexto e iteradores assíncronos” é grátis?

Sim — o texto completo de “Gerenciadores de contexto e iteradores assíncronos” é 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 “Gerenciadores de contexto e iteradores assíncronos”?

Implemente os protocolos async with e async for. 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 3 de 4.

Quanto tempo leva a aula “Gerenciadores de contexto e iteradores assíncronos”?

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