# Multiprocessing Python : définition et exemples

Avec le *multiprocessing* Python, vous pouvez **répartir la charge de travail sur plusieurs processus** afin de réduire le temps d’exécution total. C’est particulièrement avantageux pour les calculs volumineux ou les grandes quantités de données.

## Qu’est-ce que le multiprocessing en Python ?

Le multiprocessing en Python désigne la capacité d’exécuter plusieurs processus simultanément, ce qui permet d’exploiter au mieux la puissance des systèmes **multi-cœurs**. Contrairement aux approches à un seul thread, dans lesquelles les tâches sont exécutées de manière séquentielle, le multiprocessing permet d’exécuter différentes parties du programme en parallèle et indépendamment les unes des autres. Chaque processus dispose de sa propre zone de mémoire et peut être traité sur des cœurs de processeur distincts, ce qui réduit considérablement le temps d’exécution des opérations nécessitant un calcul intensif ou d’être effectuées rapidement.

Les domaines d’application du multiprocessing Python sont multiples. Dans le traitement et l’analyse des données, le multiprocessing est souvent utilisé pour traiter plus rapidement de grands ensembles de données et accélérer les analyses complexes. Le multiprocessing peut également être utilisé dans les **simulations et les calculs de modélisation**, par exemple dans les applications scientifiques, afin de réduire les temps d’exécution des calculs complexes. De plus, le multiprocessing est utile dans le domaine du Web scraping pour la saisie simultanée de données provenant de différents sites Internet ou dans le traitement d’images et la vision par ordinateur pour améliorer l’efficacité des opérations d’analyse d’images.

## Quelles sont les possibilités offertes par le multiprocessing en Python ?

Python offre différentes possibilités pour implémenter le multiprocessing. Nous vous présentons ci-dessous trois outils courants : le module `multiprocessing`, la bibliothèque `concurrent.futures` et le paquet `joblib`.

### Le module `multiprocessing`

Le module `multiprocessing` est le **module standard pour le multiprocessing en Python**. Il permet la création de processus, l’échange de données entre ces processus et la synchronisation par des verrous, des files d’attente et d’autres mécanismes.

```python
import multiprocessing
def task(n):
    result = n * n
    print(f"Result: {result}")
if __name__ == "__main__":
    processes = []
    for i in range(1, 6):
        process = multiprocessing.Process(target=task, args=(i,))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()
```

Dans l’exemple ci-dessus, nous utilisons la classe `multiprocessing.Process` pour créer et lancer des processus qui exécutent la fonction `task()`. Celle-ci calcule le carré du nombre passé en paramètre. Les processus sont initiés et on attend qu’ils se terminent avant de poursuivre le programme principal. Nous affichons le résultat avec une ***f-String***, une méthode String-Format en Python permettant d’intégrer des expressions. L’ordre est aléatoire et non décisif.

Vous pouvez également créer un pool de processus avec Python `multiprocessing` :

```python
import multiprocessing
def task(n):
    return n * n
if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(task, range(1, 6))
        print(results)  # Output: [1, 4, 9, 16, 25]
```

Avec `pool.map()`, la fonction `task()` est appliquée à une séquence de données, et les résultats sont collectés et affichés.

### La bibliothèque `concurrent.futures`

Ce module offre une interface de haut niveau pour une exécution asynchrone et un traitement parallèle des processus. Il utilise le ***Pool-Executor*** pour exécuter des tâches sur un pool de processus ou de threads. Le module `concurrent.futures` est une manière plus simple de traiter des tâches asynchrones et est, dans de nombreux cas, plus facile à gérer que le module `multiprocessing` de Python.

```python
import concurrent.futures
def task(n):
    return n * n
with concurrent.futures.ProcessPoolExecutor() as executor:
    futures = [executor.submit(task, i) for i in range(1, 6)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result()) # result in random order
```

Le code utilise le module `concurrent.futures` pour traiter les tâches en parallèle avec le `ProcessPoolExecutor`. Pour cela, la fonction `task(n)` est passée pour les nombres de 1 à 5. La méthode `as_completed()` attend la fin des tâches et affiche les **résultats dans n’importe quel ordre**.

### Le paquet `joblib`

`joblib` est une bibliothèque Python externe qui a été développée pour simplifier le traitement parallèle en Python, par exemple pour les tâches répétitives comme l’exécution de fonctions avec des paramètres d’entrée différents ou le travail avec de grandes quantités de données. Les fonctions principales de `joblib` se concentrent sur la parallélisation des tâches, la **mise en cache des résultats de fonctions** et l’optimisation des ressources de mémoire et de calcul.

```python
from joblib import Parallel, delayed
def task(n):
    return n * n
results = Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))
print(results) # Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
```

L’expression `Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))` initie l’exécution parallèle de la fonction `task()` pour les nombres de 1 à 10. `Parallel` est configuré avec `n_jobs=4`, ce qui permet de traiter jusqu’à quatre jobs en parallèle. L’appel à `delayed(task)(i)` crée la tâche à exécuter en parallèle pour chaque nombre i dans la plage de 1 à 10. Cela signifie que la fonction `task()` est appelée simultanément pour chacun de ces nombres. Le résultat pour les nombres de 1 à 10 est enregistré dans `results` et sorti.


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/le-multiprocessing-python/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/le-multiprocessing-python/) for AI/LLM consumption.