10.13-dars: functools: cache, partial, reduce

class NarxXizmati:
    def __init__(self, sorov):
        self.sorov = sorov                  # HTTP so'rov: sarlavhalar, tana, fayllar

    @lru_cache(maxsize=None)
    def chegirmalar(self, mijoz_id):
        return list(bazadan_ol(mijoz_id))

@lru_cache(maxsize=128, typed=False)
def f(x): ...

f.cache_info()          # CacheInfo(hits, misses, maxsize, currsize)
f.cache_clear()         # hammasini o'chirish
f.cache_parameters()    # {'maxsize': 128, 'typed': False}
f.__wrapped__           # asl funksiya — keshsiz chaqirish

kalit = pozitsion argumentlar + (belgi) + nomli argumentlar (berilgan tartibda)

class Hisobot:
    @lru_cache(maxsize=None)
    def hisobla(self, oy): ...

p = partial(f, 1, b=2)
p.func, p.args, p.keywords       # f, (1,), {'b': 2}
p(3, c=4)                        # f(1, 3, b=2, c=4)

from functools import partial, Placeholder as _

ikkiga_bol = partial(operator.truediv, _, 2)     # x / 2
ikkiga_bol(10)                                    # 5.0
partial(f, 1, _)                                  # ❌ TypeError: trailing Placeholders are not allowed

class Hujjat:
    saqla = partial(yoz, "json")

Hujjat().saqla("a.json")         # 3.14: yoz("json", <Hujjat>, "a.json")

reduce(f, [a, b, c, d], boshlangich)   =   f(f(f(f(boshlangich, a), b), c), d)

@cache                              # = lru_cache(maxsize=None)
@lru_cache(maxsize=256, typed=False)
f.cache_info() / f.cache_clear() / f.cache_parameters() / f.__wrapped__

Kalit = chaqiruv shakli: f(1) ≠ f(x=1) ≠ f(1, 0)
Keshlanmaydi: istisnolar
Umumiy: qaytarilgan o'zgaruvchan obyekt
Metodda: self kalitda → nusxalar tirik, teng nusxalar natijani bo'lishadi
Iplar: tuzilma xavfsiz, hisob takrorlanishi mumkin
Jarayonlar: har birining o'z keshi
TTL: vaqt chelagi argument sifatida

p = partial(f, 1, b=2)       # p.func, p.args, p.keywords
p(3, b=9)                    # nomli qayta yoziladi
partial(f, Placeholder, 2)   # 3.14: o'rtadagi joy
staticmethod(partial(...))   # 3.14: klassda self bog'lanmasin
partialmethod(f, ...)        # metod uchun

reduce(f, seq)                    # bo'sh bo'lsa TypeError
reduce(f, seq, neytral)           # yoki initial=neytral (3.14)
accumulate(seq, f, initial=...)   # oraliq natijalar
# bo'laklab/parallel — faqat assotsiativ amal + neytral element

"""Kalit shakli, typed, LRU o'chirish tartibi, istisnolar, o'zgaruvchan natija va iplar."""

import threading
from functools import cache, lru_cache

print("=== 1. Kalit — chaqiruv shakli ===")
hisoblangan = []


@lru_cache(maxsize=None)
def narx(mahsulot, soni=1):
    hisoblangan.append((mahsulot, soni))
    return 12_000 * soni


chaqiruvlar = [
    ("narx('olma')", lambda: narx("olma")),
    ("narx(mahsulot='olma')", lambda: narx(mahsulot="olma")),
    ("narx('olma', 1)", lambda: narx("olma", 1)),
    ("narx('olma', soni=1)", lambda: narx("olma", soni=1)),
    ("narx(soni=1, mahsulot='olma')", lambda: narx(soni=1, mahsulot="olma")),
    ("narx('olma')  # takror", lambda: narx("olma")),
]
for tavsif, chaqir in chaqiruvlar:
    oldin = narx.cache_info().misses
    chaqir()
    print(f"  {tavsif:32} {'hisoblandi' if narx.cache_info().misses > oldin else 'keshdan'}")
print(f"  {narx.cache_info()}  — bir xil natija uchun 5 ta yozuv")

print("\n=== 2. Teng qiymatlar, typed va tez yo'l ===")


@lru_cache(maxsize=None)
def ikki(x, y):
    return x + y


@lru_cache(maxsize=None)
def bitta(x):
    return x


@lru_cache(maxsize=None, typed=True)
def ikki_typed(x, y):
    return x + y


for f, argumentlar in [(ikki, [(1, 2), (1.0, 2.0), (True, 2)]),
                       (ikki_typed, [(1, 2), (1.0, 2.0), (True, 2)]),
                       (bitta, [(1,), (1.0,), (1,)])]:
    for a in argumentlar:
        f(*a)
    ci = f.cache_info()
    print(f"  {f.__name__:10} {str(argumentlar):28} hits={ci.hits}, yozuvlar={ci.currsize}")

print("\n=== 3. LRU o'chirish tartibi (maxsize=2) ===")
iz = []


@lru_cache(maxsize=2)
def kv(x):
    iz.append(x)
    return x * x


for x in [1, 2, 1, 3, 2, 1]:
    oldin = len(iz)
    kv(x)
    holat = "hisoblandi" if len(iz) > oldin else "keshdan"
    print(f"  kv({x}) {holat}")
print(f"  {kv.cache_info()}, {kv.cache_parameters()}")

print("\n=== 4. ⚠️ Istisnolar keshlanmaydi ===")
urinishlar = {"n": 0}


@cache
def kurs_ol(valyuta):
    urinishlar["n"] += 1
    raise ConnectionError(f"{valyuta}: server javob bermadi")


for _ in range(3):
    try:
        kurs_ol("USD")
    except ConnectionError:
        pass
print(f"  3 chaqiruv → funksiya {urinishlar['n']} marta ishladi, {kurs_ol.cache_info()}")

print("\n=== 5. ⚠️ O'zgaruvchan natija umumiy ===")


@cache
def ruxsatlar(rol):
    return ["o'qish"] if rol == "mehmon" else ["o'qish", "yozish"]


@cache
def ruxsatlar_xavfsiz(rol):
    return ("o'qish",) if rol == "mehmon" else ("o'qish", "yozish")


r = ruxsatlar("mehmon")
r.append("o'chirish")                            # bitta foydalanuvchi uchun "vaqtincha"
print(f"  keyingi mehmon oladi: {ruxsatlar('mehmon')}")
try:
    ruxsatlar_xavfsiz("mehmon").append("o'chirish")
except AttributeError as e:
    print(f"  tuple qaytarilsa: AttributeError — {e}")

print("\n=== 6. ⚠️ Iplar: bir xil kalit ikki marta hisoblanadi ===")
toliq = threading.Barrier(2)
hisoblaganlar = []


@cache
def ogir_hisobot(oy):
    hisoblaganlar.append(threading.current_thread().name)
    toliq.wait()                                 # ikkala ip ham hisob ichida uchrashadi
    return f"{oy}-oy"


iplar = [threading.Thread(target=ogir_hisobot, args=(9,), name=f"ip-{i}") for i in range(2)]
for t in iplar:
    t.start()
for t in iplar:
    t.join()
print(f"  hisoblagan iplar soni: {len(hisoblaganlar)}, {ogir_hisobot.cache_info()}")

=== 1. Kalit — chaqiruv shakli ===
  narx('olma')                     hisoblandi
  narx(mahsulot='olma')            hisoblandi
  narx('olma', 1)                  hisoblandi
  narx('olma', soni=1)             hisoblandi
  narx(soni=1, mahsulot='olma')    hisoblandi
  narx('olma')  # takror           keshdan
  CacheInfo(hits=1, misses=5, maxsize=None, currsize=5)  — bir xil natija uchun 5 ta yozuv

=== 2. Teng qiymatlar, typed va tez yo'l ===
  ikki       [(1, 2), (1.0, 2.0), (True, 2)] hits=2, yozuvlar=1
  ikki_typed [(1, 2), (1.0, 2.0), (True, 2)] hits=0, yozuvlar=3
  bitta      [(1,), (1.0,), (1,)]         hits=1, yozuvlar=2

=== 3. LRU o'chirish tartibi (maxsize=2) ===
  kv(1) hisoblandi
  kv(2) hisoblandi
  kv(1) keshdan
  kv(3) hisoblandi
  kv(2) hisoblandi
  kv(1) hisoblandi
  CacheInfo(hits=1, misses=5, maxsize=2, currsize=2), {'maxsize': 2, 'typed': False}

=== 4. ⚠️ Istisnolar keshlanmaydi ===
  3 chaqiruv → funksiya 3 marta ishladi, CacheInfo(hits=0, misses=3, maxsize=None, currsize=0)

=== 5. ⚠️ O'zgaruvchan natija umumiy ===
  keyingi mehmon oladi: ["o'qish", "o'chirish"]
  tuple qaytarilsa: AttributeError — 'tuple' object has no attribute 'append'

=== 6. ⚠️ Iplar: bir xil kalit ikki marta hisoblanadi ===
  hisoblagan iplar soni: 2, CacheInfo(hits=0, misses=2, maxsize=None, currsize=1)

"""lru_cache metodda: nusxalar tirik qoladi, teng nusxalar natijani bo'lishadi; to'rt yechim."""

import gc
import weakref
from dataclasses import dataclass, field
from functools import cache, cached_property, lru_cache


class KattaSorov:
    def __init__(self):
        self.tana = bytearray(1_000_000)


print("=== 1. ⚠️ Xotira sizishi ===")


class NarxXizmati:
    def __init__(self, sorov):
        self.sorov = sorov

    @lru_cache(maxsize=None)
    def chegirma(self, mijoz_id):
        return mijoz_id % 7


havolalar = []
for i in range(5):
    xizmat = NarxXizmati(KattaSorov())
    xizmat.chegirma(i)
    havolalar.append(weakref.ref(xizmat))
    del xizmat
gc.collect()
print(f"  5 so'rov tugadi → tirik xizmatlar: {sum(h() is not None for h in havolalar)}, "
      f"{NarxXizmati.chegirma.cache_info()}")
NarxXizmati.chegirma.cache_clear()
gc.collect()
print(f"  cache_clear() dan keyin tirik: {sum(h() is not None for h in havolalar)}  ⚠️ hamma nusxalar uchun bitta kesh")

print("\n=== 2. ⚠️ Teng nusxalar natijani bo'lishadi ===")


@dataclass(frozen=True)
class Hisobot:
    oy: int
    til: str = field(compare=False)              # taqqoslashda hisobga olinmaydi

    @lru_cache(maxsize=None)
    def sarlavha(self):
        return {"uz": f"{self.oy}-oy hisoboti", "en": f"Report for month {self.oy}"}[self.til]


uz, en = Hisobot(9, "uz"), Hisobot(9, "en")
print(f"  uz == en: {uz == en}, hash teng: {hash(uz) == hash(en)}")
print(f"  uz.sarlavha(): {uz.sarlavha()!r}")
print(f"  en.sarlavha(): {en.sarlavha()!r}   ⚠️ inglizcha kutilgan edi")

print("\n=== 3. Yechimlar ===")


class A_CachedProperty:
    def __init__(self, sorov, mijoz_id):
        self.sorov, self.mijoz_id = sorov, mijoz_id

    @cached_property
    def chegirma(self):
        return self.mijoz_id % 7


class B_NusxaKeshi:
    def __init__(self, sorov):
        self.sorov = sorov
        self.chegirma = lru_cache(maxsize=64)(self._chegirma)

    def _chegirma(self, mijoz_id):
        return mijoz_id % 7


@cache
def _chegirma_hisobla(mijoz_id):
    return mijoz_id % 7


class C_ModulFunksiyasi:
    def __init__(self, sorov):
        self.sorov = sorov

    def chegirma(self, mijoz_id):
        return _chegirma_hisobla(mijoz_id)


class D_ZaifKesh:
    _kesh = weakref.WeakKeyDictionary()

    def __init__(self, sorov):
        self.sorov = sorov

    def chegirma(self, mijoz_id):
        nusxa_keshi = D_ZaifKesh._kesh.setdefault(self, {})
        if mijoz_id not in nusxa_keshi:
            nusxa_keshi[mijoz_id] = mijoz_id % 7
        return nusxa_keshi[mijoz_id]


for nom, yarat, chaqir in [
    ("cached_property", lambda i: A_CachedProperty(KattaSorov(), i), lambda x, i: x.chegirma),
    ("nusxa keshi", lambda i: B_NusxaKeshi(KattaSorov()), lambda x, i: x.chegirma(i)),
    ("modul funksiyasi", lambda i: C_ModulFunksiyasi(KattaSorov()), lambda x, i: x.chegirma(i)),
    ("WeakKeyDictionary", lambda i: D_ZaifKesh(KattaSorov()), lambda x, i: x.chegirma(i)),
]:
    havolalar = []
    for i in range(5):
        x = yarat(i)
        chaqir(x, i)
        chaqir(x, i)
        havolalar.append(weakref.ref(x))
        del x
    darhol = sum(h() is not None for h in havolalar)
    gc.collect()
    keyin = sum(h() is not None for h in havolalar)
    print(f"  {nom:18} tirik: del dan keyin darhol {darhol}, gc.collect() dan keyin {keyin}")
print("  (nusxa keshi: self → lru_cache o'rovchisi → bog'langan metod → self — sikl, faqat gc tozalaydi)")

=== 1. ⚠️ Xotira sizishi ===
  5 so'rov tugadi → tirik xizmatlar: 5, CacheInfo(hits=0, misses=5, maxsize=None, currsize=5)
  cache_clear() dan keyin tirik: 0  ⚠️ hamma nusxalar uchun bitta kesh

=== 2. ⚠️ Teng nusxalar natijani bo'lishadi ===
  uz == en: True, hash teng: True
  uz.sarlavha(): '9-oy hisoboti'
  en.sarlavha(): '9-oy hisoboti'   ⚠️ inglizcha kutilgan edi

=== 3. Yechimlar ===
  cached_property    tirik: del dan keyin darhol 0, gc.collect() dan keyin 0
  nusxa keshi        tirik: del dan keyin darhol 5, gc.collect() dan keyin 0
  modul funksiyasi   tirik: del dan keyin darhol 0, gc.collect() dan keyin 0
  WeakKeyDictionary  tirik: del dan keyin darhol 0, gc.collect() dan keyin 0
  (nusxa keshi: self → lru_cache o'rovchisi → bog'langan metod → self — sikl, faqat gc tozalaydi)

"""Tekislash, qayta yozish, Placeholder, imzo, pickle, 3.14 deskriptor xatti-harakati, partial va lambda."""

import inspect
import operator
import pickle
from functools import Placeholder, partial, partialmethod


def xabar(daraja, modul, matn, *, vaqt="12:00", belgi="•"):
    return f"{belgi} [{vaqt}] {daraja} {modul}: {matn}"


print("=== 1. Tekislash va argumentlar tartibi ===")
xato = partial(xabar, "XATO")
xato_db = partial(xato, "db", belgi="✗")
print(f"  func: {xato_db.func.__name__}, args: {xato_db.args}, keywords: {xato_db.keywords}")
print(f"  {xato_db('ulanish uzildi')}")
print(f"  nomli qayta yozildi: {xato_db('ulanish uzildi', belgi='!', vaqt='09:30')}")
try:
    xato_db("db2", "matn")
except TypeError as e:
    print(f"  pozitsionni qayta yozib bo'lmaydi: TypeError: {e}")

print("\n=== 2. Imzo ===")
print(f"  xabar:   {inspect.signature(xabar)}")
print(f"  xato_db: {inspect.signature(xato_db)}")

print("\n=== 3. Placeholder 3.14-bob ===")
ikkiga_bol = partial(operator.truediv, Placeholder, 2)
kvadrat = partial(pow, Placeholder, 2)
auth_xabar = partial(xabar, Placeholder, "auth")
print(f"  ikkiga_bol(9) = {ikkiga_bol(9)}, kvadrat(12) = {kvadrat(12)}")
print(f"  {auth_xabar('OGOHLANTIRISH', 'parol noto' + chr(39) + 'g' + chr(39) + 'ri')}")
print(f"  imzo: {inspect.signature(auth_xabar)}")
try:
    partial(xabar, "INFO", Placeholder)
except TypeError as e:
    print(f"  oxirida Placeholder: TypeError: {e}")

print("\n=== 4. pickle: partial va lambda ===")
for nom, obyekt in [("partial(operator.mul, 3)", partial(operator.mul, 3)),
                    ("lambda x: 3 * x", lambda x: 3 * x)]:
    try:
        print(f"  {nom}: ✅ {pickle.loads(pickle.dumps(obyekt))(5)}")
    except (pickle.PicklingError, AttributeError) as e:
        print(f"  {nom}: ❌ {type(e).__name__}")

print("\n=== 5. ⚠️ 3.14: partial klass atributi sifatida self ni bog'laydi ===")


def yoz(format_, obyekt, yol):
    return f"{type(obyekt).__name__} → {yol} ({format_})"


class Hujjat:
    saqla = partial(yoz, "json")
    saqla_statik = staticmethod(partial(yoz, "json"))

    def _eksport(self, format_, yol):             # partialmethod uchun: self birinchi
        return yoz(format_, self, yol)

    saqla_metod = partialmethod(_eksport, "yaml")
    saqla_xato = partialmethod(yoz, "yaml")        # ⚠️ yoz(self, "yaml", yol) bo'lib chaqiriladi

    def __repr__(self):
        return "Hujjat()"


h = Hujjat()
print(f"  partial __get__ bormi: {hasattr(Hujjat.__dict__['saqla'], '__get__')}")
print(f"  h.saqla('a.json')              → {h.saqla('a.json')}")
try:
    print(f"  h.saqla_statik('a.json')       → {h.saqla_statik('a.json')}")
except TypeError as e:
    print(f"  h.saqla_statik('a.json')       → TypeError: {e}")
print(f"  h.saqla_statik(h, 'a.json')    → {h.saqla_statik(h, 'a.json')}")
print(f"  h.saqla_metod('b.yaml')        → {h.saqla_metod('b.yaml')}")
print(f"  h.saqla_xato('b.yaml')         → {h.saqla_xato('b.yaml')}   ⚠️ format_=Hujjat(), obyekt='yaml'")

print("\n=== 6. partial erta, lambda kechikkan ===")
tugmalar_lambda, tugmalar_partial = [], []
for raqam in range(1, 4):
    tugmalar_lambda.append(lambda: xabar("INFO", "ui", f"tugma {raqam}"))
    tugmalar_partial.append(partial(xabar, "INFO", "ui", f"tugma {raqam}"))
print(f"  lambda:  {[t().split(': ')[1] for t in tugmalar_lambda]}")
print(f"  partial: {[t().split(': ')[1] for t in tugmalar_partial]}")

=== 1. Tekislash va argumentlar tartibi ===
  func: xabar, args: ('XATO', 'db'), keywords: {'belgi': '✗'}
  ✗ [12:00] XATO db: ulanish uzildi
  nomli qayta yozildi: ! [09:30] XATO db: ulanish uzildi
  pozitsionni qayta yozib bo'lmaydi: TypeError: xabar() takes 3 positional arguments but 4 positional arguments (and 1 keyword-only argument) were given

=== 2. Imzo ===
  xabar:   (daraja, modul, matn, *, vaqt='12:00', belgi='•')
  xato_db: (matn, *, vaqt='12:00', belgi='✗')

=== 3. Placeholder 3.14-bob ===
  ikkiga_bol(9) = 4.5, kvadrat(12) = 144
  • [12:00] OGOHLANTIRISH auth: parol noto'g'ri
  imzo: (daraja, /, matn, *, vaqt='12:00', belgi='•')
  oxirida Placeholder: TypeError: trailing Placeholders are not allowed

=== 4. pickle: partial va lambda ===
  partial(operator.mul, 3): ✅ 15
  lambda x: 3 * x: ❌ PicklingError

=== 5. ⚠️ 3.14: partial klass atributi sifatida self ni bog'laydi ===
  partial __get__ bormi: True
  h.saqla('a.json')              → Hujjat → a.json (json)
  h.saqla_statik('a.json')       → TypeError: yoz() missing 1 required positional argument: 'yol'
  h.saqla_statik(h, 'a.json')    → Hujjat → a.json (json)
  h.saqla_metod('b.yaml')        → Hujjat → b.yaml (yaml)
  h.saqla_xato('b.yaml')         → str → b.yaml (Hujjat())   ⚠️ format_=Hujjat(), obyekt='yaml'

=== 6. partial erta, lambda kechikkan ===
  lambda:  ['tugma 3', 'tugma 3', 'tugma 3']
  partial: ['tugma 1', 'tugma 2', 'tugma 3']

"""partial + reduce kompozitsiya; TTL chelakli lru_cache; bo'laklab reduce va assotsiativlik."""

import operator
from functools import Placeholder, lru_cache, partial, reduce
from itertools import accumulate, batched


def foiz_chegirma(foiz, summa):
    return summa * (100 - foiz) // 100


def chegara_chegirma(chegara, ayirma, summa):
    return summa - ayirma if summa >= chegara else summa


def eng_kam(minimal, summa):
    return max(minimal, summa)


def kompozitsiya(*funksiyalar):
    """chapdan o'ngga: kompozitsiya(f, g)(x) == g(f(x)); neytral element — lambda x: x."""
    return reduce(lambda f, g: lambda x: g(f(x)), funksiyalar, lambda x: x)


print("=== 1. Qoidalar partial bilan, quvur reduce bilan ===")
qoidalar = [
    partial(foiz_chegirma, 10),                               # 10% aksiya
    partial(chegara_chegirma, 500_000, 50_000),               # 500 mingdan oshsa −50 ming
    partial(eng_kam, 100_000),                                # kamida 100 ming
]
hisobla = kompozitsiya(*qoidalar)
for savatcha in (120_000, 600_000, 580_000):
    qadamlar = list(accumulate(qoidalar, lambda s, q: q(s), initial=savatcha))
    print(f"  {savatcha:>9,} → {hisobla(savatcha):>9,}   qadamlar: {[f'{q:,}' for q in qadamlar]}")
print(f"  bo'sh quvur (neytral element): {kompozitsiya()(777)}")

print("\n=== 2. Valyuta kursi: eskirish muddati bilan kesh ===")
soat = {"t": 0}
tarmoq_sorovlari = []


@lru_cache(maxsize=32)
def _kurs(valyuta, chelak):
    tarmoq_sorovlari.append((valyuta, chelak))
    return {"USD": 12_600, "EUR": 13_700}[valyuta] + chelak * 10


def kurs(valyuta, *, muddat=300):
    return _kurs(valyuta, soat["t"] // muddat)


for t, valyuta in [(0, "USD"), (120, "USD"), (299, "EUR"), (300, "USD"), (450, "USD"), (610, "EUR")]:
    soat["t"] = t
    print(f"  t={t:>3}s {valyuta}: {kurs(valyuta):,}")
print(f"  tarmoq so'rovlari: {tarmoq_sorovlari}")
print(f"  {_kurs.cache_info()}")

print("\n=== 3. Placeholder bilan konvertatsiya ===")
soat["t"] = 0
som_to_usd = partial(operator.floordiv, Placeholder, kurs("USD"))
print(f"  {hisobla(600_000):,} so'm ≈ {som_to_usd(hisobla(600_000))} USD")

print("\n=== 4. ⭐ Bo'laklab yig'ish: faqat assotsiativ amal to'g'ri ===")
buyurtmalar = [120_000, 45_000, 300_000, 80_000, 15_000, 240_000, 99_000]


def bolaklab(amal, malumot, neytral, hajm=3):
    bolak_natijalari = [reduce(amal, bolak, neytral) for bolak in batched(malumot, hajm)]
    return reduce(amal, bolak_natijalari, neytral)


def ortacha_yomon(a, b):
    return (a + b) / 2


def juftlik(a, b):
    return (a[0] + b[0], a[1] + b[1])


for nom, amal, neytral, tayyorla in [
    ("yig'indi (+)", operator.add, 0, lambda x: x),
    ("eng katta (max)", max, float("-inf"), lambda x: x),
    ("ayirma (-)", operator.sub, 0, lambda x: x),
    ("o'rtacha (a+b)/2", ortacha_yomon, 0, lambda x: x),
    ("(yig'indi, soni)", juftlik, (0, 0), lambda x: (x, 1)),
]:
    malumot = [tayyorla(x) for x in buyurtmalar]
    ketma_ket = reduce(amal, malumot, neytral)
    bolakli = bolaklab(amal, malumot, neytral)
    print(f"  {nom:18} ketma-ket: {str(ketma_ket):18} bo'laklab: {str(bolakli):18} {'✅' if ketma_ket == bolakli else '❌'}")
jami, soni = reduce(juftlik, [(x, 1) for x in buyurtmalar], (0, 0))
print(f"  to'g'ri o'rtacha — juftlikdan: {jami / soni:,.0f}")

=== 1. Qoidalar partial bilan, quvur reduce bilan ===
    120,000 →   108,000   qadamlar: ['120,000', '108,000', '108,000', '108,000']
    600,000 →   490,000   qadamlar: ['600,000', '540,000', '490,000', '490,000']
    580,000 →   472,000   qadamlar: ['580,000', '522,000', '472,000', '472,000']
  bo'sh quvur (neytral element): 777

=== 2. Valyuta kursi: eskirish muddati bilan kesh ===
  t=  0s USD: 12,600
  t=120s USD: 12,600
  t=299s EUR: 13,700
  t=300s USD: 12,610
  t=450s USD: 12,610
  t=610s EUR: 13,720
  tarmoq so'rovlari: [('USD', 0), ('EUR', 0), ('USD', 1), ('EUR', 2)]
  CacheInfo(hits=2, misses=4, maxsize=32, currsize=4)

=== 3. Placeholder bilan konvertatsiya ===
  490,000 so'm ≈ 38 USD

=== 4. ⭐ Bo'laklab yig'ish: faqat assotsiativ amal to'g'ri ===
  yig'indi (+)       ketma-ket: 899000             bo'laklab: 899000             ✅
  eng katta (max)    ketma-ket: 300000             bo'laklab: 300000             ✅
  ayirma (-)         ketma-ket: -899000            bo'laklab: 899000             ❌
  o'rtacha (a+b)/2   ketma-ket: 127390.625         bo'laklab: 80218.75           ❌
  (yig'indi, soni)   ketma-ket: (899000, 7)        bo'laklab: (899000, 7)        ✅
  to'g'ri o'rtacha — juftlikdan: 128,429

class Xizmat:
    @lru_cache(maxsize=None)           # ❌ har nusxa abadiy tirik
    def hisobla(self, x): ...

class Xizmat:
    @cached_property                   # ✅ argumentsiz bo'lsa
    def sozlama(self): ...
    # yoki modul darajasidagi @cache funksiya, kalit — ma'lumot

@cache
def standart_sozlama():
    return {"til": "uz"}               # ❌ bir joyda o'zgartirilsa — hamma joyda

@cache
def standart_sozlama():
    return MappingProxyType({"til": "uz"})   # ✅ yoki har chaqiruvda nusxa: dict(...)

@cache
def bugungi_kurs(valyuta): ...         # ❌ ertaga ham kechagi kurs

@lru_cache(maxsize=64)
def _kurs(valyuta, sana): ...
def bugungi_kurs(valyuta):
    return _kurs(valyuta, date.today())  # ✅ sana kalitda

narx("olma")                           # ❌ uch xil shakl — uch yozuv, uch marta hisob
narx(mahsulot="olma")
narx("olma", 1)

@cache
def jami(narxlar): ...
jami([1, 2, 3])                        # ❌ TypeError: unhashable type: 'list'

jami(tuple(narxlar))                   # ✅

class Eksport:
    csv = partial(eksport, "csv")      # ❌ 3.14: eksport("csv", self, ...)

class Eksport:
    csv = staticmethod(partial(eksport, "csv"))   # ✅ eski xatti-harakat
    # yoki partialmethod — agar self kerak bo'lsa

reduce(operator.or_, toplamlar)        # ❌ bo'sh ro'yxatda TypeError

reduce(operator.or_, toplamlar, frozenset())   # ✅ neytral element

ortacha = reduce(lambda a, b: (a + b) / 2, parallel_natijalar)   # ❌ noto'g'ri

jami, soni = reduce(juftlik, [(x, 1) for x in qiymatlar], (0, 0))
ortacha = jami / soni                  # ✅ assotsiativ juftlik

from functools import cache, lru_cache, partial, reduce, Placeholder
import operator

sanoq = []
@lru_cache(maxsize=2)
def kv(x):
    sanoq.append(x)
    return x * x

def h(a, b, c=0):
    return (a, b, c)
1.  kv(2)
    kv(2)
    kv(3)
    print(sanoq, kv.cache_info().hits)
2.  sanoq.clear()
    kv.cache_clear()
    for x in [1, 2, 3, 1]:
        kv(x)
    print(sanoq)
3.  @cache
    def f(x, y=1):
        return x + y
    f(1)
    f(1, 1)
    f(x=1)
    print(f.cache_info().currsize)
4.  @cache
    def r(n):
        return [0] * n
    r(2).append(5)
    print(r(2))
5.  p = partial(partial(h, 1), 2)
    print(p.func is h, p.args)
6.  print(partial(h, c=5)(1, 2, c=7))
7.  print(partial(h, Placeholder, 2)(1))
8.  class K:
        m = partial(h, "x")
    print(K().m(3)[2])
9.  print(reduce(operator.sub, [10, 3, 2]))
10. print(reduce(operator.add, [], 0), reduce(operator.add, [1, 2], initial=10))
11. try:
        reduce(max, [])
    except TypeError:
        print("TypeError")
12. print(reduce(lambda a, b: b + a, "abc"))

1.  class Katalog:
        def __init__(self, db):
            self.db = db
        @lru_cache(maxsize=None)
        def mahsulot(self, id):
            return self.db.ol(id)

2.  @cache
    def foydalanuvchi_sozlamalari(user_id):
        return dict(bazadan(user_id))

    s = foydalanuvchi_sozlamalari(7)
    s["til"] = "en"                    # faqat shu so'rov uchun

3.  @cache
    def valyuta_kursi(kod):
        return api.ol(f"/kurs/{kod}")  # kurs har soatda yangilanadi

4.  class Eksport:
        pdf = partial(eksport, "pdf")
    Eksport().pdf("hisobot")           # 3.14 ga o'tgach buzildi

5.  from concurrent.futures import ProcessPoolExecutor
    def ortacha(bolak):
        return reduce(lambda a, b: (a + b) / 2, bolak)
    with ProcessPoolExecutor() as ex:
        natija = reduce(lambda a, b: (a + b) / 2, ex.map(ortacha, bolaklar))