0Pricing
Python Academy · Leçon

Gestionnaires de contexte et itérateurs asynchrones

Implémentez les protocoles async with et async for.

Gestionnaires de contexte et itérateurs asynchrones est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Instruction async with

Utilisez async with pour les gestionnaires de contexte dont la préparation et le nettoyage impliquent des opérations d’E/S en attente. L’objet géré doit implémenter __aenter__ et __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__ et __aexit__

Ce sont toutes deux des coroutines. __aenter__ est attendu à l’entrée ; __aexit__ est attendu à la sortie, même si une exception s’est produite.

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 permet d’écrire des gestionnaires de contexte asynchrones sous forme de fonctions génératrices asynchrones.

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

Instruction async for

async for parcourt un itérable asynchrone — c’est-à-dire un objet qui implémente __aiter__ et __anext__. Chaque itération peut impliquer des opérations d’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())

Générateurs asynchrones

Une fonction async def contenant yield est un générateur asynchrone. Utilisez async for pour le consommer.

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 pour les E/S asynchrones sur les fichiers

La bibliothèque aiofiles encapsule les opérations sur les fichiers dans des gestionnaires de contexte et des itérateurs asynchrones.

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

Session cliente aiohttp

aiohttp.ClientSession est un gestionnaire de contexte asynchrone permettant d’effectuer des requêtes HTTP simultanées.

# 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"))

Plusieurs gestionnaires de contexte asynchrones

Placez plusieurs clauses async with sur une seule ligne (forme parenthésée de Python 3.10 ou version ultérieure).

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 gère un ensemble dynamique de gestionnaires de contexte asynchrones.

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)

Tester du code asynchrone avec pytest-asyncio

pytest-asyncio permet d’écrire des fonctions de test asynchrones avec le marqueur @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

Récapitulatif du protocole des itérateurs asynchrones

Un objet est un itérable asynchrone s’il possède __aiter__. C’est un itérateur asynchrone s’il possède également __anext__. Les générateurs asynchrones implémentent automatiquement les deux.

import asyncio

async def gen():
    yield 1
    yield 2

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

Vérification rapide

Quelles méthodes spéciales un objet doit-il implémenter pour être utilisé avec async with ?

Récapitulatif

Utilisez async with pour les ressources qui nécessitent une préparation et un nettoyage asynchrones. Utilisez async for pour les itérables qui produisent des valeurs de manière asynchrone. Les générateurs asynchrones simplifient la création d’itérateurs asynchrones. Des bibliothèques comme aiofiles et aiohttp fournissent des opérations asynchrones natives sur les fichiers et HTTP.

Questions Fréquemment Posées

La leçon « Gestionnaires de contexte et itérateurs asynchrones » est-elle gratuite ?

Oui — le texte complet de « Gestionnaires de contexte et itérateurs asynchrones » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestionnaires de contexte et itérateurs asynchrones » ?

Implémentez les protocoles async with et async for. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Gestionnaires de contexte et itérateurs asynchrones » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Coroutines et boucle d’événements
  2. await, tâches et rassemblement
  3. Gestionnaires de contexte et itérateurs asynchrones
  4. Schémas d’entrées-sorties asynchrones en production
← Retour à Python Academy