Hogyan végez profilálást és optimalizálást a Python teljesítménye érdekében?

Question

Accepted Answer

A Python optimalizálása **profilálással kezdődik, hogy megtalálja az igazi szűk keresztmetszetet** — soha ne találgasson. Python interpretált, dinamikus természete lassabbá teszi az fordított nyelvekhez képest, így az optimalizálás jobb algoritmusokra, C-alapú könyvtárakra, és a szűk utakban az interpreter terhelésének csökkentésére összpontosít.

## Először profil

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

A profilálás megmutatja, *hová* megy valójában az idő, így a kód azon 20%-át optimalizálja, amely számít — nem találgatásokat.

## A legnagyobb nyereség: jobb algoritmusok és adatstruktúrák

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

Az algoritmusos fejlesztések (helyes adatstruktúra, O(n²) minták elkerülése) általában felülmúlják a mikro-optimalizálásokat — a halmaz keresése versus lista vizsgálata nagyságrendileg gyorsabb lehet.

## Használjon C-alapú könyvtárakat a nagy numerikus munkához

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

Numerikus/adat munkafolyamatokhoz a **NumPy/pandas** hasonló könyvtárak a nagy hurkokat C-ben futtatják (GIL felszabadítva), messze jobb teljesítményt nyújtva a tiszta Python hurkokhoz képest.

## Egyéb optimalizálási technikák

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

## Cacheing példa

```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 optimalizáljon korán

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

## Miért fontos ez

A Python viszonylagos lassúsága értékessé teszi a teljesítménytudatosságot, de a hatékony optimalizálás **fegyelmezett**: először profil (cProfile/line_profiler) az igazi szűk keresztmetszet megtalálásához, majd alkalmazza a legmagasabb hatástényezőjű javítást — általában jobb algoritmus/adatstruktúra (O(n) → O(1) keresések), C-alapú könyvtárak (NumPy/pandas) numerikus munkához, cacheing ismételt számításokhoz, és beépített/generátorok hatékonysághoz.

E technikákat ismerni — és az optimalizálás előtti mérés elve ahelyett, hogy találgatnánk vagy korán mikro-optimalizálnánk — ez az, ami lehetővé teszi, hogy a Python-t elég gyorssá tegyük, ahol számít, miközben a kód világos marad máshol.