Nutze Python Mul­tipro­ces­sing, um die Ar­beits­last auf mehrere Prozesse zu verteilen und so die Aus­füh­rungs­zeit deutlich zu verkürzen. Das zahlt sich besonders bei re­chen­in­ten­si­ven Aufgaben oder großen Da­ten­men­gen aus.

Was ist Python Mul­tipro­ces­sing?

Mul­tipro­ces­sing in Python er­mög­licht es dir, mehrere Prozesse simultan laufen zu lassen. Dadurch nutzt du die Power von Multi-Core-Systemen voll aus. Im Gegensatz zu Single-Thread-Verfahren, die Aufgaben nach­ein­an­der ab­ar­bei­ten, laufen beim Mul­tipro­ces­sing ver­schie­de­ne Pro­gramm­tei­le parallel und autark ab. Jeder Prozess nutzt dabei seinen eigenen Speicher und eigene Pro­zes­sor­ker­ne. Das reduziert die Wartezeit bei komplexen oder zeit­kri­ti­schen Ope­ra­tio­nen massiv.

Die Ein­satz­ge­bie­te für Python Mul­tipro­ces­sing sind extrem viel­sei­tig. In der Da­ten­ana­ly­se hilft es dir, riesige Da­ten­sät­ze schneller zu bündeln und aus­zu­wer­ten. Auch bei Si­mu­la­tio­nen und wis­sen­schaft­li­chen Modellen verkürzt Mul­tipro­ces­sing die Re­chen­zeit spürbar. Zudem pro­fi­tierst du beim Web-Scraping durch das gleich­zei­ti­ge Abrufen ver­schie­de­ner Quellen oder in der Bild­ver­ar­bei­tung (Computer Vision), wo komplexe Analysen so erst richtig effizient werden.

Welche Mög­lich­kei­ten für Python Mul­tipro­ces­sing gibt es?

Python bietet dir ver­schie­de­ne Wege, Mul­tipro­ces­sing um­zu­set­zen. Wir zeigen dir hier drei gängige Ansätze: das multiprocessing-Modul, die concurrent.futures-Bi­blio­thek und das joblib-Paket.

Das multiprocessing-Modul

Das multiprocessing-Modul ist das Stan­dard­werk­zeug für Python Mul­tipro­ces­sing. Damit erstellst du Prozesse, tauscht Daten zwischen ihnen aus und syn­chro­ni­sierst sie mittels Sperren oder War­te­schlan­gen.

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

In diesem Beispiel nutzen wir die Klasse multiprocessing.Process, um Prozesse für die Funktion task() zu starten. Diese berechnet das Quadrat einer Zahl. Wir in­iti­ie­ren die Prozesse und warten auf deren Abschluss, bevor das Haupt­pro­gramm wei­ter­läuft. Die Ausgabe erfolgt via f-String, einer ef­fi­zi­en­ten Python-String-Format-Methode. Beachte, dass die Rei­hen­fol­ge der Er­geb­nis­se hier zufällig ist.

Al­ter­na­tiv kannst du mit Python multiprocessing auch einen Pro­zess­pool anlegen:

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]
python

Über pool.map() wird die Funktion task() auf eine ganze Da­ten­se­quenz an­ge­wen­det, wobei die Er­geb­nis­se gesammelt aus­ge­ge­ben werden.

Die concurrent.futures-Bi­blio­thek

Dieses Modul bietet dir eine kom­for­ta­ble High-Level-Schnitt­stel­le für asyn­chro­ne und parallele Abläufe. Es nutzt den Pool-Executor, um Aufgaben auf Prozesse oder Threads zu verteilen. concurrent.futures ist oft in­tui­ti­ver zu bedienen als das reine multiprocessing-Modul, wenn es um einfache asyn­chro­ne Tasks geht.

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
python

Der Code verwendet concurrent.futures-Modul, um Aufgaben mit dem ProcessPoolExecutor parallel zu erledigen. Hier wird die Funktion task(n) für die Zahlen 1 bis 5 auf­ge­ru­fen. Die Methode as_completed() wartet, bis alles fertig ist, und liefert die Er­geb­nis­se in be­lie­bi­ger Abfolge zurück.

joblib

joblib ist eine externe Bi­blio­thek, die Par­al­le­li­sie­rung in Python ver­ein­facht – ideal für re­pe­ti­ti­ve Aufgaben mit ver­schie­de­nen Pa­ra­me­tern oder riesige Da­ten­men­gen. Die Stärken von joblib liegen in der einfachen Par­al­le­li­sie­rung, dem Caching von Er­geb­nis­sen und der Schonung deiner Sys­tem­res­sour­cen.

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: Results of the function for numbers from 1 to 10
python

Mit Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) startest du die parallele Be­rech­nung der Funktion task() für die Werte 1 bis 10. Durch die Kon­fi­gu­ra­ti­on Parallel mit n_jobs=4 werden bis zu vier Jobs gleich­zei­tig ab­ge­ar­bei­tet. Der Aufruf von delayed(task)(i) bereitet die par­al­le­len Tasks für jede Zahl i vor. So läuft task() simultan für alle Werte ab, und das End­ergeb­nis landet gesammelt in results.

Zum Hauptmenü