0Pricing
Python Academy · Leçon

await, tâches et rassemblement

Utilisez await, asyncio.create_task et asyncio.gather pour exécuter des opérations concurrentes.

await, tâches et rassemblement est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

await ou séquentiel

Utiliser await seul exécute les coroutines séquentiellement. Pour les exécuter concurremment, encapsulez-les dans des tâches.

import asyncio

async def main():
    # Sequential — total ~3 s
    await asyncio.sleep(2)
    await asyncio.sleep(1)

    # Concurrent using gather — total ~2 s
    await asyncio.gather(asyncio.sleep(2), asyncio.sleep(1))

asyncio.create_task()

asyncio.create_task(coro) planifie une coroutine afin qu’elle s’exécute comme une tâche indépendante, en concurrence avec la coroutine actuelle.

import asyncio

async def work(n):
    await asyncio.sleep(n)
    return n

async def main():
    t1 = asyncio.create_task(work(2))
    t2 = asyncio.create_task(work(1))
    r1 = await t1
    r2 = await t2
    print(r1, r2)   # 2 1 (total ~2 s)

asyncio.run(main())

asyncio.gather()

asyncio.gather(*coros) exécute les coroutines en concurrence et renvoie tous les résultats dans l’ordre lorsque leur exécution est terminée.

import asyncio

async def fetch(i):
    await asyncio.sleep(1)
    return f"data-{i}"

async def main():
    results = await asyncio.gather(fetch(1), fetch(2), fetch(3))
    print(results)  # ["data-1", "data-2", "data-3"] in ~1 s

asyncio.run(main())

gather avec return_exceptions

Définissez return_exceptions=True afin qu’une coroutine ayant échoué renvoie son exception comme résultat au lieu d’annuler l’ensemble de gather.

import asyncio

async def risky(n):
    if n == 2: raise ValueError("bad")
    return n

async def main():
    results = await asyncio.gather(
        risky(1), risky(2), risky(3),
        return_exceptions=True
    )
    print(results)   # [1, ValueError("bad"), 3]

asyncio.wait()

asyncio.wait(tasks, return_when=...) renvoie deux ensembles : done et pending. Utilisez FIRST_COMPLETED pour réagir au premier résultat.

import asyncio

async def slow(): await asyncio.sleep(3); return "slow"
async def fast(): await asyncio.sleep(1); return "fast"

async def main():
    tasks = {asyncio.create_task(slow()), asyncio.create_task(fast())}
    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
    for t in pending: t.cancel()

Annulation des tâches

Appelez task.cancel() pour demander l’annulation. La tâche reçoit asyncio.CancelledError à son prochain point d’attente.

import asyncio

async def long_job():
    try:
        await asyncio.sleep(100)
    except asyncio.CancelledError:
        print("Cancelled!")
        raise   # re-raise is required

async def main():
    t = asyncio.create_task(long_job())
    await asyncio.sleep(1)
    t.cancel()
    await t

asyncio.timeout() — Python 3.11+

Entourez un point d’attente de asyncio.timeout(seconds) pour annuler l’opération si elle prend trop de temps.

import asyncio

async def main():
    try:
        async with asyncio.timeout(2):
            await asyncio.sleep(10)   # too slow
    except TimeoutError:
        print("Timed out!")

asyncio.wait_for()

Avec les versions de Python antérieures à 3.11, utilisez asyncio.wait_for(coro, timeout=N) pour ajouter un délai d’attente, ce qui lève asyncio.TimeoutError.

import asyncio

async def slow(): await asyncio.sleep(5)

async def main():
    try:
        await asyncio.wait_for(slow(), timeout=2)
    except asyncio.TimeoutError:
        print("Timed out")

Noms et inspection des tâches

Nommez les tâches pour faciliter le débogage avec asyncio.create_task(coro, name="..."), puis inspectez-les avec task.get_name().

import asyncio

async def worker(): await asyncio.sleep(1)

async def main():
    t = asyncio.create_task(worker(), name="worker-1")
    print(t.get_name())   # worker-1
    await t

TaskGroup — Python 3.11+

asyncio.TaskGroup crée un groupe structuré de tâches. Si une tâche lève une exception, toutes les tâches sont annulées.

import asyncio

async def main():
    async with asyncio.TaskGroup() as tg:
        t1 = tg.create_task(asyncio.sleep(1))
        t2 = tg.create_task(asyncio.sleep(2))
    # all tasks done here

Sémaphore pour limiter le débit

Utilisez asyncio.Semaphore(n) pour limiter le nombre d’opérations simultanées (par exemple, les appels d’API).

import asyncio

sem = asyncio.Semaphore(5)  # max 5 concurrent

async def limited_fetch(url):
    async with sem:
        await fetch(url)   # at most 5 at a time

Vérification rapide

Quelle est la différence entre await coro() et asyncio.create_task(coro()) ?

Récapitulatif

Utilisez create_task ou gather pour l’exécution concurrente. gather rassemble tous les résultats ; wait offre un contrôle précis. Annulez les tâches avec .cancel() et appliquez des délais d’attente avec wait_for ou asyncio.timeout.

Questions Fréquemment Posées

La leçon « await, tâches et rassemblement » est-elle gratuite ?

Oui — le texte complet de « await, tâches et rassemblement » 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 « await, tâches et rassemblement » ?

Utilisez await, asyncio.create_task et asyncio.gather pour exécuter des opérations concurrentes. 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 2 sur 4.

Combien de temps prend la leçon « await, tâches et rassemblement » ?

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