Python Academy · Leçon

Coroutines et boucle d’événements

Définissez des coroutines avec async def et exécutez-les avec asyncio.run().

Coroutines et boucle d’événements est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu’est-ce que la concurrence ?

Asyncio fournit une concurrence coopérative : un seul fil d’exécution gère de nombreuses tâches en passant de l’une à l’autre dès que l’une d’elles attend des IO.

# 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 — Fonctions coroutine

Les fonctions définies avec async def sont des fonctions coroutine. Leur appel renvoie un objet coroutine ; elles ne s’exécutent que lorsqu’elles sont attendues ou planifiées.

import asyncio

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

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

La boucle d’événements

La boucle d’événements pilote l’exécution des coroutines. asyncio.run(coro) crée une nouvelle boucle d’événements, exécute la coroutine jusqu’à son terme, puis ferme la boucle.

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 suspend l’exécution

await expr suspend la coroutine actuelle jusqu’à ce que expr (une autre coroutine ou un futur) soit terminé. Pendant ce temps, la boucle d’événements exécute d’autres tâches.

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) suspend la coroutine actuelle pendant la durée indiquée sans bloquer la boucle d’événements.

import asyncio

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

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

Point d’entrée asyncio.run()

asyncio.run(coro) est le point d’entrée standard au niveau principal. Ne l’appelez jamais depuis une boucle d’événements en cours d’exécution.

import asyncio

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

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

Vérifier si une boucle d’événements est active

Utilisez asyncio.get_running_loop() pour détecter si une boucle est déjà active (l’appel lève RuntimeError dans le cas contraire).

import asyncio

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

asyncio.run(inner())

Exécuter du code bloquant

Exécutez du code limité par le CPU ou effectuant des IO bloquantes sans bloquer la boucle d’événements à l’aide de 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())

Enchaînement de coroutines

Les coroutines peuvent utiliser await sur d’autres coroutines et créer ainsi une chaîne. Le contrôle descend le long de la chaîne, puis remonte à mesure que chaque niveau se termine.

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

Identifier les coroutines

Utilisez asyncio.iscoroutine(obj) ou asyncio.iscoroutinefunction(func) pour examiner les fonctions asynchrones lors de l’exécution.

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

Mode de débogage d’asyncio

Activez le mode de débogage pour détecter les coroutines non attendues, les fonctions de rappel lentes et d’autres problèmes : définissez PYTHONASYNCIODEBUG=1 ou transmettez debug=True à asyncio.run.

import asyncio

async def main():
    pass

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

# Or:
# PYTHONASYNCIODEBUG=1 python script.py

Vérification rapide

Que fait asyncio.run(coro) ?

Récapitulatif

Définissez les coroutines avec async def, exécutez-les avec asyncio.run() et suspendez-les avec await. La boucle d’événements planifie les coroutines de manière coopérative et en exécute d’autres pendant que l’une attend des IO.

Questions Fréquemment Posées

La leçon « Coroutines et boucle d’événements » est-elle gratuite ?

Oui — le texte complet de « Coroutines et boucle d’événements » 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 « Coroutines et boucle d’événements » ?

Définissez des coroutines avec async def et exécutez-les avec asyncio.run(). 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 1 sur 4.

Combien de temps prend la leçon « Coroutines et boucle d’événements » ?

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

Coroutines et boucle d’événements
await, tâches et rassemblement
Gestionnaires de contexte et itérateurs asynchrones
Schémas d’entrées-sorties asynchrones en production

← Retour à Python Academy