Come profili e ottimizzi le prestazioni di Python?

Question

Accepted Answer

L'ottimizzazione di Python inizia con **profilazione per trovare il vero collo di bottiglia** — non indovinare mai. La natura interpretata e dinamica di Python lo rende più lento dei linguaggi compilati, quindi l'ottimizzazione si concentra su algoritmi migliori, sfruttamento di librerie supportate da C, e riduzione dell'overhead dell'interprete nei percorsi critici.

## Profila prima

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

La profilazione rivela *dove* il tempo va effettivamente, così ottimizzi il 20% del codice che conta — non indovini casuali.

## La vittoria più grande: algoritmi e strutture dati migliori

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

I miglioramenti algoritmici (struttura dati corretta, evitare modelli O(n²)) di solito superano le micro-ottimizzazioni — una ricerca in set rispetto a una scansione di lista può essere ordini di grandezza più veloce.

## Usa librerie supportate da C per lavori numerici pesanti

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

Per il lavoro numerico/dati, librerie come **NumPy/pandas** eseguono cicli pesanti in C (rilasciando il GIL), superando di gran lunga le prestazioni dei cicli Python puri.

## Altre tecniche di ottimizzazione

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

## Esempio di caching

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

## Non ottimizzare prematuramente

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

## Perché è importante

La relativa lentezza di Python rende la consapevolezza delle prestazioni preziosa, ma l'ottimizzazione efficace è **disciplinata**: profila prima (cProfile/line_profiler) per trovare il vero collo di bottiglia, poi applica la correzione con la leva più alta — di solito un algoritmo/struttura dati migliore (ricerche O(n) → O(1)), librerie supportate da C (NumPy/pandas) per il lavoro numerico, caching per il calcolo ripetuto, e built-in/generatori per l'efficienza.

Conoscere queste tecniche — e il principio di misurare prima di ottimizzare piuttosto che indovinare o micro-ottimizzare prematuramente — è quello che ti permette di rendere Python abbastanza veloce dove conta mantenendo il codice chiaro ovunque.