Python kursi8.4-dars: Metodlar va self
Python kursi · OOP

8.4-dars: Metodlar va self

32 daqiqa4/20-dars

8-QISM — OBYEKTGA YO'NALTIRILGAN DASTURLASH · 4-dars


1. Kirish va motivatsiya

Bu uch qator bir xil ish qiladi:

python
class A:
    def salom(self, kim):
        return f"Salom, {kim}! ({self.nom})"

a = A()
a.nom = "A"

a.salom("dunyo")                # 'Salom, dunyo! (A)'
A.salom(a, "dunyo")             # 'Salom, dunyo! (A)'   ⭐ aynan shu
A.__dict__["salom"](a, "dunyo") # 'Salom, dunyo! (A)'

Va bu narsalar turli obyektlar:

python
A.salom                         # <function A.salom at 0x...>
a.salom                         # <bound method A.salom of <A object>>

type(A.salom)                   # <class 'function'>
type(a.salom)                   # <class 'method'>

a.salom is a.salom              # False ⚠️ har safar yangi!
a.salom.__func__ is A.salom     # True

Savollar:

  • a.salom yozilganda aniq nima yaratiladi?
  • self qayerdan keladi?
  • Nega a.salom is a.salom — False?
  • Metodni sinfdan tashqarida yozib bo'ladimi?

Bu darsda:

  • Bog'langan metod (bound method) — qanday yaratiladi
  • self uzatilish mexanizmi
  • Metod turlari: nusxa, sinf, statik
  • Metodlarni ish vaqtida qo'shish va almashtirish
  • Metodni atribut sifatida saqlash tuzog'i
  • Metod loyihalash tamoyillari

2. Nazariya — chuqur tushuntirish

2.1. Metod — bu funksiya

python
class A:
    def metod(self, x):
        return x * 2


type(A.metod)                   # <class 'function'>  ← oddiy funksiya
A.__dict__["metod"]             # <function A.metod>

Sinf lug'atida funksiya saqlanadi. "Metod" — bu funksiya + obyekt birikmasi, va u faqat kirish paytida yaratiladi.

2.2. Bog'langan metod qanday yaratiladi

python
a = A()
a.metod                         # <bound method A.metod of <A object at 0x...>>

Nima bo'ldi:

  1. a.metod — a.__dict__ da metod yo'q
  2. type(a).__mro__ da qidiriladi → A.__dict__["metod"] topildi
  3. Topilgan obyekt funksiya, ya'ni deskriptor (__get__ bor)
  4. Python A.__dict__["metod"].__get__(a, A) chaqiradi
  5. Natija — MethodType obyekti: funksiya + a
python
f = A.__dict__["metod"]
f.__get__(a, A)                 # <bound method A.metod of ...>

# Qo'lda ham yasash mumkin
from types import MethodType
m = MethodType(f, a)
m(5)                            # 10

Bog'langan metod ikki narsani saqlaydi:

python
m = a.metod
m.__func__                      # <function A.metod>  — asl funksiya
m.__self__                      # <A object>          — obyekt

m(5)                            # ≡ m.__func__(m.__self__, 5)

Shuning uchun self ni yozish kerak — u haqiqiy birinchi argument.

2.3. Har kirishda yangi obyekt

python
a.metod is a.metod              # False ⚠️
a.metod == a.metod              # True  ✅ (__eq__ bor)

Har a.metod yozilganda yangi MethodType obyekti yaratiladi. Bu:

Tuzoq 1 — callback'ni o'chirish:

python
tugma.qoshish(a.bosildi)        # bir obyekt
tugma.ochirish(a.bosildi)       # ⚠️ BOSHQA obyekt — topilmaydi!

Yechim — havolani saqlash:

python
self._ishlovchi = a.bosildi
tugma.qoshish(self._ishlovchi)
tugma.ochirish(self._ishlovchi)     # ✅

Tuzoq 2 — to'plamga qo'shish:

python
kuzatuvchilar = set()
kuzatuvchilar.add(a.bosildi)
kuzatuvchilar.add(a.bosildi)
len(kuzatuvchilar)              # 1 ✅ — __hash__ va __eq__ bor

Bu ishlaydi, chunki MethodType da __eq__ va __hash__ aniqlangan (__func__ va __self__ bo'yicha).

Tuzoq 3 — obyekt o'chmaydi:

python
class A:
    def metod(self): ...

a = A()
saqlangan = a.metod             # ⭐ a ga havola SAQLANADI
del a                           # obyekt o'chmaydi!
saqlangan.__self__              # <A object> — hali tirik

Kuzatuvchi ro'yxatlarida weakref.WeakMethod ishlating.

2.4. Uch xil metod

python
class A:
    def nusxa_metod(self, x):       # self — nusxa
        return f"nusxa: {self}, {x}"

    @classmethod
    def sinf_metod(cls, x):         # cls — sinf
        return f"sinf: {cls.__name__}, {x}"

    @staticmethod
    def statik(x):                  # hech narsa
        return f"statik: {x}"
Birinchi param Nusxadan Sinfdan Qachon
Nusxa metod self A.f(a) Nusxa holati bilan ishlaydi
@classmethod cls Fabrika, sinf holati
@staticmethod — Mantiqan bog'liq yordamchi
python
a = A()
a.nusxa_metod(1)                # ✅
A.nusxa_metod(a, 1)             # ✅ — self qo'lda
A.nusxa_metod(1)                # ❌ TypeError

a.sinf_metod(1)                 # ✅ — cls = A
A.sinf_metod(1)                 # ✅

a.statik(1)                     # ✅
A.statik(1)                     # ✅

@classmethod va meros:

python
class Ota:
    @classmethod
    def yarat(cls):
        return cls()            # ⭐ HAQIQIY sinf

class Bola(Ota):
    pass

type(Bola.yarat())              # Bola ✅ — Ota emas

Batafsil — 8.16-dars.

2.5. Metodlarni ish vaqtida qo'shish

python
class A:
    pass


def yangi(self, x):
    return self.q + x


A.yangi = yangi                 # ⭐ sinfga qo'shish
a = A()
a.q = 10
a.yangi(5)                      # 15 ✅

Nusxaga qo'shish — bog'lanish YO'Q:

python
a2 = A()
a2.faqat_menga = yangi          # nusxa lug'atiga
a2.faqat_menga(5)               # ❌ TypeError: yangi() missing 1 argument

Sabab: deskriptor protokoli faqat sinf lug'atidan topilgan obyektlarga qo'llanadi. Nusxa lug'atidagi funksiya — oddiy funksiya.

Qo'lda bog'lash:

python
from types import MethodType
a2.faqat_menga = MethodType(yangi, a2)
a2.faqat_menga(5)               # 15 ✅

Callable atribut tuzog'i:

python
class A:
    def __init__(self):
        self.ishlovchi = lambda x: x * 2    # ⚠️ nusxa lug'atida

a = A()
a.ishlovchi(5)                  # 10 — self uzatilmaydi

Bu ba'zan kerak (callback saqlash), lekin metoddan farqini bilish shart.

2.6. self — kelishuv, kalit so'z emas

python
class A:
    def metod(bu, x):           # ✅ ishlaydi
        return bu.q + x

Lekin hech qachon shunday yozmang — PEP 8 va butun jamoa self ishlatadi.

Istisnolar:

Kontekst Nom
Nusxa metod self
@classmethod cls
Metaklass metodi cls (metaklass nusxasi — sinf)
__new__ cls

2.7. Metod loyihalash

Bir metod — bir vazifa:

python
# ⚠️ Ko'p vazifa
def qayta_ishla(self):
    self._yukla()
    self._tozala()
    self._tekshir()
    self._saqla()
    self._xabar_yubor()

# ✅ Har biri alohida, kompozitsiya oshkora
def quvur(self):
    self._yukla()
    self._tozala()
    ...

Nom — fe'l:

python
h.saqla()                       # ✅
h.saqlash()                     # ⚠️
h.hujjat_saqlash_amali()        # ⚠️ uzun

Qaytarish qiymati — bir xil turda:

python
def top(self, kalit):
    if kalit in self._d:
        return self._d[kalit]
    return None                 # ✅ izchil

def top(self, kalit):
    if kalit in self._d:
        return self._d[kalit]
    return []                   # ⚠️ boshqa tur

self ni qaytarish — zanjir uchun:

python
class Qurilma:
    def qosh(self, x):
        self._el.append(x)
        return self             # ⭐ zanjir

    def saralash(self):
        self._el.sort()
        return self


q = Qurilma().qosh(3).qosh(1).saralash()

Lekin aralashtirmang: yoki hamma metod self qaytarsin, yoki hech biri. Pythonda list.append() None qaytaradi — bu ataylab (7.2-darsda ko'rgan edik).


3. Tez ma'lumotnoma

Bog'langan metod

python
a.metod                 <bound method>
  = A.__dict__["metod"].__get__(a, A)
  = MethodType(A.metod, a)

a.metod.__func__        asl funksiya
a.metod.__self__        obyekt

a.metod(x)  ≡  A.metod(a, x)  ≡  a.metod.__func__(a, x)

⚠️ a.metod is a.metod  →  False   (har safar yangi)
   a.metod == a.metod  →  True    (__eq__ bor)

Uch metod turi

python
def f(self, x)          nusxa metod   a.f(1) / A.f(a, 1)
@classmethod
def f(cls, x)           sinf metod    a.f(1) / A.f(1)
@staticmethod
def f(x)                statik        a.f(1) / A.f(1)

Ish vaqtida qo'shish

python
A.yangi = fn                        ✅ bog'lanadi
a.yangi = fn                        ⚠️ bog'lanmaydi
a.yangi = MethodType(fn, a)         ✅ qo'lda bog'lash

Tuzoqlar

a.metod is a.metod          False — callback o'chirishda muammo
a.metod obyektni ushlaydi   del a — o'chmaydi (WeakMethod kerak)
nusxadagi lambda            self olmaydi

4. Batafsil misollar

Misol 1 — Bog'langan metod ichkarisi

python
"""a.metod yozilganda aniq nima bo'ladi."""

from types import MethodType, FunctionType

print("=== 1. Sinf lug'atida FUNKSIYA saqlanadi ===\n")


class A:
    def metod(self, x):
        return f"{self.nom}: {x}"


a = A()
a.nom = "A-obyekt"

print(f"  A.__dict__['metod']  = {A.__dict__['metod']}")
print(f"  type(...)            = {type(A.__dict__['metod'])}")
print(f"  A.metod              = {A.metod}")
print(f"  type(A.metod)        = {type(A.metod)}")
print(f"\n  a.metod              = {a.metod}")
print(f"  type(a.metod)        = {type(a.metod)}")

print(f"""
  ⭐ Sinf lug'atida — FUNKSIYA
     Nusxa orqali kirilganda — METHOD (bog'langan)
""")


print("=== 2. ⭐ Deskriptor protokoli ===\n")

f = A.__dict__["metod"]

print(f"  Funksiyada __get__ bormi: {hasattr(f, '__get__')}")
print(f"  → funksiya — DESKRIPTOR\n")

qolda = f.__get__(a, A)
print(f"  f.__get__(a, A)      = {qolda}")
print(f"  qolda(5)             = {qolda(5)!r}")

qolda2 = MethodType(f, a)
print(f"\n  MethodType(f, a)     = {qolda2}")
print(f"  qolda2(5)            = {qolda2(5)!r}")

print(f"""
  ⭐ a.metod aslida:
     1. a.__dict__ da 'metod' yo'q
     2. type(a).__mro__ da topildi → funksiya
     3. Funksiyada __get__ bor → deskriptor
     4. f.__get__(a, A) chaqiriladi
     5. Natija — MethodType(f, a)
""")


print("=== 3. Uch teng chaqiruv ===\n")

USULLAR = [
    ("a.metod(5)",                      lambda: a.metod(5)),
    ("A.metod(a, 5)",                   lambda: A.metod(a, 5)),
    ("A.__dict__['metod'](a, 5)",       lambda: A.__dict__["metod"](a, 5)),
    ("a.metod.__func__(a, 5)",          lambda: a.metod.__func__(a, 5)),
    ("a.metod.__func__(a.metod.__self__, 5)",
     lambda: a.metod.__func__(a.metod.__self__, 5)),
    ("MethodType(A.metod, a)(5)",       lambda: MethodType(A.metod, a)(5)),
]

for kod, fn in USULLAR:
    print(f"  {kod:<42} → {fn()!r}")

print(f"\n  ⭐ Hammasi BIR XIL — self oddiy argument")


print("\n=== 4. __func__ va __self__ ===\n")

m = a.metod
print(f"  m = a.metod")
print(f"    m.__func__  = {m.__func__}")
print(f"    m.__self__  = {m.__self__}")
print(f"    m.__self__ is a = {m.__self__ is a}")
print(f"    m.__func__ is A.metod = {m.__func__ is A.metod}")
print(f"    m.__name__  = {m.__name__!r}")
print(f"    m.__doc__   = {m.__doc__!r}")

print(f"\n  Boshqa obyektga bog'lash:")
b = A()
b.nom = "B-obyekt"
m2 = MethodType(m.__func__, b)
print(f"    m(5)  = {m(5)!r}")
print(f"    m2(5) = {m2(5)!r}   ← bir funksiya, boshqa obyekt")


print("\n=== 5. ⚠️ Har kirishda YANGI obyekt ===\n")

print(f"  a.metod is a.metod   = {a.metod is a.metod}   ⚠️")
print(f"  a.metod == a.metod   = {a.metod == a.metod}   ✅")
print(f"  hash(a.metod) == hash(a.metod) = "
      f"{hash(a.metod) == hash(a.metod)}   ✅")

print(f"\n  id lar:")
for i in range(3):
    print(f"    {i+1}-marta: id(a.metod) = {id(a.metod) % 1000000}")

print(f"\n  ⭐ __eq__ __func__ va __self__ bo'yicha:")
print(f"     a.metod == a.metod        {a.metod == a.metod}")
print(f"     a.metod == b.metod        {a.metod == b.metod}   (boshqa obyekt)")

print(f"\n  To'plamda ishlaydi:")
s = {a.metod, a.metod, b.metod}
print(f"    {{a.metod, a.metod, b.metod}} → {len(s)} element ✅")


print("\n=== ⚠️ 6. Callback o'chirish tuzog'i ===\n")


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

    def qoshish(self, f):
        self._ishlovchilar.append(f)

    def ochirish(self, f):
        try:
            self._ishlovchilar.remove(f)
            return True
        except ValueError:
            return False

    def bos(self):
        for f in self._ishlovchilar:
            f()


class Oyna:
    def __init__(self, nom):
        self.nom = nom

    def bosildi(self):
        print(f"      {self.nom} javob berdi")


t = Tugma()
o = Oyna("Oyna-1")

t.qoshish(o.bosildi)
print(f"  Qo'shildi. Ishlovchilar: {len(t._ishlovchilar)}")
t.bos()

topildi = t.ochirish(o.bosildi)
print(f"\n  t.ochirish(o.bosildi) → {topildi}")
print(f"  Qolgan: {len(t._ishlovchilar)}")
print(f"""
  ⭐ ISHLADI, chunki MethodType da __eq__ bor.
     list.remove() == bilan solishtiradi, is bilan emas.

  ⚠️ Lekin `is` ga tayangan kod BUZILADI:
""")

saqlangan = o.bosildi
print(f"    saqlangan is o.bosildi = {saqlangan is o.bosildi}   ⚠️")
print(f"    saqlangan == o.bosildi = {saqlangan == o.bosildi}   ✅")

print(f"""
  ✅ ISHONCHLI USUL — havolani saqlash:

     class Oyna:
         def __init__(self, tugma):
             self._ishlovchi = self.bosildi      # BIR MARTA
             tugma.qoshish(self._ishlovchi)

         def yop(self, tugma):
             tugma.ochirish(self._ishlovchi)     # AYNAN o'sha
""")


print("=== ⚠️ 7. Obyektni ushlab turish ===\n")

import gc
import weakref


class Kuzatilgan:
    def __init__(self, nom):
        self.nom = nom

    def ishla(self):
        return f"{self.nom} ishladi"

    def __del__(self):
        print(f"      [{self.nom} o'chirildi]")


print("  A) Oddiy bog'langan metod:")
k1 = Kuzatilgan("K1")
saqlangan_metod = k1.ishla
zaif1 = weakref.ref(k1)
print(f"    saqlangan_metod = k1.ishla")
print(f"    del k1")
del k1
gc.collect()
print(f"    zaif1() = {zaif1()}   ⚠️ hali tirik!")
print(f"    saqlangan_metod() = {saqlangan_metod()!r}")
del saqlangan_metod
gc.collect()

print(f"\n  B) WeakMethod:")
k2 = Kuzatilgan("K2")
zaif_metod = weakref.WeakMethod(k2.ishla)
zaif2 = weakref.ref(k2)
print(f"    zaif_metod = weakref.WeakMethod(k2.ishla)")
print(f"    zaif_metod()() = {zaif_metod()()!r}")
print(f"    del k2")
del k2
gc.collect()
print(f"    zaif2()      = {zaif2()}   ✅ o'chirildi")
print(f"    zaif_metod() = {zaif_metod()}   ✅ None")

print(f"""
  ⭐ Kuzatuvchi ro'yxatlarida WeakMethod ishlating —
     aks holda obyektlar hech qachon o'chmaydi (xotira oqishi).
""")

Natijaning muhim qismi:

text
=== 1. Sinf lug'atida FUNKSIYA saqlanadi ===

  A.__dict__['metod']  = <function A.metod at 0x000001>
  type(...)            = <class 'function'>
  a.metod              = <bound method A.metod of <__main__.A object at 0x0000025FE3E58980>>
  type(a.metod)        = <class 'method'>

=== 3. Uch teng chaqiruv ===

  a.metod(5)                                 → 'A-obyekt: 5'
  A.metod(a, 5)                              → 'A-obyekt: 5'
  A.__dict__['metod'](a, 5)                  → 'A-obyekt: 5'
  a.metod.__func__(a, 5)                     → 'A-obyekt: 5'

=== 5. ⚠️ Har kirishda YANGI obyekt ===

  a.metod is a.metod   = False   ⚠️
  a.metod == a.metod   = True    ✅

=== ⚠️ 7. Obyektni ushlab turish ===

  A) Oddiy bog'langan metod:
    zaif1() = <__main__.Kuzatilgan object at 0x0000025FE3E596A0>   ⚠️ hali tirik!

  B) WeakMethod:
      [K2 o'chirildi]
    zaif2()      = None   ✅ o'chirildi
    zaif_metod() = None   ✅ None

Nima ko'rsatdi: 2.1, 2.2, 2.3-bo'limlar.

Misol 2 — Uch xil metod

python
"""Nusxa, sinf va statik metodlar."""

from datetime import date

print("=== 1. Uch tur — solishtirish ===\n")


class Namoyish:
    SINF_ATRIBUTI = "sinf qiymati"

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

    def nusxa_metod(self, x):
        return f"nusxa_metod: self={self.nom}, x={x}"

    @classmethod
    def sinf_metod(cls, x):
        return f"sinf_metod: cls={cls.__name__}, x={x}"

    @staticmethod
    def statik_metod(x):
        return f"statik_metod: x={x}"


n = Namoyish("obyekt")

print(f"  Nusxadan chaqirish:")
for metod in ["nusxa_metod", "sinf_metod", "statik_metod"]:
    print(f"    n.{metod}(1)")
    print(f"      → {getattr(n, metod)(1)}")

print(f"\n  Sinfdan chaqirish:")
for kod, f in [
    ("Namoyish.nusxa_metod(1)",     lambda: Namoyish.nusxa_metod(1)),
    ("Namoyish.nusxa_metod(n, 1)",  lambda: Namoyish.nusxa_metod(n, 1)),
    ("Namoyish.sinf_metod(1)",      lambda: Namoyish.sinf_metod(1)),
    ("Namoyish.statik_metod(1)",    lambda: Namoyish.statik_metod(1)),
]:
    try:
        natija = f"✅ {f()}"
    except TypeError as e:
        natija = f"❌ TypeError: {e}"
    print(f"    {kod:<32} {natija}")

print(f"\n  Sinf lug'atidagi turlar:")
for nom in ["nusxa_metod", "sinf_metod", "statik_metod"]:
    xom = Namoyish.__dict__[nom]
    olingan = getattr(Namoyish, nom)
    print(f"    {nom:<14} __dict__: {type(xom).__name__:<14} "
          f"getattr: {type(olingan).__name__}")


print("\n=== 2. ⭐ @classmethod va meros ===\n")


class Hujjat:
    KENGAYTMA = ".txt"

    def __init__(self, matn: str):
        self.matn = matn

    @classmethod
    def bosh(cls):
        """⭐ cls — HAQIQIY sinf, Hujjat emas."""
        return cls("")

    @classmethod
    def fayldan(cls, nom: str):
        return cls(f"<{nom}{cls.KENGAYTMA} mazmuni>")

    @staticmethod
    def yaroqli_nom(nom: str) -> bool:
        """Sinf holatiga bog'liq emas."""
        return bool(nom) and "/" not in nom and "\\" not in nom

    def __repr__(self):
        return f"{type(self).__name__}({self.matn!r})"


class Markdown(Hujjat):
    KENGAYTMA = ".md"


class Html(Hujjat):
    KENGAYTMA = ".html"


print(f"  {'Sinf':<12} {'bosh()':<22} {'fayldan(\"a\")'}")
print("  " + "─" * 62)
for Sinf in [Hujjat, Markdown, Html]:
    print(f"  {Sinf.__name__:<12} {Sinf.bosh()!r:<22} {Sinf.fayldan('a')!r}")

print(f"""
  ⭐ cls avlod sinfni biladi:
     Markdown.bosh()  → Markdown, Hujjat EMAS
     cls.KENGAYTMA    → '.md'

  ⚠️ Agar Hujjat(...) qattiq yozilganda:

     @classmethod
     def bosh(cls):
         return Hujjat("")      ❌ har doim Hujjat
""")


print("=== 3. Fabrika metodlari ===\n")


class Sana:
    OYLAR = ("yanvar", "fevral", "mart", "aprel", "may", "iyun",
             "iyul", "avgust", "sentabr", "oktabr", "noyabr", "dekabr")

    def __init__(self, kun: int, oy: int, yil: int):
        if not 1 <= oy <= 12:
            raise ValueError(f"Oy 1–12: {oy}")
        if not 1 <= kun <= 31:
            raise ValueError(f"Kun 1–31: {kun}")
        self.kun, self.oy, self.yil = kun, oy, yil

    # ── Fabrikalar ──

    @classmethod
    def satrdan(cls, s: str) -> "Sana":
        """'15.03.2026' formatidan."""
        try:
            kun, oy, yil = map(int, s.strip().split("."))
        except ValueError as e:
            raise ValueError(f"Format 'kk.oo.yyyy' bo'lsin: {s!r}") from e
        return cls(kun, oy, yil)

    @classmethod
    def izodan(cls, s: str) -> "Sana":
        """'2026-03-15' (ISO 8601) formatidan."""
        yil, oy, kun = map(int, s.strip().split("-"))
        return cls(kun, oy, yil)

    @classmethod
    def bugun(cls) -> "Sana":
        d = date.today()
        return cls(d.day, d.month, d.year)

    @classmethod
    def ozbekcha(cls, s: str) -> "Sana":
        """'15-mart 2026' formatidan."""
        qismlar = s.replace("-", " ").split()
        kun = int(qismlar[0])
        oy = cls.OYLAR.index(qismlar[1].lower()) + 1
        yil = int(qismlar[2])
        return cls(kun, oy, yil)

    # ── Statik yordamchilar ──

    @staticmethod
    def kabisami(yil: int) -> bool:
        """Sinf yoki nusxa holatiga bog'liq emas."""
        return yil % 4 == 0 and (yil % 100 != 0 or yil % 400 == 0)

    @staticmethod
    def oy_kunlari(oy: int, yil: int) -> int:
        kunlar = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
        if oy == 2 and Sana.kabisami(yil):
            return 29
        return kunlar[oy - 1]

    # ── Nusxa metodlari ──

    def ozbekcha_matn(self) -> str:
        return f"{self.kun}-{self.OYLAR[self.oy - 1]} {self.yil}"

    def iso(self) -> str:
        return f"{self.yil:04d}-{self.oy:02d}-{self.kun:02d}"

    def __repr__(self):
        return f"Sana({self.kun}, {self.oy}, {self.yil})"


FABRIKALAR = [
    ("Sana(15, 3, 2026)",           lambda: Sana(15, 3, 2026)),
    ("Sana.satrdan('15.03.2026')",  lambda: Sana.satrdan("15.03.2026")),
    ("Sana.izodan('2026-03-15')",   lambda: Sana.izodan("2026-03-15")),
    ("Sana.ozbekcha('15-mart 2026')", lambda: Sana.ozbekcha("15-mart 2026")),
    ("Sana.bugun()",                lambda: Sana.bugun()),
]

for kod, f in FABRIKALAR:
    s = f()
    print(f"  {kod:<34} → {s!r}")
    print(f"  {'':<34}   {s.ozbekcha_matn()} / {s.iso()}")

print(f"\n  Statik metodlar (obyektsiz ishlaydi):")
for yil in [2024, 2025, 2026, 2000, 1900]:
    print(f"    Sana.kabisami({yil}) = {Sana.kabisami(yil)!s:<6} "
          f"fevralda {Sana.oy_kunlari(2, yil)} kun")

print(f"""
  ⭐ NEGA FABRIKA, __init__ da isinstance EMAS:

     ⚠️ def __init__(self, m):
            if isinstance(m, str) and "." in m: ...
            elif isinstance(m, str) and "-" in m: ...
            elif isinstance(m, tuple): ...

        • Nom yo'q — nima qilayotgani ko'rinmaydi
        • Hujjat bitta joyda aralash
        • Yangi format qo'shish — shoxlanish o'sadi
        • Tur ko'rsatkichi murakkab

     ✅ Sana.satrdan(...)   — har biri nomli, hujjatli, testli
""")


print("=== 4. Qachon qaysi ===\n")

print("""
  ┌────────────────┬──────────────────────────────────────────┐
  │ Tur            │ Qachon                                   │
  ├────────────────┼──────────────────────────────────────────┤
  │ Nusxa metod    │ self.x ni o'qiydi yoki o'zgartiradi      │
  │ @classmethod   │ Fabrika (cls(...) qaytaradi)            │
  │                │ Sinf holatini o'zgartiradi (cls.JAMI)   │
  │                │ Meros bilan to'g'ri ishlashi kerak      │
  │ @staticmethod  │ Sinf va nusxa holatiga bog'liq EMAS,    │
  │                │ lekin mantiqan shu sinfga tegishli      │
  └────────────────┴──────────────────────────────────────────┘

  ⚠️ @staticmethod TEKSHIRUVI:

     Agar metod self ham, cls ham ishlatmasa —
     u haqiqatan shu sinfga tegishlimi?

     ✅ Ha:  Sana.kabisami(yil)      — sana mantiqi
     ⚠️ Yo'q: Utils.satr_tozala(s)   — modul funksiyasi bo'lsin
""")


print("=== 5. Deskriptor sifatida ===\n")


class Tekshir:
    def nusxa(self): ...
    @classmethod
    def sinf(cls): ...
    @staticmethod
    def statik(): ...


t = Tekshir()

print(f"  {'Nom':<10} {'__dict__ turi':<16} {'Sinfdan':<18} {'Nusxadan'}")
print("  " + "─" * 62)
for nom in ["nusxa", "sinf", "statik"]:
    xom = type(Tekshir.__dict__[nom]).__name__
    sinfdan = type(getattr(Tekshir, nom)).__name__
    nusxadan = type(getattr(t, nom)).__name__
    print(f"  {nom:<10} {xom:<16} {sinfdan:<18} {nusxadan}")

print(f"""
  ⭐ Uchalasi ham DESKRIPTOR — __get__ ular xatti-harakatini belgilaydi:

     function.__get__(obj, cls)     → MethodType(f, obj)
     classmethod.__get__(obj, cls)  → MethodType(f, cls)
     staticmethod.__get__(obj, cls) → f  (o'zgarishsiz)

  Bu — Pythonning yagona mexanizmi (8.15-darsda batafsil).
""")

qolda_classmethod = Tekshir.__dict__["sinf"].__get__(None, Tekshir)
qolda_staticmethod = Tekshir.__dict__["statik"].__get__(None, Tekshir)
print(f"  classmethod.__get__(None, Tekshir) = {qolda_classmethod}")
print(f"  staticmethod.__get__(None, Tekshir) = {qolda_staticmethod}")

Natijaning muhim qismi:

text
=== 1. Uch tur — solishtirish ===

  Sinfdan chaqirish:
    Namoyish.nusxa_metod(1)          ❌ TypeError: Namoyish.nusxa_metod() missing 1 required positional argument: 'x'
    Namoyish.nusxa_metod(n, 1)       ✅ nusxa_metod: self=obyekt, x=1
    Namoyish.sinf_metod(1)           ✅ sinf_metod: cls=Namoyish, x=1

  Sinf lug'atidagi turlar:
    nusxa_metod    __dict__: function       getattr: function
    sinf_metod     __dict__: classmethod    getattr: method
    statik_metod   __dict__: staticmethod   getattr: function

=== 2. ⭐ @classmethod va meros ===

  Sinf         bosh()                 fayldan("a")
  ──────────────────────────────────────────────────────────────
  Hujjat       Hujjat('')             Hujjat('<a.txt mazmuni>')
  Markdown     Markdown('')           Markdown('<a.md mazmuni>')
  Html         Html('')               Html('<a.html mazmuni>')

=== 3. Fabrika metodlari ===

  Sana.ozbekcha('15-mart 2026')      → Sana(15, 3, 2026)
                                       15-mart 2026 / 2026-03-15

Nima ko'rsatdi: 2.4-bo'lim.

Misol 3 — Metodlarni ish vaqtida o'zgartirish

python
"""Monkey patching, dinamik metodlar va ularning xavflari."""

from types import MethodType
import functools

print("=== 1. Sinfga metod qo'shish ===\n")


class Bosh:
    def __init__(self, q):
        self.q = q


def kopaytir(self, n):
    """Sinfdan tashqarida yozilgan metod."""
    return self.q * n


Bosh.kopaytir = kopaytir                # ⭐ sinfga qo'shildi

b = Bosh(10)
print(f"  Bosh.kopaytir = kopaytir")
print(f"  b.kopaytir(3) = {b.kopaytir(3)}   ✅")
print(f"  type(b.kopaytir) = {type(b.kopaytir).__name__}   ← bog'landi")

# lambda ham
Bosh.kvadrat = lambda self: self.q ** 2
print(f"\n  Bosh.kvadrat = lambda self: self.q ** 2")
print(f"  b.kvadrat() = {b.kvadrat()}   ✅")

# classmethod va staticmethod ham
Bosh.yarat = classmethod(lambda cls, q: cls(q * 2))
Bosh.yordam = staticmethod(lambda: "yordam matni")
print(f"\n  b2 = Bosh.yarat(5) → q = {Bosh.yarat(5).q}")
print(f"  Bosh.yordam() = {Bosh.yordam()!r}")


print("\n=== ⚠️ 2. Nusxaga qo'shish — bog'lanmaydi ===\n")

b2 = Bosh(20)
b2.faqat_menga = kopaytir               # ⚠️ nusxa lug'atiga

print(f"  b2.faqat_menga = kopaytir")
print(f"  type(b2.faqat_menga) = {type(b2.faqat_menga).__name__}   "
      f"← funksiya, method emas")

try:
    b2.faqat_menga(3)
except TypeError as e:
    print(f"  b2.faqat_menga(3) → ❌ TypeError: {e}")

print(f"  b2.faqat_menga(b2, 3) = {b2.faqat_menga(b2, 3)}   "
      f"← self qo'lda")

print(f"\n  ✅ Qo'lda bog'lash:")
b2.togri = MethodType(kopaytir, b2)
print(f"    b2.togri = MethodType(kopaytir, b2)")
print(f"    type(b2.togri) = {type(b2.togri).__name__}")
print(f"    b2.togri(3) = {b2.togri(3)}   ✅")

print(f"""
  ⭐ SABAB: deskriptor protokoli FAQAT sinf lug'atidan
     topilgan obyektlarga qo'llanadi.

     Qidiruv tartibi:
       1. obj.__dict__       ← funksiya bo'lsa, __get__ CHAQIRILMAYDI
       2. type(obj).__mro__  ← funksiya bo'lsa, __get__ CHAQIRILADI
""")


print("=== ⚠️ 3. Callable atribut vs metod ===\n")


class Ishlovchi:
    def __init__(self, f=None):
        self.tashqi = f or (lambda x: x)    # ⚠️ nusxa lug'atida

    def ichki(self, x):                      # ✅ sinf lug'atida
        return x * 2


i = Ishlovchi(lambda x: x + 100)

print(f"  i.ichki(5)  = {i.ichki(5)}     ← self avtomatik")
print(f"  i.tashqi(5) = {i.tashqi(5)}   ← self YO'Q")
print(f"\n  type(i.ichki)  = {type(i.ichki).__name__}")
print(f"  type(i.tashqi) = {type(i.tashqi).__name__}")

print(f"""
  ⭐ Bu — TUZOQ EMAS, tanlov:

     Callback saqlash kerak bo'lsa   → nusxa atributi (self yo'q)
     Obyekt xatti-harakati bo'lsa    → sinf metodi (self bor)

  ⚠️ Lekin aralashtirmang — o'quvchi chalkashadi.
""")


print("=== 4. Monkey patching ===\n")


class Xizmat:
    def sorov(self, url):
        return f"HAQIQIY so'rov: {url}"

    def qayta_ishla(self, url):
        natija = self.sorov(url)
        return f"[{natija}]"


x = Xizmat()
print(f"  Oldin:  {x.qayta_ishla('/api')}")

# Test uchun almashtirish
asl_sorov = Xizmat.sorov
Xizmat.sorov = lambda self, url: f"SOXTA javob: {url}"

print(f"  Patch:  {x.qayta_ishla('/api')}")

Xizmat.sorov = asl_sorov
print(f"  Qaytdi: {x.qayta_ishla('/api')}")

print(f"""
  ✅ QACHON O'RINLI:
     • Testda tashqi bog'liqlikni almashtirish
     • Uchinchi tomon kutubxonasidagi xatoni vaqtincha tuzatish
     • Ishlab chiqish paytida kuzatuv qo'shish

  ⚠️ XAVFLARI:
     • Global ta'sir — butun dastur
     • Nosozlikni topish qiyin ("bu kod qayerdan keldi?")
     • Kutubxona yangilansa — buziladi
     • Bir vaqtli ishda xavfli

  ✅ TESTDA — unittest.mock:

     from unittest.mock import patch

     with patch.object(Xizmat, "sorov", return_value="SOXTA"):
         ...                            # ✅ avtomatik qaytariladi
""")


print("=== 5. Dekorator bilan metod o'rash ===\n")


def olchov(f):
    """Metod chaqiruvlarini sanaydi."""
    @functools.wraps(f)
    def ichki(self, *args, **kwargs):
        ichki.soni += 1
        return f(self, *args, **kwargs)
    ichki.soni = 0
    return ichki


class Kalkulyator:
    def __init__(self):
        self.tarix = []

    @olchov
    def qosh(self, a, b):
        n = a + b
        self.tarix.append(f"{a}+{b}={n}")
        return n

    @olchov
    def kopaytir(self, a, b):
        n = a * b
        self.tarix.append(f"{a}*{b}={n}")
        return n


k = Kalkulyator()
k.qosh(1, 2); k.qosh(3, 4); k.kopaytir(2, 5)

print(f"  k.qosh(1,2), k.qosh(3,4), k.kopaytir(2,5)")
print(f"    qosh chaqiruvlari:      {Kalkulyator.qosh.soni}")
print(f"    kopaytir chaqiruvlari:  {Kalkulyator.kopaytir.soni}")
print(f"    tarix: {k.tarix}")

print(f"\n  ⭐ @functools.wraps saqlaydi:")
print(f"    k.qosh.__name__ = {k.qosh.__name__!r}")
print(f"    k.qosh.__doc__  = {k.qosh.__doc__!r}")

print(f"""
  ⚠️ Hisoblagich SINF darajasida — barcha nusxalar uchun umumiy.
     Nusxa darajasida kerak bo'lsa — self ga yozing:

     def ichki(self, *args, **kwargs):
         self._sonlar[f.__name__] = self._sonlar.get(f.__name__, 0) + 1
""")


print("=== 6. Butun sinfni dekorator bilan ===\n")


def barcha_metodlarga(dekorator):
    """Sinf dekoratori — hamma ommaviy metodni o'raydi."""
    def sinf_dekorator(sinf):
        for nom, qiymat in list(vars(sinf).items()):
            if callable(qiymat) and not nom.startswith("_"):
                setattr(sinf, nom, dekorator(qiymat))
        return sinf
    return sinf_dekorator


def jurnal(f):
    @functools.wraps(f)
    def ichki(self, *args, **kwargs):
        print(f"      → {type(self).__name__}.{f.__name__}{args}")
        natija = f(self, *args, **kwargs)
        print(f"      ← {natija!r}")
        return natija
    return ichki


@barcha_metodlarga(jurnal)
class Xizmat2:
    def bir(self, x):
        return x + 1

    def ikki(self, x):
        return x * 2

    def _ichki(self, x):        # _ bilan — o'ralmaydi
        return x


x2 = Xizmat2()
print(f"  x2.bir(5):")
x2.bir(5)
print(f"  x2.ikki(5):")
x2.ikki(5)
print(f"  x2._ichki(5) = {x2._ichki(5)}   ← jurnal yo'q (_ prefiks)")

print(f"""
  ⭐ Bu naqsh ishlatiladi:
     • Jurnal (logging)
     • Vaqt o'lchash (profiling)
     • Tranzaksiya boshqaruvi
     • Kirish nazorati

  ⚠️ vars(sinf) — FAQAT o'sha sinfning metodlari.
     Meros olganlarni o'ramaydi.
""")

Natijaning muhim qismi:

text
=== ⚠️ 2. Nusxaga qo'shish — bog'lanmaydi ===

  type(b2.faqat_menga) = function   ← funksiya, method emas
  b2.faqat_menga(3) → ❌ TypeError: kopaytir() missing 1 required
                         positional argument: 'n'
  b2.faqat_menga(b2, 3) = 60   ← self qo'lda

  ✅ Qo'lda bog'lash:
    type(b2.togri) = method
    b2.togri(3) = 60   ✅

=== 5. Dekorator bilan metod o'rash ===

    qosh chaqiruvlari:      2
    kopaytir chaqiruvlari:  1
    tarix: ['1+2=3', '3+4=7', '2*5=10']

=== 6. Butun sinfni dekorator bilan ===

  x2.bir(5):
      → Xizmat2.bir(5,)
      ← 6

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Amaliy: hodisa tizimi

python
"""Metodlar va bog'lanish — to'liq amaliy misol."""

from __future__ import annotations

import weakref
from collections import defaultdict
from types import MethodType
from typing import Callable, Any

print("=== HODISA TIZIMI ===\n")


class HodisaAvtobusi:
    """Kuzatuvchi (observer) naqshi.

    ⭐ Bog'langan metodlarni to'g'ri saqlaydi:
       • WeakMethod — obyekt o'chganda obuna ham o'chadi
       • Oddiy funksiyalar uchun weakref.ref
       • Bir xil ishlovchini ikki marta qo'shmaydi
    """

    def __init__(self) -> None:
        self._obunalar: dict[str, list] = defaultdict(list)
        self._jurnal: list[str] = []

    def _zaif(self, ishlovchi: Callable) -> tuple:
        """Ishlovchining zaif havolasini va identifikatorini qaytaradi."""
        if isinstance(ishlovchi, MethodType):
            return weakref.WeakMethod(ishlovchi), (
                id(ishlovchi.__self__), ishlovchi.__func__.__qualname__
            )
        return weakref.ref(ishlovchi), (id(ishlovchi),)

    def obuna(self, hodisa: str, ishlovchi: Callable) -> None:
        zaif, kalit = self._zaif(ishlovchi)
        mavjud = [k for _, k in self._obunalar[hodisa]]
        if kalit in mavjud:
            self._jurnal.append(f"takror: {hodisa}")
            return
        self._obunalar[hodisa].append((zaif, kalit))
        self._jurnal.append(f"obuna: {hodisa}")

    def bekor(self, hodisa: str, ishlovchi: Callable) -> bool:
        _, kalit = self._zaif(ishlovchi)
        oldin = len(self._obunalar[hodisa])
        self._obunalar[hodisa] = [
            (z, k) for z, k in self._obunalar[hodisa] if k != kalit
        ]
        ochirildi = oldin != len(self._obunalar[hodisa])
        self._jurnal.append(f"bekor: {hodisa} → {ochirildi}")
        return ochirildi

    def yubor(self, hodisa: str, **malumot: Any) -> int:
        """Hodisani yuboradi. O'lgan obunalarni tozalaydi."""
        tirik = []
        yuborildi = 0
        for zaif, kalit in self._obunalar[hodisa]:
            ishlovchi = zaif()
            if ishlovchi is None:
                continue                    # ⭐ obyekt o'lgan
            tirik.append((zaif, kalit))
            ishlovchi(**malumot)
            yuborildi += 1
        self._obunalar[hodisa] = tirik
        return yuborildi

    def statistika(self) -> dict[str, int]:
        return {h: len(o) for h, o in self._obunalar.items() if o}


class Foydalanuvchi:
    def __init__(self, ism: str, avtobus: HodisaAvtobusi):
        self.ism = ism
        self._avtobus = avtobus
        self.xabarlar: list[str] = []
        avtobus.obuna("xabar", self.xabar_keldi)
        avtobus.obuna("ogohlantirish", self.ogohlantirish)

    def xabar_keldi(self, matn: str = "", kimdan: str = "") -> None:
        self.xabarlar.append(f"{kimdan}: {matn}")
        print(f"    [{self.ism}] xabar: {matn}")

    def ogohlantirish(self, matn: str = "", **_) -> None:
        print(f"    [{self.ism}] ⚠️  {matn}")

    def chiq(self) -> None:
        self._avtobus.bekor("xabar", self.xabar_keldi)
        self._avtobus.bekor("ogohlantirish", self.ogohlantirish)


print("1. Obuna va yuborish:\n")

avtobus = HodisaAvtobusi()
aziz = Foydalanuvchi("Aziz", avtobus)
malika = Foydalanuvchi("Malika", avtobus)

print(f"  Statistika: {avtobus.statistika()}\n")

n = avtobus.yubor("xabar", matn="Salom!", kimdan="Server")
print(f"\n  Yuborildi: {n} ta ishlovchiga")


print("\n\n2. ⭐ Takror obunani to'sish:\n")

print(f"  Oldin: {len(avtobus._obunalar['xabar'])} ta")
avtobus.obuna("xabar", aziz.xabar_keldi)        # ⚠️ boshqa obyekt!
avtobus.obuna("xabar", aziz.xabar_keldi)
print(f"  aziz.xabar_keldi ni 2 marta qo'shdik")
print(f"  Keyin: {len(avtobus._obunalar['xabar'])} ta   ✅ takrorlanmadi")

print(f"""
  ⭐ SABAB: aziz.xabar_keldi har safar YANGI MethodType,
     lekin biz (id(__self__), __qualname__) bo'yicha
     solishtiryapmiz — shuning uchun takror aniqlanadi.
""")


print("=== 3. Bekor qilish ===\n")

print(f"  Oldin: {avtobus.statistika()}")
aziz.chiq()
print(f"  aziz.chiq() dan keyin: {avtobus.statistika()}")

print(f"\n  Yuborish:")
n = avtobus.yubor("xabar", matn="Ikkinchi xabar", kimdan="Server")
print(f"  Yuborildi: {n} ta   ← faqat Malika")


print("\n\n4. ⭐ Obyekt o'chganda avtomatik tozalash:\n")

import gc


class Vaqtinchalik:
    def __init__(self, nom, avtobus):
        self.nom = nom
        avtobus.obuna("test", self.ishla)

    def ishla(self, **_):
        print(f"    [{self.nom}] ishladi")


v1 = Vaqtinchalik("V1", avtobus)
v2 = Vaqtinchalik("V2", avtobus)

print(f"  Ikki obunachi:")
avtobus.yubor("test")
print(f"  Obunalar: {avtobus.statistika().get('test')}")

print(f"\n  del v1:")
del v1
gc.collect()

print(f"  Yuborish:")
n = avtobus.yubor("test")
print(f"  Yuborildi: {n} ta")
print(f"  Obunalar: {avtobus.statistika().get('test')}   "
      f"✅ o'lgan obuna avtomatik tozalandi")

print(f"""
  ⭐ WeakMethod bo'lmasa:
     • avtobus v1 ga havolani ushlab turardi
     • v1 hech qachon o'chmasdi
     • XOTIRA OQISHI (memory leak)

  Bu — GUI va hodisa tizimlaridagi klassik xato.
""")


print("=== 5. Turli ishlovchi turlari ===\n")


def oddiy_funksiya(matn: str = "", **_):
    print(f"    [funksiya] {matn}")


class Sinf:
    @staticmethod
    def statik(matn: str = "", **_):
        print(f"    [statik] {matn}")

    @classmethod
    def sinf_metod(cls, matn: str = "", **_):
        print(f"    [{cls.__name__}.sinf_metod] {matn}")


class Chaqiriladigan:
    """__call__ bilan — obyekt funksiya kabi."""
    def __init__(self, nom):
        self.nom = nom

    def __call__(self, matn: str = "", **_):
        print(f"    [{self.nom} __call__] {matn}")


avtobus2 = HodisaAvtobusi()
ch = Chaqiriladigan("Chaqiriladigan")

# Ishlovchilarni tirik ushlash uchun havola saqlaymiz
saqlangan = [oddiy_funksiya, Sinf.statik, Sinf.sinf_metod, ch]

for h in saqlangan:
    avtobus2.obuna("hammasi", h)

print(f"  4 xil ishlovchi obuna bo'ldi:")
n = avtobus2.yubor("hammasi", matn="Test xabar")
print(f"\n  Yuborildi: {n} ta")

print(f"\n  {'Ishlovchi':<26} {'type()':<16} {'zaif havola'}")
print("  " + "─" * 60)
for h in saqlangan:
    turi = type(h).__name__
    zaif_turi = ("WeakMethod" if isinstance(h, MethodType)
                 else "ref")
    nom = getattr(h, "__qualname__", type(h).__name__)
    print(f"  {nom:<26} {turi:<16} {zaif_turi}")


print("\n\n6. Jurnal:\n")

for q in avtobus._jurnal[:10]:
    print(f"  {q}")
print(f"  ... jami {len(avtobus._jurnal)} yozuv")

print(f"""

  ⭐ BU MISOLDA KO'RSATILGAN:

     1. a.metod har safar YANGI MethodType
        → identifikator bo'yicha solishtirish kerak

     2. Bog'langan metod obyektni USHLAB TURADI
        → WeakMethod bilan hal qilindi

     3. Turli ishlovchi turlari (funksiya, statik,
        sinf metod, __call__) — bir xil ishlatiladi

     4. isinstance(h, MethodType) bilan bog'langan
        metodni ajratish

     5. O'lgan obunalarni yuborish paytida tozalash
""")

Natijaning muhim qismi:

text
1. Obuna va yuborish:

  Statistika: {'xabar': 2, 'ogohlantirish': 2}

    [Aziz] xabar: Salom!
    [Malika] xabar: Salom!

  Yuborildi: 2 ta ishlovchiga

2. ⭐ Takror obunani to'sish:

  Oldin: 2 ta
  aziz.xabar_keldi ni 2 marta qo'shdik
  Keyin: 2 ta   ✅ takrorlanmadi

4. ⭐ Obyekt o'chganda avtomatik tozalash:

  del v1:
  Yuborish:
    [V2] ishladi
  Yuborildi: 1 ta
  Obunalar: 1   ✅ o'lgan obuna avtomatik tozalandi

Nima ko'rsatdi: 2.2, 2.3, 2.4-bo'limlar.


5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"self — kalit so'z" Oddiy parametr nomi (kelishuv)
"Metod nusxada saqlanadi" Sinf lug'atida funksiya, metod kirish paytida yasaladi
"a.metod is a.metod — True" Har kirishda yangi MethodType
"a.metod = fn metod qo'shadi" Bog'lanmaydi — MethodType kerak
"@staticmethod = modul funksiyasi" Nom fazosi va meros farqi bor
"Metodni sinfdan tashqarida yozib bo'lmaydi" Bo'ladi — A.f = fn
"Bog'langan metod obyektni ushlamaydi" Ushlaydi — WeakMethod kerak
"A.metod(a) — noto'g'ri" To'g'ri, a.metod() bilan bir xil

6. Keng tarqalgan xatolar va yechimlari

1. self unutish

python
def metod():                    # ❌
def metod(self):                # ✅

2. Nusxaga funksiya biriktirish

python
a.f = fn                        # ⚠️ self olmaydi
a.f = MethodType(fn, a)         # ✅

3. Callback'ni is bilan izlash

python
if cb is a.metod: ...           # ⚠️ har doim False
if cb == a.metod: ...           # ✅
self._cb = a.metod              # ✅ eng ishonchli

4. Kuzatuvchida kuchli havola

python
self._kuzatuvchilar.append(o.metod)             # ⚠️ o o'chmaydi
self._kuzatuvchilar.append(WeakMethod(o.metod)) # ✅

5. @staticmethod unutish

python
class A:
    def yordam(x):              # ⚠️ x — aslida self
        return x * 2
    @staticmethod
    def yordam(x):              # ✅
        return x * 2

6. @classmethod da sinfni qattiq yozish

python
@classmethod
def yarat(cls):
    return Ota()                # ⚠️ meros buziladi
    return cls()                # ✅

7. Dekoratorda wraps unutish

python
def d(f):
    def ichki(self, *a): ...    # ⚠️ __name__ yo'qoladi
    @functools.wraps(f)         # ✅
    def ichki(self, *a): ...

8. Monkey patch'ni qaytarmaslik

python
A.f = soxta                     # ⚠️ butun dasturda qoladi
with patch.object(A, "f", soxta):   # ✅ avtomatik qaytariladi

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 7.11-dars (o'tilgan): funksiya — birinchi darajali obyekt
  • 8.15-dars: @property — deskriptor protokolining davomi
  • 8.16-dars: @staticmethod va @classmethod to'liq
  • 10-qism: dekoratorlar va functools.wraps
  • 17-qism: unittest.mock.patch — xavfsiz monkey patching
  • GUI/asyncio: callback va WeakMethod
  • CPython: Objects/classobject.c, Objects/funcobject.c

8. Eng yaxshi amaliyotlar

  1. self va cls nomlarini o'zgartirmang. PEP 8 va butun jamoa shunga o'rgangan.

  2. Metod nomi — fe'l. saqla(), hisobla(), tekshir().

  3. Callback havolasini saqlang. self._ishlovchi = self.metod — bir marta.

  4. Kuzatuvchilarda WeakMethod. Xotira oqishining oldini oladi.

  5. cls() yozing, sinf nomini emas. Meros to'g'ri ishlashi uchun.

  6. @staticmethod ni tekshiring. self ham, cls ham kerak bo'lmasa — sinfga tegishlimi?

  7. Monkey patch faqat testda. unittest.mock.patch bilan.

  8. Dekoratorda functools.wraps. Nom, docstring va imzo saqlansin.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
1.  class A:
        def f(self): pass
    a = A()
    print(a.f is a.f, a.f == a.f)
2.  class A:
        def f(self): return 1
    print(type(A.f).__name__, type(A().f).__name__)
3.  class A:
        def f(self, x): return x
    a = A()
    print(A.f(a, 5))
4.  class A:
        def f(self, x): return x
    a = A()
    print(a.f.__self__ is a)
5.  class A: pass
    A.f = lambda self: 42
    print(A().f())
6.  class A: pass
    a = A()
    a.f = lambda self: 42
    try: print(a.f())
    except TypeError as e: print("TypeError")
7.  class A:
        @staticmethod
        def f(x): return x * 2
    print(A.f(3), A().f(3))
8.  class A:
        @classmethod
        def f(cls): return cls.__name__
    class B(A): pass
    print(A.f(), B.f(), B().f())
9.  class A:
        def f(self): return 1
    print(A.__dict__["f"].__get__(A(), A)())
10. class A:
        def f(bu): return "ok"
    print(A().f())
11. class A:
        def f(self): pass
    print(len({A().f, A().f}))
12. class A:
        def f(self): pass
    a = A()
    print(len({a.f, a.f}))
Javoblar
  1. False True — yangi obyekt, lekin __eq__ bor
  2. function method
  3. 5 — self qo'lda uzatildi
  4. True
  5. 42 — sinfga qo'shilgan, bog'lanadi
  6. TypeError — nusxadagi funksiya bog'lanmaydi
  7. 6 6 — statik metod ikkalasidan ishlaydi
  8. A B B — cls haqiqiy sinf
  9. 1 — deskriptor qo'lda chaqirildi
  10. ok — self kalit so'z emas
  11. 2 — ikki turli obyekt
  12. 1 — bir obyekt, __eq__ va __hash__ bor

Vazifa 2: Xatolarni tuzating

python
1.  class A:
        def f(): return 1
2.  a.f = kopaytir
3.  tugma.ochirish(o.bosildi)   # qo'shilgani boshqa obyekt edi
4.  self._kuzatuvchilar.append(o.metod)
5.  class A:
        @classmethod
        def yarat(cls): return A()
6.  class A:
        def yordam(x): return x * 2      # self ishlatilmaydi
7.  def dek(f):
        def ichki(self, *a): return f(self, *a)
        return ichki
8.  A.sorov = soxta_sorov      # test tugagach qaytarilmadi
Javoblar
python
1.  def f(self): return 1
2.  a.f = MethodType(kopaytir, a)
3.  self._ishlovchi = o.bosildi  saqlang, o'shani o'chiring
4.  weakref.WeakMethod(o.metod)
5.  return cls()
6.  @staticmethod qo'shing
7.  @functools.wraps(f) qo'shing
8.  with unittest.mock.patch.object(A, "sorov", soxta_sorov):

Vazifa 3: Metod tahlilchisi

Vosita yozing:

  1. Sinf metodlarini turlarga ajratsin (nusxa/sinf/statik/property)
  2. Har biri uchun imzo va docstring holatini ko'rsatsin
  3. self ishlatmaydigan nusxa metodlarni topsin (@staticmethod taklifi)
  4. cls() o'rniga sinf nomi yozilganini topsin
  5. Meros olingan va o'z metodlarini ajratsin

Vazifa 4: Zaif kuzatuvchi

WeakMethod bilan hodisa tizimi yozing:

  1. Bog'langan metod, funksiya va __call__ obyektlarini qabul qilsin
  2. Takror obunani to'ssin
  3. O'lgan obunalarni avtomatik tozalasin
  4. Ustuvorlik (priority) qo'llab-quvvatlasin
  5. Bir ishlovchi xato bersa boshqalari ishlashda davom etsin

Vazifa 5: Zanjirli qurilma

self qaytaruvchi sinf yozing:

  1. qosh(), filtrla(), saralash(), cheklash() — hammasi self
  2. natija() — yakuniy ro'yxat
  3. Har amal jurnalga yozilsin
  4. __repr__ joriy holatni ko'rsatsin
  5. O'zgarmas variantini ham yozing (har amal yangi obyekt)

Vazifa 6: Dinamik metodlar

Sinf yozing:

  1. __getattr__ bilan mavjud bo'lmagan metodni yaratsin
  2. top_ism, top_email → _top("ism") ga aylansin
  3. Yaratilgan metodni keshlasin (setattr)
  4. Noto'g'ri nom uchun aniq xato bersin
  5. dir() ni to'g'ri qaytarsin (__dir__)

Vazifa 7: O'ylash

Nega Python a.metod uchun bog'langan metodni keshlamaydi — nega har safar yangi obyekt yaratadi?

Javob

Chunki keshlash aylanma havola yaratadi va xotira sarfini oshiradi, foydasi esa kam.

1. Muammoning kattaligi

python
class A:
    def f(self): ...
    def g(self): ...
    def h(self): ...


a = A()
a.f                             # yangi MethodType
a.f                             # yana yangi

Agar keshlansa, a.__dict__ da:

python
a.__dict__ = {
    "f": <bound method>,
    "g": <bound method>,
    "h": <bound method>,
}

2. Aylanma havola

a.__dict__["f"] → MethodType
                    ↓ __self__
                    a

Ya'ni a o'ziga havola qiladi. Bu:

  • Havolalar hisobi (refcount) hech qachon nolga tushmaydi
  • Obyektni faqat axlat yig'uvchi (gc) o'chira oladi
  • __del__ kechikadi yoki umuman chaqirilmaydi

CPython aylanma havolani hal qiladi, lekin bu qimmat:

python
import gc
gc.collect()                    # butun to'plamni skanerlash

Har obyekt aylanma havolali bo'lsa — gc doim ishlaydi.

3. Xotira

MethodType obyekti — 64 bayt (CPython 3.12, 64-bit):

python
import sys
class A:
    def f(self): ...
    def g(self): ...

sys.getsizeof(A().f)            # 64

10 metodli sinf, 100 000 nusxa:

100_000 × 10 × 64 bayt = 64 MB

Faqat metod obyektlari uchun. Kesh bo'lmasa — 0 bayt.

Bundan tashqari, __dict__ ham kattalashadi:

python
# Keshsiz
a.__dict__                      # {'x': 1}           — 104 bayt

# Kesh bilan (10 metod)
a.__dict__                      # {'x': 1, 'f': ..., }  — 640+ bayt

4. Yaratish arzon

MethodType yaratish — ikki ko'rsatkichni nusxalash:

c
/* CPython: Objects/classobject.c */
PyObject *PyMethod_New(PyObject *func, PyObject *self) {
    PyMethodObject *im = free_list;     /* bo'sh ro'yxatdan */
    ...
    im->im_func = Py_NewRef(func);
    im->im_self = Py_NewRef(self);
    ...
}

CPython bo'sh ro'yxat (free list) ishlatadi — o'chirilgan MethodType obyektlari qayta ishlatiladi. Ya'ni malloc ham chaqirilmaydi.

Tezlik:

python
import timeit

class A:
    def f(self): pass

a = A()
timeit.timeit("a.f", globals=globals(), number=10_000_000)
# ~0.6s → 60 nanosekund

60 ns — bu lug'at qidiruvidan bir oz sekinroq. Kesh bunga arzimaydi.

5. To'g'ri holat buzilardi

python
class A:
    def f(self): return 1


a = A()
m = a.f                         # keshlangan bo'lardi

A.f = lambda self: 2            # metod almashtirildi

a.f()                           # ⚠️ kesh bo'lsa hali 1 qaytarardi

Keshni bekor qilish uchun A.__setattr__ har o'zgarishda barcha nusxalarning keshini tozalashi kerak bo'lardi — bu mumkin emas (sinf nusxalarni bilmaydi).

6. Python 3.7+ optimizatsiyasi

CPython bu muammoni boshqacha hal qildi — LOAD_METHOD / CALL_METHOD bayt-kodi:

python
import dis

def f(a):
    return a.metod(1)

dis.dis(f)
  LOAD_FAST                a
  LOAD_METHOD              metod        ← MethodType YARATMAYDI
  LOAD_CONST               1
  CALL_METHOD              1

LOAD_METHOD bog'langan metod obyektini umuman yaratmaydi — funksiya va self ni to'g'ridan-to'g'ri stekka qo'yadi va CALL_METHOD ularni birga chaqiradi.

Ya'ni eng ko'p uchraydigan holat (a.metod(...) — kirish va darhol chaqiruv) uchun xarajat nolga tushirilgan.

MethodType faqat metod saqlanganda yaratiladi:

python
a.metod(1)                      # ✅ MethodType yaratilmaydi (LOAD_METHOD)
m = a.metod                     # ⚠️ MethodType yaratiladi
callback(a.metod)               # ⚠️ yaratiladi

Python 3.11 da bu yanada yaxshilandi (PRECALL/CALL va inline caching).

7. Boshqa tillar

Til Yondashuv
Python Har safar yasaydi (LOAD_METHOD bilan optimizatsiya)
Java Metod havolasi (obj::metod) — har safar yangi lambda
C# Delegate — har safar yangi
JavaScript this bog'lanmaydi — bind() kerak
Ruby obj.method(:f) — aniq so'ralganda

Java da ham:

java
Runnable r1 = obj::metod;
Runnable r2 = obj::metod;
r1 == r2                        // false — Python bilan bir xil

8. Amaliy oqibatlari

Bilish kerak bo'lgan uchta narsa:

python
# 1. is bilan solishtirmang
if cb is a.metod: ...           # ❌ har doim False
if cb == a.metod: ...           # ✅

# 2. Callback havolasini saqlang
class A:
    def __init__(self, tugma):
        self._ishlovchi = self.bosildi      # ✅ bir marta
        tugma.qoshish(self._ishlovchi)

    def yop(self, tugma):
        tugma.ochirish(self._ishlovchi)     # ✅ aynan o'sha

# 3. Tsiklda saqlang
for _ in range(1_000_000):
    a.metod()                   # ✅ LOAD_METHOD — tez

m = a.metod                     # ✅ bir marta yaratildi
for _ in range(1_000_000):
    m()                         # ✅ ham tez

9. functools.partialmethod bilan solishtirish

Agar bog'langan metodni saqlash kerak bo'lsa va u qayta-qayta ishlatilsa:

python
from functools import partial

class A:
    def f(self, x, y): return x + y

a = A()
qismiy = partial(a.f, 10)       # self VA x bog'landi
qismiy(5)                       # 15

partial — bu ham obyekt, lekin bir marta yaratiladi.

Xulosa: kesh yo'q, chunki:

  1. Aylanma havola — gc yuki va __del__ muammosi
  2. Xotira — 100k nusxa × 10 metod = 64 MB
  3. Yaratish arzon — 60 ns, free list bilan
  4. To'g'rilik — metod almashtirilsa kesh eskirardi
  5. LOAD_METHOD — eng ko'p uchraydigan holatda umuman yaratilmaydi

Ya'ni muammo keshlash bilan emas, bayt-kod darajasida hal qilingan — bu Pythonning odatiy yondashuvi.

Nimani mustahkamlaydi: 2.2, 2.3-bo'limlar.


Xulosa

Bu darsda metodlar va self mexanizmini o'rgandik.

Eng muhim uch fikr:

  1. Metod — funksiya + obyekt, va u kirish paytida yasaladi. Sinf lug'atida oddiy funksiya turadi; a.metod yozilganda funksiyaning __get__ deskriptori chaqiriladi va MethodType(funksiya, a) qaytadi. Shuning uchun a.metod(x), A.metod(a, x) va a.metod.__func__(a, x) — aynan bir narsa.

  2. a.metod is a.metod — False. Har kirishda yangi obyekt yaratiladi (__eq__ bor, shuning uchun == ishlaydi). Bu callback'ni o'chirishda muammo tug'diradi — havolani bir marta saqlang. Bog'langan metod obyektni ushlab turadi, shuning uchun kuzatuvchi ro'yxatlarida weakref.WeakMethod kerak.

  3. Uch metod turi — bir mexanizm. function, classmethod va staticmethod — uchalasi ham deskriptor; ular faqat __get__ da nima qaytarishi bilan farq qiladi. @classmethod da cls() yozing, sinf nomini emas — meros shunda to'g'ri ishlaydi.

Keyingi darsda sinf va nusxa atributlarining farqini chuqurroq ko'ramiz: qachon qaysi biri, umumiy holat tuzoqlari va xotira ta'siri.

OOP · 4-dars yakunlandi

8.4-dars: Metodlar va self

32 daqvaqt
0belgi
Keyingi dars: 8.5-dars: Klass va nusxa atributlari
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0