Python Academy · Lección

Gestores e iteradores de contexto asíncronos

Implemente los protocolos async with y async for.

Gestores e iteradores de contexto asíncronos es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 3 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.

Sentencia async with

Use async with para gestores de contexto cuya configuración o liberación implique esperar operaciones de E/S. El objeto gestionado debe implementar __aenter__ y __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 y aexit

Ambos son corrutinas. Se espera a __aenter__ al entrar y a __aexit__ al salir, incluso si se produjo una excepción.

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 escribir gestores de contexto asíncronos como funciones generadoras así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())

Sentencia async for

async for itera sobre un iterable asíncrono, es decir, uno que implementa __aiter__ y __anext__. Cada iteración puede implicar operaciones 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())

Generadores asíncronos

Una función async def que contiene yield es un generador asíncrono. Use async for para consumirlo.

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 de archivos asíncrona

La biblioteca aiofiles envuelve las operaciones de archivo en gestores de contexto e iteradores así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())

Sesión de cliente de aiohttp

aiohttp.ClientSession es un gestor de contexto asíncrono para realizar solicitudes 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"))

Varios gestores de contexto asíncronos

Apile varias cláusulas async with en una sola línea (forma entre paréntesis de Python 3.10+).

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 gestiona un conjunto dinámico de gestores de contexto así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)

Pruebas de código asíncrono con pytest-asyncio

pytest-asyncio permite escribir funciones de prueba asíncronas con el 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

Resumen del protocolo de iteradores asíncronos

Un objeto es un iterable asíncrono si tiene __aiter__. Es un iterador asíncrono si también tiene __anext__. Los generadores asíncronos implementan ambos automáticamente.

import asyncio

async def gen():
    yield 1
    yield 2

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

Comprobación rápida

¿Qué métodos dunder debe implementar un objeto para poder usarse con async with?

Recapitulación

Use async with para los recursos que necesitan una configuración o liberación asíncrona. Use async for para los iterables que producen valores de forma asíncrona. Los generadores asíncronos simplifican la creación de iteradores asíncronos. Bibliotecas como aiofiles y aiohttp proporcionan operaciones de archivo y HTTP nativas para código asíncrono.

Preguntas frecuentes

¿La lección «Gestores e iteradores de contexto asíncronos» es gratis?

Sí — el texto completo de «Gestores e iteradores de contexto asíncronos» 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 «Gestores e iteradores de contexto asíncronos»?

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

¿Cuánto tiempo toma la lección «Gestores e iteradores de contexto asíncronos»?

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