Bagaimana cara anda memprofile dan mengoptimalkan prestasi Python?

Question

Accepted Answer

Mengoptimalkan Python dimulai dengan **memprofil untuk menemukan botol leher yang sebenarnya** — jangan pernah menebak. Sifat Python yang ditafsirkan dan dinamis membuatnya lebih lambat daripada bahasa yang dikompilasi, jadi optimisasi berfokus pada algoritma yang lebih baik, memanfaatkan perpustakaan yang didukung C, dan mengurangi overhead penerjemah di jalur panas.

## Profil terlebih dahulu

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

Pemrofilan mengungkapkan *ke mana* waktu benar-benar pergi, sehingga Anda mengoptimalkan 20% kode yang penting — bukan tebakan acak.

## Kemenangan terbesar: algoritma dan struktur data yang lebih baik

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

Peningkatan algoritma (struktur data yang tepat, menghindari pola O(n²)) biasanya jauh melampaui optimisasi mikro — pencarian set vs pemindaian daftar dapat berkali-kali lipat lebih cepat.

## Gunakan perpustakaan yang didukung C untuk pekerjaan numerik berat

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

Untuk pekerjaan numerik/data, perpustakaan seperti **NumPy/pandas** menjalankan loop berat dalam C (melepaskan GIL), jauh mengungguli loop murni Python.

## Teknik optimisasi lainnya

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

## Contoh penyimpanan

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

## Jangan mengoptimalkan secara prematur

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

## Mengapa penting

Kelambatan relatif Python membuat kesadaran kinerja berharga, tetapi optimisasi efektif adalah **disiplin**: profil pertama (cProfile/line_profiler) untuk menemukan bottleneck sebenarnya, kemudian terapkan perbaikan leverage tertinggi — biasanya algoritma/struktur data yang lebih baik (O(n) → O(1) pencarian), perpustakaan yang didukung C (NumPy/pandas) untuk pekerjaan numerik, caching untuk komputasi berulang, dan built-in/generator untuk efisiensi.

Mengetahui teknik-teknik ini — dan prinsip mengukur sebelum mengoptimalkan daripada menebak atau mengoptimalkan secara prematur mikro — adalah yang memungkinkan Anda membuat Python cukup cepat di mana pun yang penting sambil menjaga kode tetap jelas di mana-mana.