Tezlik: o'lchash, profiling, optimizatsiya

import time, timeit

def sekin_qoshish(n):
    s = ""
    for i in range(n):
        s += str(i)
    return s

def tez_qoshish(n):
    return "".join(str(i) for i in range(n))

N = 20_000
t0 = time.perf_counter()
sekin_qoshish(N)
bitta_olchov = (time.perf_counter() - t0) * 1000
print(f"bitta o'lchov: {bitta_olchov:.1f} ms  <- shovqinli, ishonchsiz")

sekin = timeit.timeit(lambda: sekin_qoshish(N), number=20) / 20 * 1000
tez = timeit.timeit(lambda: tez_qoshish(N), number=20) / 20 * 1000
print(f"timeit (20 marta) — sekin: {sekin:.1f} ms | tez: {tez:.1f} ms | {sekin / tez:.1f}x farq")

"""Ataylab sekin qilingan qayta ishlash — profiling uchun."""
from hisobot.oqish import oqi, tozala
from hisobot.hisob import guruh_ortachasi


def sekin_takrorlash(qatorlar, marta=40):
    """Bir ishni ko'p marta bajaradi — profil uchun sezilarli bo'lsin."""
    natija = None
    for _ in range(marta):
        natija = tozala(qatorlar)
    return natija


def ishla(yol="sinov_malumot.csv"):
    qatorlar = oqi(yol)
    katta = qatorlar * 200                 # sun'iy ravishda kattalashtiramiz
    n = sekin_takrorlash(katta)
    return guruh_ortachasi(n.talabalar)

.venv/bin/python3 -m cProfile -s cumtime -m profil_sinov 2>/dev/null | head -25 || \
.venv/bin/python3 -c "
import cProfile, pstats, io, sys
sys.path.insert(0, '.')
from profil_sinov import ishla
pr = cProfile.Profile()
pr.enable(); ishla(); pr.disable()
s = io.StringIO()
pstats.Stats(pr, stream=s).sort_stats('cumulative').print_stats(12)
print(s.getvalue())
"

import cProfile, io, pstats, sys, time
sys.path.insert(0, str(ISH))
sys.path.insert(0, str(ISH / "src"))
from hisobot.oqish import oqi, tozala

qatorlar = oqi(ISH / "sinov_malumot.csv") * 400
print("qatorlar soni:", len(qatorlar))

pr = cProfile.Profile()
pr.enable()
tozala(qatorlar)
pr.disable()
s = io.StringIO()
pstats.Stats(pr, stream=s).sort_stats("tottime").print_stats(8)
chiqish = s.getvalue()
print("\n".join(chiqish.splitlines()[4:16]))

import time
from hisobot.tekshiruv import bahoni_tekshir, sanani_tekshir

def olch(f, *a, n=50_000):
    f(*a)
    t0 = time.perf_counter()
    for _ in range(n):
        f(*a)
    return (time.perf_counter() - t0) / n * 1e6

import pandas as pd
show(pd.DataFrame([
    {"funksiya": "bahoni_tekshir('85')", "mks": round(olch(bahoni_tekshir, "85"), 3)},
    {"funksiya": "sanani_tekshir('2026-09-01')", "mks": round(olch(sanani_tekshir, "2026-09-01"), 3)},
    {"funksiya": "int('85')", "mks": round(olch(int, "85"), 3)},
]))

import time

ROYXAT = list(range(50_000))
TOPLAM = set(ROYXAT)
LUGAT = {x: x for x in ROYXAT}

def olch(f, n=2000):
    f()
    t0 = time.perf_counter()
    for _ in range(n):
        f()
    return (time.perf_counter() - t0) / n * 1e6

nishon = 49_999
import pandas as pd
show(pd.DataFrame([
    {"tuzilma": "list", "amal": "x in ro'yxat", "mks": round(olch(lambda: nishon in ROYXAT), 2)},
    {"tuzilma": "set", "amal": "x in to'plam", "mks": round(olch(lambda: nishon in TOPLAM), 2)},
    {"tuzilma": "dict", "amal": "x in lug'at", "mks": round(olch(lambda: nishon in LUGAT), 2)},
]))

import time
from datetime import date

SANALAR = [f"2026-{(i % 12) + 1:02d}-{(i % 28) + 1:02d}" for i in range(20_000)]

def har_safar_tahlil():
    return sum(date.fromisoformat(s).month for s in SANALAR)

KESH = {}
def kesh_bilan():
    jami = 0
    for s in SANALAR:
        if s not in KESH:
            KESH[s] = date.fromisoformat(s)
        jami += KESH[s].month
    return jami

t0 = time.perf_counter(); har_safar_tahlil(); a = (time.perf_counter() - t0) * 1000
kesh_bilan()                                   # keshni to'ldiramiz
t0 = time.perf_counter(); kesh_bilan(); b = (time.perf_counter() - t0) * 1000
print(f"har safar tahlil : {a:.1f} ms")
print(f"kesh bilan       : {b:.1f} ms  ({a / b:.1f}x tezroq)")
print(f"noyob sanalar    : {len(KESH)} ta (jami {len(SANALAR)})")

import time
from functools import lru_cache
from datetime import date

@lru_cache(maxsize=1024)
def tahlil(s: str) -> date:
    return date.fromisoformat(s)

SANALAR = [f"2026-{(i % 12) + 1:02d}-{(i % 28) + 1:02d}" for i in range(20_000)]
tahlil.cache_clear()
t0 = time.perf_counter()
sum(tahlil(s).month for s in SANALAR)
ms = (time.perf_counter() - t0) * 1000
print(f"lru_cache bilan: {ms:.1f} ms | statistika: {tahlil.cache_info()}")

import time

MALUMOT = [{"baho": i % 101, "guruh": "ABC"[i % 3]} for i in range(200_000)]

def sekin():
    natija = []
    for q in MALUMOT:
        if q["baho"] >= 60:
            natija.append(q["baho"] * 1.0)
    return sum(natija) / len(natija)

def tezroq():
    baholar = [q["baho"] for q in MALUMOT if q["baho"] >= 60]
    return sum(baholar) / len(baholar)

def eng_tez():
    jami = soni = 0
    for q in MALUMOT:
        b = q["baho"]
        if b >= 60:
            jami += b
            soni += 1
    return jami / soni

import pandas as pd
qatorlar = []
for nom, f in [("append bilan sikl", sekin), ("ro'yxat ifodasi", tezroq), ("yig'indi sikl", eng_tez)]:
    f()
    t0 = time.perf_counter()
    for _ in range(5):
        natija = f()
    qatorlar.append({"usul": nom, "ms": round((time.perf_counter() - t0) / 5 * 1000, 1),
                     "natija": round(natija, 4)})
show(pd.DataFrame(qatorlar))

import sys, tracemalloc

def royxat_bilan(n):
    return [i * i for i in range(n)]

def generator_bilan(n):
    return (i * i for i in range(n))

N = 500_000
tracemalloc.start()
r = royxat_bilan(N)
royxat_xotira = tracemalloc.get_traced_memory()[1]
tracemalloc.stop()
del r

tracemalloc.start()
g = generator_bilan(N)
jami = sum(g)
gen_xotira = tracemalloc.get_traced_memory()[1]
tracemalloc.stop()

print(f"ro'yxat  : {royxat_xotira / 1024 / 1024:.1f} MB")
print(f"generator: {gen_xotira / 1024:.1f} KB")
print(f"farq     : {royxat_xotira / max(gen_xotira, 1):.0f}x")

import sys
sys.path.insert(0, str(ISH / "src"))
import csv, tracemalloc
from pathlib import Path

yol = ISH / "katta.csv"
with yol.open("w", encoding="utf-8", newline="") as f:
    w = csv.writer(f)
    w.writerow(["ism", "guruh", "baho", "sana"])
    for i in range(200_000):
        w.writerow([f"T{i}", "ABC"[i % 3], 50 + i % 51, "2026-09-01"])
print("fayl:", yol.stat().st_size // 1024 // 1024, "MB")

def hammasi_royxatga(p):
    with open(p, encoding="utf-8") as f:
        qatorlar = list(csv.DictReader(f))
    return sum(int(q["baho"]) for q in qatorlar) / len(qatorlar)

def oqim_bilan(p):
    jami = soni = 0
    with open(p, encoding="utf-8") as f:
        for q in csv.DictReader(f):
            jami += int(q["baho"]); soni += 1
    return jami / soni

import pandas as pd
qatorlar = []
for nom, f in [("hammasini ro'yxatga", hammasi_royxatga), ("qator-qator (oqim)", oqim_bilan)]:
    tracemalloc.start()
    natija = f(yol)
    cho_qqi = tracemalloc.get_traced_memory()[1]
    tracemalloc.stop()
    qatorlar.append({"usul": nom, "xotira cho'qqisi, MB": round(cho_qqi / 1024 / 1024, 1),
                     "natija": round(natija, 3)})
show(pd.DataFrame(qatorlar))
yol.unlink()

import pandas as pd
show(pd.DataFrame([
    {"holat": "Kod tushunarsiz bo'lib ketdi", "baho": "Yomon — 5% tezlanish uchun arzimaydi"},
    {"holat": "Testlar buzildi", "baho": "Yomon — to'g'rilik tezlikdan muhim"},
    {"holat": "Bo'g'in boshqa joyda edi", "baho": "Behuda mehnat — avval profil qiling"},
    {"holat": "10x tezlanish, kod o'sha", "baho": "Yaxshi — odatda tuzilma almashtirishdan"},
    {"holat": "Foydalanuvchi sezmaydi", "baho": "Bekor — 80 ms yoki 40 ms, farqi yo'q"},
]))