Wie profilierst und optimierst du die Python-Leistung?

Question

Accepted Answer

Die Optimierung von Python beginnt mit **Profiling zur Identifizierung des echten Engpasses** — niemals raten. Pythons interpretierte, dynamische Natur macht es langsamer als kompilierte Sprachen, daher konzentriert sich die Optimierung auf bessere Algorithmen, Nutzung von C-gestützten Bibliotheken und Reduzierung des Interpreter-Overheads in kritischen Pfaden.

## Profiling an erster Stelle

```python
import cProfile
cProfile.run("my_function()")   # shows time spent per function call

# line-level profiling (third-party)
# pip install line_profiler → @profile decorator → kernprof -l -v script.py
```

```bash
python -m cProfile -s cumtime script.py   # sort by cumulative time → find hotspots
```

Profiling zeigt *wo* die Zeit tatsächlich verbracht wird, sodass du die 20% des Codes optimierst, die zählen — nicht zufällige Vermutungen.

## Der größte Gewinn: bessere Algorithmen und Datenstrukturen

```python
# ❌ O(n) membership test in a list — slow for large data
if item in my_list: ...          # scans every element

# ✅ O(1) membership test in a set/dict
if item in my_set: ...           # hash lookup — dramatically faster at scale
```

Algorithmische Verbesserungen (richtige Datenstruktur, Vermeidung von O(n²)-Mustern) überwiegen normalerweise Mikro-Optimierungen — eine Set-Suche gegenüber einem Listenscann kann um Größenordnungen schneller sein.

## Verwende C-gestützte Bibliotheken für schwere numerische Arbeiten

```python
# ❌ pure-Python loop over millions of numbers — slow (interpreter overhead per element)
result = [x * 2 for x in big_list]

# ✅ NumPy does it in optimized C, vectorized — far faster
import numpy as np
result = np.array(big_list) * 2
```

Für numerische/Daten-Arbeiten führen Bibliotheken wie **NumPy/pandas** die schweren Schleifen in C aus (geben die GIL frei), was pure-Python-Schleifen bei weitem übertrifft.

## Weitere Optimierungstechniken

```text
✓ Caching/memoization: @functools.lru_cache for repeated expensive calls
✓ Use built-ins (sum, map, sorted) — implemented in C, faster than manual loops
✓ Use generators for large data (avoid building huge lists in memory)
✓ Use local variables in hot loops (local lookup is faster than global/attribute)
✓ Use __slots__ to reduce per-object memory for many instances
✓ For CPU parallelism: multiprocessing (bypass the GIL)
✓ Last resort: rewrite hotspots in C / Cython / Rust (PyO3), or try PyPy
```

## Caching-Beispiel

```python
from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)   # memoized → exponential becomes linear
```

## Optimiere nicht zu früh

```text
"Premature optimization is the root of all evil." Write clear code first,
profile to find real bottlenecks, then optimize those specifically.
```

## Warum es wichtig ist

Pythons relative Langsamkeit macht Leistungsbewusstsein wertvoll, aber effektive Optimierung ist **diszipliniert**: Profilerstellung zuerst (cProfile/line_profiler) um den echten Engpass zu finden, dann die höchsten Verbesserungen anwenden — normalerweise ein besserer Algorithmus/Datenstruktur (O(n) → O(1)-Lookups), C-gestützte Bibliotheken (NumPy/pandas) für numerische Arbeiten, Caching für wiederholte Berechnungen und Built-ins/Generatoren für Effizienz.

Das Verständnis dieser Techniken — und das Prinzip, vor der Optimierung zu messen statt zu raten oder Mikro-Optimierungen zu früh durchzuführen — ist das, was dir ermöglicht, Python dort schnell genug zu machen, wo es zählt, während du den Code überall sonst klar hältst.