Mul­ti­pro­ces­sing Python : dé­fi­ni­tion et exemples

Avec le mul­ti­pro­ces­sing Python, vous pouvez répartir la charge de travail sur plusieurs processus afin de réduire le temps d’exécution total. C’est par­ti­cu­liè­re­ment avan­ta­geux pour les calculs vo­lu­mi­neux ou les grandes quantités de données.

Qu’est-ce que le mul­ti­pro­ces­sing en Python ?

Le mul­ti­pro­ces­sing en Python désigne la capacité d’exécuter plusieurs processus si­mul­ta­né­ment, ce qui permet d’exploiter au mieux la puissance des systèmes multi-cœurs. Con­trai­re­ment aux approches à un seul thread, dans les­quelles les tâches sont exécutées de manière sé­quen­tielle, le mul­ti­pro­ces­sing permet d’exécuter dif­fé­rentes parties du programme en parallèle et in­dé­pen­dam­ment les unes des autres. Chaque processus dispose de sa propre zone de mémoire et peut être traité sur des cœurs de pro­ces­seur distincts, ce qui réduit con­si­dé­ra­ble­ment le temps d’exécution des opé­ra­tions né­ces­si­tant un calcul intensif ou d’être ef­fec­tuées ra­pi­de­ment.

Les domaines d’ap­pli­ca­tion du mul­ti­pro­ces­sing Python sont multiples. Dans le trai­te­ment et l’analyse des données, le mul­ti­pro­ces­sing est souvent utilisé pour traiter plus ra­pi­de­ment de grands ensembles de données et accélérer les analyses complexes. Le mul­ti­pro­ces­sing peut également être utilisé dans les si­mu­la­tions et les calculs de mo­dé­li­sa­tion, par exemple dans les ap­pli­ca­tions scien­ti­fiques, afin de réduire les temps d’exécution des calculs complexes. De plus, le mul­ti­pro­ces­sing est utile dans le domaine du Web scraping pour la saisie si­mul­ta­née de données provenant de dif­fé­rents sites Internet ou dans le trai­te­ment d’images et la vision par or­di­na­teur pour améliorer l’ef­fi­ca­cité des opé­ra­tions d’analyse d’images.

Quelles sont les pos­si­bi­li­tés offertes par le mul­ti­pro­ces­sing en Python ?

Python offre dif­fé­rentes pos­si­bi­li­tés pour im­plé­men­ter le mul­ti­pro­ces­sing. Nous vous pré­sen­tons ci-dessous trois outils courants : le module multiprocessing, la bi­blio­thèque concurrent.futures et le paquet joblib.

Le module multiprocessing

Le module multiprocessing est le module standard pour le mul­ti­pro­ces­sing en Python. Il permet la création de processus, l’échange de données entre ces processus et la syn­chro­ni­sa­tion par des verrous, des files d’attente et d’autres mé­ca­nismes.

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 pour­suivre le programme principal. Nous affichons le résultat avec une f-String, une méthode String-Format en Python per­met­tant d’intégrer des ex­pres­sions. L’ordre est aléatoire et non décisif.

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

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 bi­blio­thèque concurrent.futures

Ce module offre une interface de haut niveau pour une exécution asyn­chrone et un trai­te­ment 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 asyn­chrones et est, dans de nombreux cas, plus facile à gérer que le module multiprocessing de 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 bi­blio­thèque Python externe qui a été dé­ve­lop­pée pour sim­pli­fier le trai­te­ment parallèle en Python, par exemple pour les tâches ré­pé­ti­tives comme l’exécution de fonctions avec des pa­ra­mètres d’entrée dif­fé­rents ou le travail avec de grandes quantités de données. Les fonctions prin­ci­pales de joblib se con­centrent sur la pa­ral­lé­li­sa­tion des tâches, la mise en cache des résultats de fonctions et l’op­ti­mi­sa­tion des res­sources de mémoire et de calcul.

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’ex­pres­sion 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 si­mul­ta­né­ment pour chacun de ces nombres. Le résultat pour les nombres de 1 à 10 est en­re­gis­tré dans results et sorti.