Parallele for-Schleife in Python

1. Verwenden Sie das Modul multiprocessing, um die for-Schleife in Python zu parallelisieren
2. Verwenden Sie das Modul joblib, um die for-Schleife in Python zu parallelisieren
3. Verwenden Sie das asyncio-Modul, um die for-Schleife in Python zu parallelisieren

Die Parallelisierung der Schleife bedeutet die parallele Verteilung aller Prozesse unter Verwendung mehrerer Kerne. Wenn wir zahlreiche Jobs haben, wartet nicht jede Berechnung, bis die vorherige in der Parallelverarbeitung abgeschlossen ist. Stattdessen wird für die Vervollständigung ein anderer Prozessor verwendet.

In diesem Artikel werden wir eine for-Schleife in Python parallelisieren.

Verwenden Sie das Modul multiprocessing, um die for-Schleife in Python zu parallelisieren

Um die Schleife zu parallelisieren, können wir das Paket multiprocessing in Python verwenden, da es das Erstellen eines untergeordneten Prozesses durch die Anforderung eines anderen laufenden Prozesses unterstützt.

Das Modul multiprocessing könnte anstelle der for-Schleife verwendet werden, um Operationen auf jedem Element des Iterables auszuführen. Sein multiprocessing.pool()-Objekt könnte verwendet werden, da die Verwendung mehrerer Threads in Python wegen der globalen Interpretersperre keine besseren Ergebnisse liefern würde.

Beispielsweise,

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)

Ausgabe:

0, 1, 3, 6, 10

Verwenden Sie das Modul joblib, um die for-Schleife in Python zu parallelisieren

Das Modul joblib verwendet Multiprocessing, um die mehreren CPU-Kerne auszuführen, um die Parallelisierung der for-Schleife durchzuführen. Es bietet eine leichtgewichtige Pipeline, die das Muster für eine einfache und unkomplizierte parallele Berechnung speichert.

Um eine parallele Verarbeitung durchzuführen, müssen wir die Anzahl der Jobs festlegen, und die Anzahl der Jobs ist auf die Anzahl der Kerne in der CPU begrenzt oder wie viele derzeit verfügbar oder im Leerlauf sind.

Mit der Funktion delayed() können wir Python anweisen, nach einiger Zeit eine bestimmte genannte Methode aufzurufen.

Die Funktion Parallel() erstellt eine parallele Instanz mit spezifizierten Kernen (hier 2).

Wir müssen eine Liste für die Ausführung des Codes erstellen. Dann wird die Liste an Parallel übergeben, das zwei Threads entwickelt und die Aufgabenliste an sie verteilt.

Siehe den Code unten.

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))

Ausgabe:

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

Verwenden Sie das asyncio-Modul, um die for-Schleife in Python zu parallelisieren

Das Modul asyncio ist Single-Threaded und führt die Ereignisschleife aus, indem es die Coroutine mit den Methoden yield from oder await vorübergehend anhält.

Der folgende Code wird parallel ausgeführt, wenn er aufgerufen wird, ohne dass sich dies auf die wartende Hauptfunktion auswirkt. Die Schleife läuft auch parallel zur Hauptfunktion.

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")

Ausgabe:

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