Kako profiliraš in optimiziraš zmogljivost Python-a?

Question

Accepted Answer

Optimizacija Python-a se začne s **profiliranjem za iskanje pravega ozkega grla** — nikoli ne ugibaj. Python je interpretiran, dinamičen jezik, kar ga počasnejši od kompajliranih jezikov, zato se optimizacija osredotoča na boljše algoritme, izkoriščanje C-podprtih knjižnic in zmanjšanje režije interpreterja v kritičnih delih kode.

## Najprej profilira

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

Profiliranje razkrije *kje* se čas dejansko porabi, zato optimiziraš tiste 20 % kode, ki je pomembna — ne naključne ugibe.

## Največja prednost: boljši algoritmi in podatkovne strukture

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

Algoritmična izboljšanja (prava podatkovna struktura, izogibanje O(n²) vzorcem) običajno daleč presežejo mikro-optimizacije — iskanje v množici (set) v primerjavi s pregledovanjem seznama je lahko za velikostne razrede hitrejše.

## Uporabi C-podprte knjižnice za težko numerično delo

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

Za numerično/podatkovko delo knjižnice kot **NumPy/pandas** izvajajo težke zanke v C-u (sprostijo GIL), kar je bistveno boljše od čistih Python zanulk.

## Druge tehnike optimizacije

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

## Primer predpomnenja

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

## Ne optimiziraj preuranо

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

## Zakaj je to pomembno

Relativna počasnost Python-a naredi razumevanje zmogljivosti dragoceno, vendar je učinkovita optimizacija **disciplinirana**: najprej profilira (cProfile/line_profiler) za odkritje pravega ozkega grla, nato pa uporabi rešitev z največjo učinkovitostjo — običajno boljši algoritem/podatkovna struktura (O(n) → O(1) iskanja), C-podprte knjižnice (NumPy/pandas) za numerično delo, predpomnenje za ponavljajočo se izračunavanje in vgrajene funkcije/generatorje za učinkovitost.

Znanje teh tehnik — in načela merjenja pred optimizacijo namesto ugibanja ali preuranjе mikro-optimizacije — je ključno za to, da narediš Python dovolj hiter tam, kjer je važno, hkrati pa ohraniš kodo jasno povsod drugod.