Tutoriel : Créer des tâches (Tasks) en Python

Introduction

Une task représente une unité de travail exécutée de manière indépendante.

Python propose principalement :

Technique	Cas d'utilisation
asyncio	E/S asynchrones (HTTP, sockets, fichiers, etc.)
threading	Plusieurs tâches qui attendent des E/S simultanément
multiprocessing	Calcul intensif (CPU)

asyncio n'accélère pas les calculs CPU. Il permet surtout d'éviter qu'un programme reste bloqué pendant des opérations d'entrée/sortie.

---

1. Première coroutine

import asyncio

async def dire_bonjour():
    print("Bonjour")
    await asyncio.sleep(2)
    print("Au revoir")

asyncio.run(dire_bonjour())

---

2. Créer une Task

import asyncio

async def travail():
    print("Début")
    await asyncio.sleep(3)
    print("Fin")

async def main():
    task = asyncio.create_task(travail())

    print("Autre travail...")
    await task

asyncio.run(main())

---

3. Plusieurs tâches simultanément

import asyncio

async def telecharger(n):
    print(f"Début {n}")
    await asyncio.sleep(n)
    print(f"Fin {n}")

async def main():
    tasks = [
        asyncio.create_task(telecharger(3)),
        asyncio.create_task(telecharger(2)),
        asyncio.create_task(telecharger(1)),
    ]

    await asyncio.gather(*tasks)

asyncio.run(main())

---

4. Producteur / consommateur

import asyncio

queue = asyncio.Queue()

async def producteur():
    for i in range(5):
        await queue.put(i)
        print("Produit", i)

async def consommateur():
    while True:
        item = await queue.get()
        print("Consommé", item)
        queue.task_done()

async def main():
    c = asyncio.create_task(consommateur())
    await producteur()
    await queue.join()
    c.cancel()

asyncio.run(main())

---

5. Les Threads

from threading import Thread
import time

def travail(n):
    print("Début", n)
    time.sleep(2)
    print("Fin", n)

threads=[]

for i in range(3):
    t=Thread(target=travail,args=(i,))
    t.start()
    threads.append(t)

for t in threads:
    t.join()

---

6. asyncio + Thread

import asyncio
import time

def calcul():
    time.sleep(5)
    return 42

async def main():
    resultat = await asyncio.to_thread(calcul)
    print(resultat)

asyncio.run(main())

---

7. Annuler une tâche

import asyncio

async def travail():
    try:
        while True:
            print("...")
            await asyncio.sleep(1)
    except asyncio.CancelledError:
        print("Annulée")
        raise

async def main():
    t = asyncio.create_task(travail())

    await asyncio.sleep(3)

    t.cancel()

    try:
        await t
    except asyncio.CancelledError:
        pass

asyncio.run(main())

---

8. Timeout

import asyncio

async def travail():
    await asyncio.sleep(10)

async def main():
    try:
        await asyncio.wait_for(travail(), timeout=3)
    except asyncio.TimeoutError:
        print("Temps dépassé")

asyncio.run(main())

---

Bonnes pratiques

• Utiliser asyncio pour les E/S.
• Utiliser threading pour lancer plusieurs opérations bloquantes.
• Utiliser multiprocessing pour les calculs intensifs.
• Toujours attendre (await) une Task.
• Gérer CancelledError.

Résumé

Besoin	Solution
Plusieurs requêtes HTTP	asyncio
Plusieurs téléchargements	asyncio
Lecture simultanée de fichiers	threads ou asyncio
Calcul scientifique	multiprocessing
Interface graphique + tâche de fond	threads