Profil ve optimizasyon

Önce ölç, sonra düzelt

Ilgaz Bank'ın gece raporu 40 dakika sürüyor ve ekip "Python yavaş" diyor. Çoğu zaman yavaş olan Python değil, bir listede milyon kez in aramak ya da döngüde string biriktirmektir. Optimizasyonun ilk kuralı: tahmin etme, ölç. İkinci kuralı: en çok zaman geçen yüzde 5'lik kodu düzelt, gerisine dokunma.

timeit: küçük parçayı ölç

timeit bir ifadeyi çok kez çalıştırıp toplam süreyi verir; çöp toplayıcıyı kapatır, en küçük gürültüyle ölçer. İki alternatifi karşılaştırmak için idealdir.

import timeit

musteriler = list(range(50_000))
kume = set(musteriler)
aranan = [49_999, 25_000, -1, 10]

t_liste = timeit.timeit(lambda: [x in musteriler for x in aranan], number=50)
t_kume = timeit.timeit(lambda: [x in kume for x in aranan], number=50)
print(f"liste in: {t_liste:.4f} s   set in: {t_kume:.6f} s")
print(f"set yaklaşık {t_liste / t_kume:.0f} kat hızlı")

cProfile: büyük programda nerede?

Bütün betikte hangi fonksiyonun süre yediğini cProfile gösterir. Bellek içinde çalıştırıp pstats ile en pahalı birkaç fonksiyonu sıralarsın. tottime fonksiyonun kendi süresi, cumtime çağırdıklarıyla birlikte toplam.

import cProfile, pstats, io

def musteri_bul(musteri_id, liste):
    return musteri_id in liste                  # O(n)

def rapor(n):
    liste = list(range(n))
    bulunan = 0
    for i in range(0, n, 7):
        if musteri_bul(i, liste):
            bulunan += 1
    return bulunan

pr = cProfile.Profile()
pr.enable()
rapor(20_000)
pr.disable()

cikti = io.StringIO()
pstats.Stats(pr, stream=cikti).sort_stats("cumulative").print_stats(4)
satirlar = [s for s in cikti.getvalue().splitlines() if "musteri_bul" in s or "rapor" in s]
print("\n".join(satirlar))

Çıktıda musteri_bul binlerce kez çağrılıyor ve toplam sürenin neredeyse tamamını alıyor. Düzeltme fonksiyonu hızlandırmak değil, veri yapısını değiştirmek: listeyi bir kez set'e çevir.

Big-O sezgisi

Big-O, girdi n büyüyünce sürenin nasıl büyüdüğünü söyler. Sabitleri değil eğilimi önemser; 10 bin satırda fark etmeyen şey 10 milyonda saatlere dönüşür.

import timeit

siparisler = [(i, i % 1000) for i in range(20_000)]          # (siparis, musteri_id)
musteriler = [(m, f"Müşteri{m}") for m in range(1000)]

def birlestir_yavas():                     # O(n·m)
    return [(s, ad) for s, m in siparisler for mid, ad in musteriler if mid == m]

def birlestir_hizli():                     # O(n+m)
    ad = dict(musteriler)
    return [(s, ad[m]) for s, m in siparisler]

assert birlestir_yavas()[:3] == birlestir_hizli()[:3]
print(f"yavaş: {timeit.timeit(birlestir_yavas, number=1):.3f} s")
print(f"hızlı: {timeit.timeit(birlestir_hizli, number=1):.4f} s")

Sık kazanımlar

String birleştirme

Döngüde s += parça her seferinde yeni string üretir. Parçaları listede biriktirip "".join(...) ya da f-string kullan.

Üreteçle bellek

[f(x) for x in range(10**7)] tüm listeyi belleğe koyar; (f(x) for x in ...) ya da yield tek seferde bir eleman üretir. sum, max, any gibi tüketiciler üreteçle (generator) çalışır. Büyük dosyayı satır satır okumak da aynı ilkedir.

lru_cache

Aynı girdiyle tekrar tekrar çağrılan saf (yan etkisiz) fonksiyonu functools.lru_cache ile ezberle. Özyinelemeli hesaplar ve pahalı sorgular için çarpıcıdır.

import timeit, sys
from functools import lru_cache

def birlestir_arti(n):
    s = ""
    for i in range(n):
        s += f"{i},"
    return s

def birlestir_join(n):
    return ",".join(str(i) for i in range(n)) + ","

assert birlestir_arti(100) == birlestir_join(100)
print(f"+=: {timeit.timeit(lambda: birlestir_arti(20_000), number=5):.3f} s  "
      f"join: {timeit.timeit(lambda: birlestir_join(20_000), number=5):.3f} s")

liste = [x * x for x in range(100_000)]
uretec = (x * x for x in range(100_000))
print("liste:", sys.getsizeof(liste), "bayt | üreteç:", sys.getsizeof(uretec), "bayt")

@lru_cache(maxsize=None)
def taksit_katsayi(ay: int) -> float:
    return 1.0 if ay == 0 else taksit_katsayi(ay - 1) * 1.02

t0 = timeit.default_timer()
print(round(taksit_katsayi(400), 4), f"{timeit.default_timer() - t0:.5f} s")
print(taksit_katsayi.cache_info())

numpy'a geçiş

Sayısal bir döngüyü ne kadar iyileştirsen de yorumlayıcı maliyeti kalır. Veri tek tip sayı ve işlem eleman eleman ise numpy'a geç: döngü C'de döner, bellek yan yana olur. Kural: "for ile milyon sayı" gördüğünde numpy/pandas düşün.

import timeit, numpy as np

tutarlar = [float(i % 500) for i in range(300_000)]
dizi = np.array(tutarlar)

def kdv_python():
    return sum(t * 1.2 for t in tutarlar if t > 100)

def kdv_numpy():
    return float((dizi[dizi > 100] * 1.2).sum())

assert abs(kdv_python() - kdv_numpy()) < 1e-3
print(f"python: {timeit.timeit(kdv_python, number=3):.3f} s  numpy: {timeit.timeit(kdv_numpy, number=3):.4f} s")

import time
from functools import wraps

def zamanla(fn):
    @wraps(fn)
    def sarmal(*args, **kwargs):
        t0, c0 = time.perf_counter(), time.process_time()
        try:
            return fn(*args, **kwargs)
        finally:
            duvar = time.perf_counter() - t0
            cpu = time.process_time() - c0
            print(f"{fn.__name__}: duvar={duvar:.3f}s cpu={cpu:.3f}s")
    return sarmal

@zamanla
def hesapla():
    return sum(i * i for i in range(300_000))

@zamanla
def bekle():
    time.sleep(0.2)          # ağ/disk beklemesinin taklidi

hesapla()
bekle()                      # duvar ~0.2 s, cpu ~0: kod bekliyor, hesaplamıyor

import timeit

veri = list(range(10_000))
sonuclar = timeit.repeat(lambda: sorted(veri, reverse=True), repeat=5, number=200)
print("ölçümler:", [round(s, 4) for s in sonuclar])
print(f"en iyi: {min(sonuclar) / 200 * 1e6:.1f} µs / çağrı")

# 1) cProfile'ı kod değiştirmeden çalıştır, kümülatif süreye göre sırala
python -m cProfile -s cumtime gece_raporu.py | head -25

# 2) Sonucu dosyaya kaydedip sonra incele
python -m cProfile -o profil.out gece_raporu.py
python -m pstats profil.out        # açılan kabukta: sort cumtime / stats 15

# 3) Satır satır: fonksiyonun üstüne @profile yaz, kernprof ile çalıştır
pip install line_profiler
kernprof -l -v gece_raporu.py

# 4) Çalışan sürece dışarıdan bak (sunucuyu durdurmadan)
pip install py-spy
py-spy top --pid 12345
py-spy record -o profil.svg -- python gece_raporu.py   # alev grafiği (flame graph)

import tracemalloc

def liste_ile(n):
    return sum([i * 2 for i in range(n)])

def uretec_ile(n):
    return sum(i * 2 for i in range(n))

for fn in (liste_ile, uretec_ile):
    tracemalloc.start()
    fn(200_000)
    simdi, tepe = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    print(f"{fn.__name__:11}: tepe {tepe / 1024:8.1f} KB")

import heapq, bisect
from collections import Counter

tutarlar = [120, 5400, 80, 990, 15000, 300, 7200]
print("en büyük 3:", heapq.nlargest(3, tutarlar))

# Kademeli komisyon: 0-999 %3, 1000-4999 %2, 5000+ %1
esikler = [1000, 5000]
oranlar = [0.03, 0.02, 0.01]
for t in (500, 1000, 7200):
    print(t, "->", oranlar[bisect.bisect_right(esikler, t)])

sehirler = ["İzmir", "Ankara", "İzmir", "Bursa", "İzmir", "Ankara"]
print(Counter(sehirler).most_common(2))