10.12-dars: Closure chuqur

class Oyna:
    def __init__(self, tugma):
        self.malumot = katta_jadval_yukla()          # 200 MB
        tugma.bosilganda(lambda: self.yangila())

for _ in range(50):
    oyna = Oyna(asosiy_tugma)
    oyna.yopish()
    del oyna

def hisoblagich():
    n = 0
    def ol():
        return n
    def qosh():
        nonlocal n
        n += 1
    return ol, qosh

hisoblagich chaqiruvi
     │
     ▼
  ┌──────┐
  │ cell │──► 0 → 1 → 2 ...
  └──────┘
   ▲    ▲
   │    │
  ol   qosh

import dis
dis.dis(hisoblagich)

class Hisob:
    def yarat(self):
        return super().__init__()

Hisob.yarat.__code__.co_freevars      # ('__class__',)

[lambda i=i: i for i in range(3)]               # 1. sukut argument
[functools.partial(ishla, i) for i in range(3)] # 2. partial
def yasa(i): return lambda: i                   # 3. fabrika — har chaqiruv yangi hujayra
[yasa(i) for i in range(3)]

def f():
    try:
        1 / 0
    except ZeroDivisionError as e:
        g = lambda: e
    return g

f()()    # NameError: cannot access free variable 'e' where it is not associated with a value in enclosing scope

def hisobot_yasa(jadval):                  # jadval — 1 mln qator
    soni = len(jadval)
    def sarlavha():
        return f"{len(jadval)} qator"      # ❌ jadvalni ushlaydi
    return sarlavha

def hisobot_yasa(jadval):
    soni = len(jadval)
    def sarlavha():
        return f"{soni} qator"             # ✅ faqat butun son
    return sarlavha

tugma.bosilganda(lambda: self.yangila())   # tugma → lambda → cell → self

def yasa(malumot):
    def yur(n):
        return yur(n - 1) if n else malumot    # yur → cell → yur
    return yur

tashqi.__code__.co_cellvars       # tashqi yaratadigan hujayralar nomlari
ichki.__code__.co_freevars        # ichki ishlatadigan tashqi hujayralar nomlari
ichki.__closure__                 # hujayra obyektlari korteji (yoki None)
ichki.__closure__[0].cell_contents  # hozirgi qiymat (yoziladi)
types.CellType(qiymat)            # qo'lda hujayra

MAKE_CELL  STORE_DEREF  LOAD_DEREF  COPY_FREE_VARS

[lambda: i for i in r]            → hammasi oxirgi
lambda i=i: i                     → sukut — def paytida
functools.partial(f, i)           → qotirilgan argument
def yasa(i): return lambda: i     → har chaqiruv yangi hujayra

closure → cell → obyekt           (butun obyekt tirik)
except E as e:  → blok oxirida del e → bo'sh hujayra → NameError
o'zini chaqiruvchi ichki funksiya → sikl → faqat gc
callback'da self                  → WeakMethod / weakref.ref / obunani bekor qilish

"""Bitta hujayrani bo'lishadigan funksiyalar, co_cellvars/co_freevars, bytecode, cell_contents, __class__."""

import dis
import types


def hisoblagich(boshlangich=0):
    n = boshlangich

    def ol():
        return n

    def qosh(qadam=1):
        nonlocal n
        n += qadam
        return n

    def nolla():
        nonlocal n
        n = 0

    return ol, qosh, nolla


print("=== 1. Bir chaqiruv — bitta quti ===")
ol, qosh, nolla = hisoblagich()
print(f"  hisoblagich.co_cellvars: {hisoblagich.__code__.co_cellvars}")
print(f"  ol.co_freevars: {ol.__code__.co_freevars}, qosh.co_freevars: {qosh.__code__.co_freevars}")
print(f"  bitta hujayra: {ol.__closure__[0] is qosh.__closure__[0] is nolla.__closure__[0]}")
qosh(); qosh(5)
print(f"  qosh ikki marta → ol() = {ol()}, cell_contents = {ol.__closure__[0].cell_contents}")
nolla()
print(f"  nolla() → ol() = {ol()}")

print("\n=== 2. Har chaqiruv — yangi quti ===")
a_ol, a_qosh, _ = hisoblagich(100)
b_ol, b_qosh, _ = hisoblagich(100)
a_qosh(); a_qosh(); b_qosh()
print(f"  a: {a_ol()}, b: {b_ol()}, hujayralar bir xilmi: {a_ol.__closure__[0] is b_ol.__closure__[0]}")

print("\n=== 3. Closure o'zgaruvchini eslaydi, qiymatni emas ===")


def yarat():
    xabar = "birinchi"
    f = lambda: xabar
    oldin = f()
    xabar = "ikkinchi"
    return oldin, f


oldin, f = yarat()
print(f"  lambda yaratilgan paytda o'qilsa: {oldin!r}, keyin chaqirilsa: {f()!r}")

print("\n=== 4. Bytecode ===")


def opkodlar(funksiya):
    return sorted({i.opname for i in dis.get_instructions(funksiya)} &
                  {"MAKE_CELL", "STORE_DEREF", "LOAD_DEREF", "COPY_FREE_VARS", "LOAD_FAST",
                   "STORE_FAST", "LOAD_FAST_BORROW"})


for nom, funksiya in [("hisoblagich", hisoblagich), ("ol", ol), ("qosh", qosh)]:
    print(f"  {nom:12} {opkodlar(funksiya)}")


def oddiy(n):
    return n + 1


print(f"  {'oddiy':12} {opkodlar(oddiy)}  closure: {oddiy.__closure__}")

print("\n=== 5. cell_contents yoziladi; CellType ===")
ol, qosh, _ = hisoblagich()
ol.__closure__[0].cell_contents = 41
print(f"  hujayraga 41 yozildi → qosh() = {qosh()}")
hujayra = types.CellType("qo'lda")
yangi = types.FunctionType(ol.__code__, globals(), "ol_nusxa", None, (hujayra,))
print(f"  boshqa hujayra bilan yangi funksiya: {yangi()!r}, asl ol(): {ol()}")

print("\n=== 6. Yashirin closure: super() va __class__ ===")


class Hisob:
    def __init__(self, balans):
        self.balans = balans

    def tavsif(self):
        return f"{type(self).__name__}: {self.balans}"


class Omonat(Hisob):
    def tavsif(self):
        return super().tavsif() + " (omonat)"

    def oddiy(self):
        return self.balans


print(f"  Omonat.tavsif.co_freevars: {Omonat.tavsif.__code__.co_freevars}")
print(f"  Omonat.oddiy.co_freevars:  {Omonat.oddiy.__code__.co_freevars}")
print(f"  __class__ hujayrasida: {Omonat.tavsif.__closure__[0].cell_contents.__name__}")


class Boshqa(Hisob):
    tavsif = Omonat.tavsif


try:
    Boshqa(5).tavsif()
except TypeError as e:
    print(f"  ⚠️ metodni boshqa klassga ko'chirish: TypeError: {e}")

=== 1. Bir chaqiruv — bitta quti ===
  hisoblagich.co_cellvars: ('n',)
  ol.co_freevars: ('n',), qosh.co_freevars: ('n',)
  bitta hujayra: True
  qosh ikki marta → ol() = 6, cell_contents = 6
  nolla() → ol() = 0

=== 2. Har chaqiruv — yangi quti ===
  a: 102, b: 101, hujayralar bir xilmi: False

=== 3. Closure o'zgaruvchini eslaydi, qiymatni emas ===
  lambda yaratilgan paytda o'qilsa: 'birinchi', keyin chaqirilsa: 'ikkinchi'

=== 4. Bytecode ===
  hisoblagich  ['LOAD_FAST_BORROW', 'MAKE_CELL', 'STORE_DEREF', 'STORE_FAST']
  ol           ['COPY_FREE_VARS', 'LOAD_DEREF']
  qosh         ['COPY_FREE_VARS', 'LOAD_DEREF', 'LOAD_FAST_BORROW', 'STORE_DEREF']
  oddiy        ['LOAD_FAST_BORROW']  closure: None

=== 5. cell_contents yoziladi; CellType ===
  hujayraga 41 yozildi → qosh() = 42
  boshqa hujayra bilan yangi funksiya: "qo'lda", asl ol(): 42

=== 6. Yashirin closure: super() va __class__ ===
  Omonat.tavsif.co_freevars: ('__class__',)
  Omonat.oddiy.co_freevars:  ()
  __class__ hujayrasida: Omonat
  ⚠️ metodni boshqa klassga ko'chirish: TypeError: super(type, obj): obj (instance of Boshqa) is not an instance or subtype of type (Omonat).

"""Sikl, comprehension, generator ifodasi; uch yechim; except as e va del; foydali kechikkan bog'lanish."""

import functools


print("=== 1. Uch xil yaratish — uch xil natija ===")
royxat = [lambda: i for i in range(3)]
print(f"  list comprehension:          {[f() for f in royxat]}")
print(f"  generator, darhol chaqirilsa: {[f() for f in (lambda: i for i in range(3))]}")
generator = (lambda: i for i in range(3))
saqlangan = list(generator)
print(f"  generator, avval list():      {[f() for f in saqlangan]}")
funksiyalar = []
for j in range(3):
    funksiyalar.append(lambda: j)
j = 99
print(f"  for sikl, keyin j = 99:       {[f() for f in funksiyalar]}   ⚠️ modul darajasida — global o'zgaruvchi")

print("\n=== 2. Tugmalar: har tugma o'z raqamini chiqarishi kerak ===")


class Tugma:
    def __init__(self, yorliq, bosilganda):
        self.yorliq, self.bosilganda = yorliq, bosilganda


def ishla(raqam, belgi="#"):
    return f"{belgi}{raqam}"


def yasa(raqam):
    return lambda: ishla(raqam)


variantlar = {
    "lambda: ishla(r)": [Tugma(r, lambda: ishla(r)) for r in range(1, 4)],
    "lambda r=r: ...": [Tugma(r, lambda r=r: ishla(r)) for r in range(1, 4)],
    "partial(ishla, r)": [Tugma(r, functools.partial(ishla, r)) for r in range(1, 4)],
    "yasa(r)": [Tugma(r, yasa(r)) for r in range(1, 4)],
}
for nom, tugmalar in variantlar.items():
    print(f"  {nom:18} → {[t.bosilganda() for t in tugmalar]}")

print("\n=== 3. ⚠️ Sukut argument yechimining narxi ===")
f = variantlar["lambda r=r: ..."][0].bosilganda
print(f"  imzo ko'rinadi: {f.__defaults__}, tasodifan f(7) → {f(7)!r}")
p = variantlar["partial(ishla, r)"][0].bosilganda
print(f"  partial ichini ko'rish mumkin: func={p.func.__name__}, args={p.args}; p(belgi='№') → {p(belgi='№')!r}")

print("\n=== 4. ⚠️ Bo'sh hujayra: except ... as e va del ===")


def xato_ushla():
    try:
        {}["kalit"]
    except KeyError as e:
        kechikkan = lambda: f"oxirgi xato: {e!r}"
        xato = e
        togri = lambda: f"oxirgi xato: {xato!r}"
    return kechikkan, togri


kechikkan, togri = xato_ushla()
for nom, f in [("e ni ushlagan", kechikkan), ("xato = e", togri)]:
    try:
        print(f"  {nom}: {f()}")
    except NameError as ex:
        print(f"  {nom}: NameError: {ex}")
print(f"  e hujayrasi bo'shmi: {kechikkan.__closure__[0].__repr__().endswith('empty>')}")


def ochirilgan():
    vaqtinchalik = [1, 2, 3]
    f = lambda: sum(vaqtinchalik)
    del vaqtinchalik
    return f


try:
    ochirilgan()()
except NameError as ex:
    print(f"  del dan keyin: NameError: {ex}")

print("\n=== 5. Kechikkan bog'lanish foydali bo'lganda ===")


def sozlamali_ilova():
    sozlama = {"til": "uz", "valyuta": "UZS"}

    def narx(summa):
        return f"{summa:,} {sozlama['valyuta']}"

    def qayta_yukla(yangi):
        nonlocal sozlama
        sozlama = yangi

    return narx, qayta_yukla


narx, qayta_yukla = sozlamali_ilova()
print(f"  {narx(150_000)}")
qayta_yukla({"til": "en", "valyuta": "USD"})
print(f"  qayta yuklangandan keyin o'sha narx funksiyasi: {narx(12)}")

=== 1. Uch xil yaratish — uch xil natija ===
  list comprehension:          [2, 2, 2]
  generator, darhol chaqirilsa: [0, 1, 2]
  generator, avval list():      [2, 2, 2]
  for sikl, keyin j = 99:       [99, 99, 99]   ⚠️ modul darajasida — global o'zgaruvchi

=== 2. Tugmalar: har tugma o'z raqamini chiqarishi kerak ===
  lambda: ishla(r)   → ['#3', '#3', '#3']
  lambda r=r: ...    → ['#1', '#2', '#3']
  partial(ishla, r)  → ['#1', '#2', '#3']
  yasa(r)            → ['#1', '#2', '#3']

=== 3. ⚠️ Sukut argument yechimining narxi ===
  imzo ko'rinadi: (1,), tasodifan f(7) → '#7'
  partial ichini ko'rish mumkin: func=ishla, args=(1,); p(belgi='№') → '№1'

=== 4. ⚠️ Bo'sh hujayra: except ... as e va del ===
  e ni ushlagan: NameError: cannot access free variable 'e' where it is not associated with a value in enclosing scope
  xato = e: oxirgi xato: KeyError('kalit')
  e hujayrasi bo'shmi: True
  del dan keyin: NameError: cannot access free variable 'vaqtinchalik' where it is not associated with a value in enclosing scope

=== 5. Kechikkan bog'lanish foydali bo'lganda ===
  150,000 UZS
  qayta yuklangandan keyin o'sha narx funksiyasi: 12 USD

"""Closure butun obyektni ushlaydi; self li callback; WeakMethod; o'zini chaqiruvchi ichki funksiya va gc."""

import gc
import weakref


class KattaJadval:
    def __init__(self, qatorlar):
        self.qatorlar = list(range(qatorlar))

    def __len__(self):
        return len(self.qatorlar)


print("=== 1. Closure butun obyektni tirik ushlaydi ===")


def sarlavha_yomon(jadval):
    return lambda: f"{len(jadval)} qator"


def sarlavha_yaxshi(jadval):
    soni = len(jadval)
    return lambda: f"{soni} qator"


for nom, yasovchi in [("jadvalni ushlaydi", sarlavha_yomon), ("faqat sonni", sarlavha_yaxshi)]:
    jadval = KattaJadval(100_000)
    havola = weakref.ref(jadval)
    sarlavha = yasovchi(jadval)
    del jadval
    gc.collect()
    ushlangan = [type(c.cell_contents).__name__ for c in sarlavha.__closure__]
    print(f"  {nom:18} {sarlavha()!r:15} jadval tirikmi: {havola() is not None}, hujayralarda: {ushlangan}")

print("\n=== 2. ⚠️ self ni ushlaydigan callback ===")


class Tugma:
    def __init__(self):
        self.ishlovchilar = []

    def bosilganda(self, f):
        self.ishlovchilar.append(f)

    def bos(self):
        natijalar = []
        for f in list(self.ishlovchilar):
            if isinstance(f, weakref.WeakMethod):
                metod = f()
                if metod is None:
                    self.ishlovchilar.remove(f)
                    continue
                f = metod
            natijalar.append(f())
        return natijalar


class Oyna:
    soni = 0

    def __init__(self, tugma, usul):
        Oyna.soni += 1
        self.raqam = Oyna.soni
        self.jadval = KattaJadval(10_000)
        if usul == "lambda":
            tugma.bosilganda(lambda: self.yangila())
        elif usul == "WeakMethod":
            tugma.bosilganda(weakref.WeakMethod(self.yangila))

    def yangila(self):
        return f"oyna {self.raqam} yangilandi"


for usul in ("lambda", "WeakMethod"):
    tugma = Tugma()
    havolalar = []
    for _ in range(3):
        oyna = Oyna(tugma, usul)
        havolalar.append(weakref.ref(oyna))
        del oyna
    gc.collect()
    tirik = sum(h() is not None for h in havolalar)
    print(f"  {usul:10}: 3 oyna yaratilib o'chirildi → tirik: {tirik}, tugma bosildi: {tugma.bos()}, "
          f"ro'yxatda qoldi: {len(tugma.ishlovchilar)}")

print("\n=== 3. ⚠️ O'zini chaqiruvchi ichki funksiya — aylanma havola ===")


def yurgizuvchi(jadval):
    def yur(n):
        return yur(n - 1) if n else len(jadval)
    return yur


gc.disable()
try:
    jadval = KattaJadval(1_000)
    havola = weakref.ref(jadval)
    yur = yurgizuvchi(jadval)
    print(f"  yur(5) = {yur(5)}, yur hujayralari: {yur.__code__.co_freevars}")
    print(f"  yur o'z hujayrasida o'zi: {yur.__closure__[1].cell_contents is yur}")
    del jadval, yur
    print(f"  del dan keyin (gc o'chiq) jadval tirikmi: {havola() is not None}")
    yigildi = gc.collect()
    print(f"  gc.collect() → {yigildi} obyekt yig'ildi, jadval tirikmi: {havola() is not None}")
finally:
    gc.enable()

print("\n=== 4. Obunani bekor qiluvchi closure ===")


class Hodisalar:
    def __init__(self):
        self.obunachilar = {}

    def obuna(self, nom, f):
        self.obunachilar.setdefault(nom, []).append(f)
        bekor_qilindi = False

        def bekor_qil():
            nonlocal bekor_qilindi
            if bekor_qilindi:
                return False
            self.obunachilar[nom].remove(f)
            bekor_qilindi = True
            return True

        return bekor_qil

    def chiqar(self, nom, *args):
        return [f(*args) for f in self.obunachilar.get(nom, [])]


TOLOV = "to'lov"
h = Hodisalar()
bekor1 = h.obuna(TOLOV, lambda s: f"SMS: {s:,}")
bekor2 = h.obuna(TOLOV, lambda s: f"email: {s:,}")
print(f"  {h.chiqar(TOLOV, 50_000)}")
print(f"  bekor1() → {bekor1()}, yana bekor1() → {bekor1()}")
print(f"  {h.chiqar(TOLOV, 70_000)}")

=== 1. Closure butun obyektni tirik ushlaydi ===
  jadvalni ushlaydi  '100000 qator'  jadval tirikmi: True, hujayralarda: ['KattaJadval']
  faqat sonni        '100000 qator'  jadval tirikmi: False, hujayralarda: ['int']

=== 2. ⚠️ self ni ushlaydigan callback ===
  lambda    : 3 oyna yaratilib o'chirildi → tirik: 3, tugma bosildi: ['oyna 1 yangilandi', 'oyna 2 yangilandi', 'oyna 3 yangilandi'], ro'yxatda qoldi: 3
  WeakMethod: 3 oyna yaratilib o'chirildi → tirik: 0, tugma bosildi: [], ro'yxatda qoldi: 0

=== 3. ⚠️ O'zini chaqiruvchi ichki funksiya — aylanma havola ===
  yur(5) = 1000, yur hujayralari: ('jadval', 'yur')
  yur o'z hujayrasida o'zi: True
  del dan keyin (gc o'chiq) jadval tirikmi: True
  gc.collect() → 6 obyekt yig'ildi, jadval tirikmi: False

=== 4. Obunani bekor qiluvchi closure ===
  ['SMS: 50,000', 'email: 50,000']
  bekor1() → True, yana bekor1() → False
  ['email: 70,000']

"""debounce, throttle, memo: closure va klass variantlari; holatni ko'rish, pickle, bir nechta amal."""

import pickle


class Soat:
    def __init__(self):
        self.t = 0.0

    def __call__(self):
        return self.t


soat = Soat()


def debounce(kutish, *, soat=soat):
    """Oxirgi chaqiruvdan keyin `kutish` soniya jimlik bo'lsa, `tekshir()` funksiyani bajaradi."""
    def dekorator(funksiya):
        kutilayotgan = None                # (vaqt, args)

        def chaqir(*args):
            nonlocal kutilayotgan
            kutilayotgan = (soat(), args)

        def tekshir():
            nonlocal kutilayotgan
            if kutilayotgan and soat() - kutilayotgan[0] >= kutish:
                _, args = kutilayotgan
                kutilayotgan = None
                return funksiya(*args)
            return None

        chaqir.tekshir = tekshir
        return chaqir
    return dekorator


def throttle(davr, *, soat=soat):
    def dekorator(funksiya):
        oxirgi = float("-inf")

        def orovchi(*args):
            nonlocal oxirgi
            if soat() - oxirgi >= davr:
                oxirgi = soat()
                return funksiya(*args)
            return "o'tkazib yuborildi"

        return orovchi
    return dekorator


def memo(funksiya):
    kesh = {}

    def orovchi(*args):
        if args not in kesh:
            kesh[args] = funksiya(*args)
        return kesh[args]

    orovchi.tozala = kesh.clear
    orovchi.hajm = lambda: len(kesh)
    return orovchi


class Memo:
    def __init__(self, funksiya):
        self.funksiya = funksiya
        self.kesh = {}

    def __call__(self, *args):
        if args not in self.kesh:
            self.kesh[args] = self.funksiya(*args)
        return self.kesh[args]


print("=== 1. debounce: qidiruv maydoniga yozish ===")
sorovlar = []


@debounce(0.3)
def qidir(matn):
    sorovlar.append(matn)
    return f"'{matn}' bo'yicha qidirildi"


for vaqt, harf in [(0.0, "p"), (0.1, "py"), (0.2, "pyt"), (0.25, "pyth"), (0.4, "pytho"), (0.5, "python")]:
    soat.t = vaqt
    qidir(harf)
    natija = qidir.tekshir()
    if natija:
        print(f"  t={vaqt}: {natija}")
soat.t = 0.85
print(f"  t=0.85: {qidir.tekshir()}")
print(f"  serverga so'rovlar: {sorovlar}  (6 ta harf, 1 ta so'rov)")

print("\n=== 2. throttle: skroll hodisalari ===")


@throttle(1.0)
def yukla(sahifa):
    return f"{sahifa}-sahifa yuklandi"


for vaqt, sahifa in [(10.0, 2), (10.3, 3), (10.9, 4), (11.0, 5), (11.5, 6), (12.2, 7)]:
    soat.t = vaqt
    print(f"  t={vaqt}: {yukla(sahifa)}")

print("\n=== 3. Holatni ko'rish: closure vs klass ===")


def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)


m1, m2 = memo(fib), Memo(fib)
for n in (10, 20, 10):
    m1(n), m2(n)
print(f"  closure: hujayralar {m1.__code__.co_freevars}, kesh hajmi (yordamchi orqali): {m1.hajm()}")
print(f"  klass:   vars → {sorted(vars(m2))}, kesh kalitlari: {sorted(m2.kesh)}")

print("\n=== 4. pickle ===")
for nom, obyekt in [("closure memo", m1), ("klass Memo", m2)]:
    try:
        tiklangan = pickle.loads(pickle.dumps(obyekt))
        print(f"  {nom}: ✅ tiklandi, kesh: {sorted(tiklangan.kesh)}")
    except (pickle.PicklingError, AttributeError) as e:
        print(f"  {nom}: ❌ {type(e).__name__}: {str(e).split(' <')[0]}")

print("\n=== 5. Bitta chaqiruvning ichki holati — yashirinlik afzallik ham ===")
m2.kesh[(10,)] = -1
print(f"  klass: tashqaridan buzish oson → m2(10) = {m2(10)}")
try:
    m1.kesh
except AttributeError:
    print(f"  closure: m1.kesh yo'q, faqat tozala/hajm orqali → m1(10) = {m1(10)}")

=== 1. debounce: qidiruv maydoniga yozish ===
  t=0.85: 'python' bo'yicha qidirildi
  serverga so'rovlar: ['python']  (6 ta harf, 1 ta so'rov)

=== 2. throttle: skroll hodisalari ===
  t=10.0: 2-sahifa yuklandi
  t=10.3: o'tkazib yuborildi
  t=10.9: o'tkazib yuborildi
  t=11.0: 5-sahifa yuklandi
  t=11.5: o'tkazib yuborildi
  t=12.2: 7-sahifa yuklandi

=== 3. Holatni ko'rish: closure vs klass ===
  closure: hujayralar ('funksiya', 'kesh'), kesh hajmi (yordamchi orqali): 2
  klass:   vars → ['funksiya', 'kesh'], kesh kalitlari: [(10,), (20,)]

=== 4. pickle ===
  closure memo: ❌ PicklingError: Can't pickle local object
  klass Memo: ✅ tiklandi, kesh: [(10,), (20,)]

=== 5. Bitta chaqiruvning ichki holati — yashirinlik afzallik ham ===
  klass: tashqaridan buzish oson → m2(10) = -1
  closure: m1.kesh yo'q, faqat tozala/hajm orqali → m1(10) = 55

for b in tugmalar:
    b.bosilganda(lambda: ochir(b.id))       # ❌ hammasi oxirgi tugmani o'chiradi

for b in tugmalar:
    b.bosilganda(functools.partial(ochir, b.id))   # ✅

def hisoblagich():
    n = 0
    def qosh():
        n += 1                              # ❌ UnboundLocalError — n lokal bo'lib qoldi
    return qosh

    def qosh():
        nonlocal n                          # ✅
        n += 1

def hisobot(df):
    return lambda: f"{len(df)} qator"       # ❌ butun DataFrame xotirada qoladi

def hisobot(df):
    n = len(df)
    return lambda: f"{n} qator"             # ✅

tugma.bosilganda(lambda: self.yangila())             # ❌ oyna hech qachon o'chmaydi

tugma.bosilganda(weakref.WeakMethod(self.yangila))   # ✅ yoki yopilganda obunani bekor qiling

except ValueError as e:
    qayta_urinish = lambda: jurnal(e)       # ❌ NameError

except ValueError as e:
    xato = e
    qayta_urinish = lambda: jurnal(xato)    # ✅

ishlovchilar = [lambda x, i=i: x * i for i in range(3)]
ishlovchilar[0](5, 10)                      # ❌ tasodifan i qayta yozildi — xato yo'q

ishlovchilar = [functools.partial(operator.mul, i) for i in range(3)]   # ✅

pool.map(yasa_ishlovchi(sozlama), malumot)  # ❌ PicklingError: Can't pickle local object

pool.map(functools.partial(ishla, sozlama), malumot)   # ✅ modul darajasidagi funksiya + partial

def hisob(balans):
    def yech(s): ...
    def qosh(s): ...
    def qoldiq(): ...
    return {"yech": yech, "qosh": qosh, "qoldiq": qoldiq}   # ❌ klassni qo'lda yasash

class Hisob: ...                            # ✅ metodlar, repr, isinstance, pickle

def yasash():
    n = 0
    def ol():
        return n
    def qosh():
        nonlocal n
        n += 1
        return n
    return ol, qosh
1.  ol, qosh = yasash()
    qosh()
    qosh()
    print(ol())
2.  a = yasash()
    b = yasash()
    a[1]()
    print(a[0](), b[0]())
3.  print([f() for f in [lambda: i for i in range(3)]])
4.  print([f() for f in (lambda: i for i in range(3))])
5.  print([f() for f in [lambda i=i: i for i in range(3)]])
6.  def f():
        x = 1
        g = lambda: x
        x = 2
        return g
    print(f()())
7.  ol, qosh = yasash()
    print(ol.__closure__[0] is qosh.__closure__[0])
8.  ol, qosh = yasash()
    ol.__closure__[0].cell_contents = 10
    print(qosh())
9.  print(yasash.__code__.co_cellvars, yasash()[0].__code__.co_freevars)
10. def f():
        try:
            1 / 0
        except ZeroDivisionError as e:
            g = lambda: type(e).__name__
        return g
    try:
        f()()
    except NameError:
        print("NameError")
11. class K:
        def m(self):
            return super().__str__()
    print(K.m.__code__.co_freevars)
12. def tashqi():
        x = "tashqi"
        def orta():
            x = "orta"
            def ichki():
                nonlocal x
                x = "ichki"
            ichki()
            return x
        return orta(), x
    print(tashqi())

1.  def vazifalar_yarat(nomlar):
        vazifalar = []
        for nom in nomlar:
            vazifalar.append(lambda: print(f"{nom} bajarildi"))
        return vazifalar

2.  def sanagich():
        soni = 0
        def keyingi():
            soni += 1
            return soni
        return keyingi

3.  class Grafik:
        def __init__(self, manba):
            self.nuqtalar = manba.yukla()      # juda katta
            manba.yangilanganda(lambda: self.chiz())

4.  def ishlov(fayllar):
        xatolar = []
        for f in fayllar:
            try:
                oqi(f)
            except OSError as e:
                xatolar.append(lambda: f"{f}: {e}")
        return xatolar

5.  def daraja_filtri(jurnal):
        return lambda yozuv: yozuv.daraja >= jurnal.sozlama.daraja and len(jurnal.yozuvlar)