Cum profilezi și optimizezi performanța Python?

Question

Accepted Answer

Optimizarea Python începe cu **profilarea pentru a găsi adevărata cenuşă** — niciodată ghicind. Natura interpretată și dinamică a Python face să fie mai lentă decât limbajele compilate, deci optimizarea se concentrează pe algoritmi mai buni, valorificarea bibliotecilor sprijinite de C și reducerea suprascărcării interpretorului pe căile fierbinți.

## Profilează mai întâi

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

Profilarea dezvăluie *unde* merge de fapt vremea, deci optimizezi cei 20% din cod care contează — nu ghiciri aleatorii.

## Cea mai mare victorie: algoritmi și structuri de date mai buni

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

Îmbunătățirile algoritmice (structura de date corectă, evitarea modelelor O(n²)) eclipsează de obicei micro-optimizările — o căutare în set vs o scanare în listă poate fi cu ordine de mărime mai rapidă.

## Utilizează biblioteci sprijinite de C pentru munca numerică grea

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

Pentru munca numerică/date, biblioteci cum ar fi **NumPy/pandas** rulează buclele grele în C (eliberând GIL), depășind cu mult buclele pure-Python.

## Alte tehnici de optimizare

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

## Exemplu de cache

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

## Nu optimiza în prealabil

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

## De ce conteaza

Lentoarea relativă a Python face ca conștientizarea performanței să fie valoroasă, dar optimizarea efectivă este **disciplinată**: profilează mai întâi (cProfile/line_profiler) pentru a găsi adevărata cenuşă, apoi aplică reparația cu cea mai mare pârghie — de obicei un algoritm/structură de date mai bună (căutări O(n) → O(1)), biblioteci sprijinite de C (NumPy/pandas) pentru munca numerică, cache pentru calcul repetat și built-ins/generatoare pentru eficiență.

Cunoașterea acestor tehnici — și principiul măsurării înainte de optimizare în loc să ghicești sau să optimizezi prematur la nivel micro — este ceea ce îți permite să faci Python suficient de rapid unde contează, menținând codul clar peste tot altundeva.