Parallèle pour la boucle en Python

1. Utiliser le module multiprocessing pour paralléliser la boucle for en Python
2. Utilisez le module joblib pour paralléliser la boucle for en Python
3. Utiliser le module asyncio pour paralléliser la boucle for en Python

Paralléliser la boucle signifie répartir tous les processus en parallèle en utilisant plusieurs cœurs. Lorsque nous avons de nombreux travaux, chaque calcul n’attend pas la fin du précédent en traitement parallèle. Au lieu de cela, il utilise un processeur différent pour l’achèvement.

Dans cet article, nous allons paralléliser une boucle for en Python.

Utiliser le module multiprocessing pour paralléliser la boucle for en Python

Pour paralléliser la boucle, nous pouvons utiliser le package multiprocessing en Python car il prend en charge la création d’un processus enfant à la demande d’un autre processus en cours.

Le module multiprocessing pourrait être utilisé à la place de la boucle for pour exécuter des opérations sur chaque élément de l’itérable. Son objet multiprocessing.pool() pourrait être utilisé, car l’utilisation de plusieurs threads en Python ne donnerait pas de meilleurs résultats à cause du verrouillage de l’interpréteur global.

Par example,

import multiprocessing


def sumall(value):
    return sum(range(1, value + 1))


pool_obj = multiprocessing.Pool()

answer = pool_obj.map(sumall, range(0, 5))
print(answer)

Production:

0, 1, 3, 6, 10

Utilisez le module joblib pour paralléliser la boucle for en Python

Le module joblib utilise le multitraitement pour exécuter les multiples cœurs du processeur afin d’effectuer la parallélisation de la boucle for. Il fournit un pipeline léger qui mémorise le modèle pour un calcul parallèle simple et direct.

Pour effectuer un traitement parallèle, nous devons définir le nombre de tâches, et le nombre de tâches est limité au nombre de cœurs dans le processeur ou au nombre de tâches disponibles ou inactives pour le moment.

La fonction delayed() nous permet de dire à Python d’appeler une méthode mentionnée particulière après un certain temps.

La fonction Parallel() crée une instance parallèle avec des cœurs spécifiés (2 dans ce cas).

Nous devons créer une liste pour l’exécution du code. Ensuite, la liste est transmise à parallèle, qui développe deux threads et leur distribue la liste des tâches.

Voir le code ci-dessous.

from joblib import Parallel, delayed
import math


def sqrt_func(i, j):
    time.sleep(1)
    return math.sqrt(i ** j)


Parallel(n_jobs=2)(delayed(sqrt_func)(i, j) for i in range(5) for j in range(2))

Production:

[1.0,
 0.0,
 1.0,
 1.0,
 1.0,
 1.4142135623730951,
 1.0,
 1.7320508075688772,
 1.0,
 2.0]

Utiliser le module asyncio pour paralléliser la boucle for en Python

Le module asyncio est monothread et exécute la boucle d’événement en suspendant temporairement la coroutine à l’aide des méthodes yield from ou await.

Le code ci-dessous s’exécutera en parallèle lorsqu’il sera appelé sans affecter la fonction principale à attendre. La boucle fonctionne également en parallèle avec la fonction principale.

import asyncio
import time


def background(f):
    def wrapped(*args, **kwargs):
        return asyncio.get_event_loop().run_in_executor(None, f, *args, **kwargs)

    return wrapped


@background
def your_function(argument):
    time.sleep(2)
    print("function finished for " + str(argument))


for i in range(10):
    your_function(i)


print("loop finished")

Production:

ended execution for 4
ended execution for 8
ended execution for 0
ended execution for 3
ended execution for 6
ended execution for 2
ended execution for 5
ended execution for 7
ended execution for 9
ended execution for 1