Python bietet verschiedene Möglichkeiten, um Code parallel auszufühen. Hier sind ein paar Beispiele:
1. Multithreading:
Python hat ein eingebautes Modul namens “threading”, das genutzt werden kann, um Code auf mehreren Threads auszuführen. Beachten Sie jedoch, dass aufgrund der Global Interpreter Lock (GIL) in Python, Multithreading in Python nicht immer zu einer erhöhten Leistung führt, besonders bei rechenintensiven Aufgaben.
Beispiel:
```python
import threading
def job(num): print(“Thread”, num)
threads = []
for i in range(5): thread = threading.Thread(target=job, args=(i,)) threads.append(thread) thread.start()
for thread in threads:
thread.join()
```
2. Multiprocessing:
Das “multiprocessing” Modul in Python ermöglicht die Erstellung von Prozessen, die parallele Ausführung von Code ermöglichen. Dies kann die Leistung von rechenintensiven Aufgaben erheblich verbessern.
Beispiel:
```python
from multiprocessing import Process
def job(num): print(“Process”, num)
processes = []
for i in range(5): process = Process(target=job, args=(i,)) processes.append(process) process.start()
for process in processes:
process.join()
```
3. Concurrent.futures:
Das Modul “concurrent.futures” bietet eine hohe Abstraktionsebene für die Ausführung paralleler Aufgaben.
Beispiel:
```python
from concurrent.futures import ThreadPoolExecutor
def job(num): return num * 2
with ThreadPoolExecutor() as executor:
futures = [executor.submit(job, i) for i in range(5)]
results = [future.result() for future in futures]
print(results)
```
4. Verwendung von Frameworks wie Dask oder joblib, die eine einfache Schnittstelle für das parallele Ausführen von Python-Funktionen bieten.
Erinnern Sie sich jedoch daran, dass der parallele Code komplizierter ist und schwerer zu debuggen sein kann und dass nicht alle Probleme durch Parallelisierung gelöst werden können. In einigen Fällen kann es sogar die Performance verschlechtern. Es ist also wichtig, die Notwendigkeit der Parallelisierung sorgfältig abzuwägen.
