# Python Multiprocessing: Parallele Verarbeitung von Prozessen

Mit Python Multiprocessing können Sie die **Arbeitslast auf mehrere Prozesse aufteilen**, um die Gesamtausführungszeit zu verkürzen. Das ist besonders vorteilhaft bei umfangreichen Berechnungen oder großen Datenmengen.

## Was ist Python Multiprocessing?

Multiprocessing in Python bezeichnet die Fähigkeit, mehrere Prozesse gleichzeitig auszuführen, wodurch die Leistung von **Multi-Core-Systemen** optimal genutzt wird. Im Gegensatz zu Single-Thread-Ansätzen, bei denen Aufgaben sequenziell abgearbeitet werden, können mit Multiprocessing verschiedene Teile des Programms parallel und unabhängig voneinander ablaufen. Jeder Prozess verfügt über einen eigenen Speicherbereich und kann auf separaten Prozessorkernen verarbeitet werden, wodurch sich die Ausführungszeit für rechenaufwendige oder zeitkritische Operationen erheblich reduziert.

Die Einsatzgebiete von Python Multiprocessing sind vielfältig. In der Datenverarbeitung und Analyse wird Multiprocessing häufig verwendet, um große Datensätze schneller zu verarbeiten und komplexe Analysen zu beschleunigen. Auch in **Simulationen und Modellierungsberechnungen**, beispielsweise in wissenschaftlichen Anwendungen, kann Multiprocessing eingesetzt werden, um die Ausführungszeiten von komplexen Berechnungen zu verkürzen. Darüber hinaus findet Multiprocessing Anwendung im Bereich des Web-Scrapings für die gleichzeitige Erfassung von Daten von verschiedenen Webseiten oder in der Bildverarbeitung sowie Computer Vision, um die Effizienz von Operationen zur Bildanalyse zu verbessern.

## Welche Möglichkeiten für Python Multiprocessing gibt es?

Python bietet verschiedene Möglichkeiten, Multiprocessing zu implementieren. Im Folgenden stellen wir Ihnen drei gängige Tools vor: das `multiprocessing`-Modul, die `concurrent.futures`-Bibliothek und das `joblib`-Paket.

### Das `multiprocessing`-Modul

Das `multiprocessing`-Modul ist das **Standardmodul für Python Multiprocessing**. Es ermöglicht die Erstellung von Prozessen, den Austausch von Daten zwischen diesen Prozessen und die Synchronisierung durch Sperren, Warteschlangen und andere Mechanismen.

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

Im obigen Beispiel benutzen wir die Klasse `multiprocessing.Process`, um Prozesse zu erstellen und zu starten, die die Funktion `task()` ausführen. Diese berechnet das Quadrat der übergebenen Zahl. Die Prozesse werden initiiert und es wird auf ihre Beendigung gewartet, bevor das Hauptprogramm fortgesetzt wird. Das Ergebnis geben wir mit einem **f-String** aus, eine [Python-String-Format](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-string-format/)-Methode zum Verknüpfen von Ausdrücken. Die Reihenfolge ist zufällig und nicht deterministisch.

Sie können auch einen Prozesspool mit Python `multiprocessing` erzeugen:

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

Mit `pool.map()` wird die Funktion `task()` auf eine Sequenz von Daten angewendet, und die Ergebnisse werden gesammelt und ausgegeben.

### Die `concurrent.futures`-Bibliothek

Dieses Modul bietet eine High-Level-Schnittstelle für eine asynchrone Durchführung und parallele Verarbeitung von Prozessen. Es verwendet den **Pool-Executor**, um Aufgaben auf einem Pool von Prozessen oder Threads auszuführen. Das `concurrent.futures`-Modul ist eine einfachere Möglichkeit, asynchrone Aufgaben zu verarbeiten, und ist in vielen Fällen leichter zu handhaben als das Python `multiprocessing`-Modul.

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

Der Code nutzt das `concurrent.futures-Modul`, um Aufgaben parallel mit dem `ProcessPoolExecutor` abzuarbeiten. Dabei wird die Funktion `task(n)` für Zahlen von 1 bis 5 übergeben. Die `as_completed()`-Methode wartet auf den Abschluss der Aufgaben und gibt die **Ergebnisse in beliebiger Reihenfolge** aus.

### `joblib`

`joblib` ist eine externe Python-Bibliothek, die entwickelt wurde, um die Parallelverarbeitung in Python zu vereinfachen, zum Beispiel für wiederholbare Aufgaben wie das Ausführen von Funktionen mit unterschiedlichen Eingangsparametern oder das Arbeiten mit großen Datenmengen. Die Hauptfunktionen von `joblib` konzentrieren sich auf die Parallelisierung von Aufgaben, das **Zwischenspeichern (Caching) von Funktionsergebnissen** und die Optimierung von Speicher- und Rechenressourcen.

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

Der Ausdruck `Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))` initiiert die parallele Ausführung der Funktion `task()` für die Zahlen von 1 bis 10. `Parallel` wird mit `n_jobs=4` konfiguriert, was dazu führt, dass bis zu vier parallele Jobs verarbeitet werden können. Der Aufruf von `delayed(task)(i)` erstellt die parallel durchzuführende Aufgabe für jede Zahl i im Bereich von 1 bis 10. Dies bedeutet, dass die Funktion `task()` gleichzeitig für jede dieser Zahlen aufgerufen wird. Das Ergebnis für die Zahlen von 1 bis 10 wird in `results` gespeichert und ausgegeben.


This is a markdown version of: [https://www.ionos.at/digitalguide/websites/web-entwicklung/python-multiprocessing/](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-multiprocessing/) for AI/LLM consumption.