Hoe profileert en optimaliseert u Python-prestatie?

Question

Accepted Answer

Het optimaliseren van Python begint met **profilering om de echte bottleneck te vinden** — gok nooit. De geïnterpreteerde, dynamische aard van Python maakt het langzamer dan gecompileerde talen, dus optimalisatie richt zich op betere algoritmen, gebruikmaken van C-ondersteunde bibliotheken en het verminderen van interpreter-overhead in hot paths.

## Profiel eerst

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

Profilering onthult *waar* tijd werkelijk wordt besteed, dus u optimaliseert de 20% van de code die ertoe doet — niet willekeurige gokken.

## De grootste overwinning: betere algoritmen en datastructuren

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

Algoritmische verbeteringen (juiste datastructuur, vermijding van O(n²)-patronen) overtreffen meestal micro-optimalisaties ver — een set lookup versus een list scan kan ordes van grootte sneller zijn.

## Gebruik C-ondersteunde bibliotheken voor zwaar numeriek werk

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

Voor numeriek/data-werk voeren bibliotheken zoals **NumPy/pandas** zware lussen uit in C (waarbij de GIL wordt vrijgegeven), wat veel sneller is dan zuivere Python-lussen.

## Overige optimalisatietechnieken

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

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

## Optimaliseer niet voortijdig

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

## Waarom het belangrijk is

De relatieve traagheid van Python maakt prestatiebewustzijn waardevol, maar effectieve optimalisatie is **gedisciplineerd**: eerst profileren (cProfile/line_profiler) om de echte bottleneck te vinden, vervolgens de highest-leverage fix toepassen — meestal een beter algoritme/datastructuur (O(n) → O(1) lookups), C-ondersteunde bibliotheken (NumPy/pandas) voor numeriek werk, caching voor herhaalde berekeningen en built-ins/generators voor efficiëntie.

Deze technieken kennen — en het principe van meten voordat je optimaliseert in plaats van gokken of voortijdig micro-optimalisatie toe te passen — is wat je in staat stelt Python snel genoeg te maken waar het ertoe doet, terwijl je de code overal duidelijk houdt.