La programmation asynchrone est une forme de programmation parallèle qui permet à une unité de travail de fonctionner séparément du travail principal du programme. C’est un moyen efficace de traiter des tâches qui peuvent s’exécuter simultanément et ne nécessitent pas que d’autres opérations soient terminées.
Python 3.4 a introduit les bibliothèques asyncio et concurrent.futures pour faciliter la programmation asynchrone. L’exécution asynchrone en Python peut être réalisée de plusieurs façons. Voici comment vous pouvez le faire.
1. Utilisant asyncio et coroutines:
Python 3.5+ a introduit le mot-clé async qui permet de définir les coroutines et le mot-clé await qui peut être utilisé pour attendre une coroutine.
Un exemple simple:
```
import asyncio
async def count(): print(“Un,”) await asyncio.sleep(1) print(“deux”)
async def main(): await asyncio.gather(count(), count(), count())
asyncio.run(main())
```
1. Utilisant les threads:
Vous pouvez également utiliser les threads qui sont inclus dans la bibliothèque standard.
Un exemple simple:
```
import threading
def worker(num): “”“thread worker function”““ print(‘Worker: %s’ % num)
threads = []
for i in range(5):
t = threading.Thread(target=worker, args=(i,))
threads.append(t)
t.start()
```
1. Utilisant multiprocessing module:
```
from multiprocessing import Process
def f(name): print(‘hello’, name)
if name == ‘main’:
p = Process(target=f, args=(‘bob’,))
p.start()
p.join()
```
Cela dit, il est important de comprendre l’évolution de Python, les librairies disponibles et les avantages/inconvénients de chaque approche. La meilleure approche dépend des exigences spécifiques de votre tâche.
