8.4-dars: Metodlar va self
8-QISM — OBYEKTGA YO'NALTIRILGAN DASTURLASH · 4-dars
1. Kirish va motivatsiya
Bu uch qator bir xil ish qiladi:
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:
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 # TrueSavollar:
a.salomyozilganda aniq nima yaratiladi?selfqayerdan keladi?- Nega
a.salom is a.salom—False? - Metodni sinfdan tashqarida yozib bo'ladimi?
Bu darsda:
- Bog'langan metod (bound method) — qanday yaratiladi
selfuzatilish 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
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
a = A()
a.metod # <bound method A.metod of <A object at 0x...>>Nima bo'ldi:
a.metod—a.__dict__dametodyo'qtype(a).__mro__da qidiriladi →A.__dict__["metod"]topildi- Topilgan obyekt funksiya, ya'ni deskriptor (
__get__bor) - Python
A.__dict__["metod"].__get__(a, A)chaqiradi - Natija —
MethodTypeobyekti: funksiya +a
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) # 10Bog'langan metod ikki narsani saqlaydi:
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
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:
tugma.qoshish(a.bosildi) # bir obyekt
tugma.ochirish(a.bosildi) # ⚠️ BOSHQA obyekt — topilmaydi!Yechim — havolani saqlash:
self._ishlovchi = a.bosildi
tugma.qoshish(self._ishlovchi)
tugma.ochirish(self._ishlovchi) # ✅Tuzoq 2 — to'plamga qo'shish:
kuzatuvchilar = set()
kuzatuvchilar.add(a.bosildi)
kuzatuvchilar.add(a.bosildi)
len(kuzatuvchilar) # 1 ✅ — __hash__ va __eq__ borBu ishlaydi, chunki MethodType da __eq__ va __hash__ aniqlangan (__func__ va __self__ bo'yicha).
Tuzoq 3 — obyekt o'chmaydi:
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
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 |
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:
class Ota:
@classmethod
def yarat(cls):
return cls() # ⭐ HAQIQIY sinf
class Bola(Ota):
pass
type(Bola.yarat()) # Bola ✅ — Ota emasBatafsil — 8.16-dars.
2.5. Metodlarni ish vaqtida qo'shish
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:
a2 = A()
a2.faqat_menga = yangi # nusxa lug'atiga
a2.faqat_menga(5) # ❌ TypeError: yangi() missing 1 argumentSabab: deskriptor protokoli faqat sinf lug'atidan topilgan obyektlarga qo'llanadi. Nusxa lug'atidagi funksiya — oddiy funksiya.
Qo'lda bog'lash:
from types import MethodType
a2.faqat_menga = MethodType(yangi, a2)
a2.faqat_menga(5) # 15 ✅Callable atribut tuzog'i:
class A:
def __init__(self):
self.ishlovchi = lambda x: x * 2 # ⚠️ nusxa lug'atida
a = A()
a.ishlovchi(5) # 10 — self uzatilmaydiBu ba'zan kerak (callback saqlash), lekin metoddan farqini bilish shart.
2.6. self — kelishuv, kalit so'z emas
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:
# ⚠️ 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:
h.saqla() # ✅
h.saqlash() # ⚠️
h.hujjat_saqlash_amali() # ⚠️ uzunQaytarish qiymati — bir xil turda:
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 turself ni qaytarish — zanjir uchun:
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
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
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
A.yangi = fn ✅ bog'lanadi
a.yangi = fn ⚠️ bog'lanmaydi
a.yangi = MethodType(fn, a) ✅ qo'lda bog'lashTuzoqlar
a.metod is a.metod False — callback o'chirishda muammo
a.metod obyektni ushlaydi del a — o'chmaydi (WeakMethod kerak)
nusxadagi lambda self olmaydi4. Batafsil misollar
Misol 1 — Bog'langan metod ichkarisi
"""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:
=== 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 ✅ NoneNima ko'rsatdi: 2.1, 2.2, 2.3-bo'limlar.
Misol 2 — Uch xil metod
"""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:
=== 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-15Nima ko'rsatdi: 2.4-bo'lim.
Misol 3 — Metodlarni ish vaqtida o'zgartirish
"""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:
=== ⚠️ 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,)
← 6Nima ko'rsatdi: 2.5-bo'lim.
Misol 4 — Amaliy: hodisa tizimi
"""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:
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 tozalandiNima 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
def metod(): # ❌
def metod(self): # ✅2. Nusxaga funksiya biriktirish
a.f = fn # ⚠️ self olmaydi
a.f = MethodType(fn, a) # ✅3. Callback'ni is bilan izlash
if cb is a.metod: ... # ⚠️ har doim False
if cb == a.metod: ... # ✅
self._cb = a.metod # ✅ eng ishonchli4. Kuzatuvchida kuchli havola
self._kuzatuvchilar.append(o.metod) # ⚠️ o o'chmaydi
self._kuzatuvchilar.append(WeakMethod(o.metod)) # ✅5. @staticmethod unutish
class A:
def yordam(x): # ⚠️ x — aslida self
return x * 2
@staticmethod
def yordam(x): # ✅
return x * 26. @classmethod da sinfni qattiq yozish
@classmethod
def yarat(cls):
return Ota() # ⚠️ meros buziladi
return cls() # ✅7. Dekoratorda wraps unutish
def d(f):
def ichki(self, *a): ... # ⚠️ __name__ yo'qoladi
@functools.wraps(f) # ✅
def ichki(self, *a): ...8. Monkey patch'ni qaytarmaslik
A.f = soxta # ⚠️ butun dasturda qoladi
with patch.object(A, "f", soxta): # ✅ avtomatik qaytariladi7. 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:
@staticmethodva@classmethodto'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
selfvaclsnomlarini o'zgartirmang. PEP 8 va butun jamoa shunga o'rgangan.Metod nomi — fe'l.
saqla(),hisobla(),tekshir().Callback havolasini saqlang.
self._ishlovchi = self.metod— bir marta.Kuzatuvchilarda
WeakMethod. Xotira oqishining oldini oladi.cls()yozing, sinf nomini emas. Meros to'g'ri ishlashi uchun.@staticmethodni tekshiring.selfham,clsham kerak bo'lmasa — sinfga tegishlimi?Monkey patch faqat testda.
unittest.mock.patchbilan.Dekoratorda
functools.wraps. Nom, docstring va imzo saqlansin.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
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
False True— yangi obyekt, lekin__eq__borfunction method5—selfqo'lda uzatildiTrue42— sinfga qo'shilgan, bog'lanadiTypeError— nusxadagi funksiya bog'lanmaydi6 6— statik metod ikkalasidan ishlaydiA B B—clshaqiqiy sinf1— deskriptor qo'lda chaqirildiok—selfkalit so'z emas2— ikki turli obyekt1— bir obyekt,__eq__va__hash__bor
Vazifa 2: Xatolarni tuzating
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 qaytarilmadiJavoblar
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:
- Sinf metodlarini turlarga ajratsin (nusxa/sinf/statik/property)
- Har biri uchun imzo va docstring holatini ko'rsatsin
selfishlatmaydigan nusxa metodlarni topsin (@staticmethodtaklifi)cls()o'rniga sinf nomi yozilganini topsin- Meros olingan va o'z metodlarini ajratsin
Vazifa 4: Zaif kuzatuvchi
WeakMethod bilan hodisa tizimi yozing:
- Bog'langan metod, funksiya va
__call__obyektlarini qabul qilsin - Takror obunani to'ssin
- O'lgan obunalarni avtomatik tozalasin
- Ustuvorlik (priority) qo'llab-quvvatlasin
- Bir ishlovchi xato bersa boshqalari ishlashda davom etsin
Vazifa 5: Zanjirli qurilma
self qaytaruvchi sinf yozing:
qosh(),filtrla(),saralash(),cheklash()— hammasiselfnatija()— yakuniy ro'yxat- Har amal jurnalga yozilsin
__repr__joriy holatni ko'rsatsin- O'zgarmas variantini ham yozing (har amal yangi obyekt)
Vazifa 6: Dinamik metodlar
Sinf yozing:
__getattr__bilan mavjud bo'lmagan metodni yaratsintop_ism,top_email→_top("ism")ga aylansin- Yaratilgan metodni keshlasin (
setattr) - Noto'g'ri nom uchun aniq xato bersin
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
class A:
def f(self): ...
def g(self): ...
def h(self): ...
a = A()
a.f # yangi MethodType
a.f # yana yangiAgar keshlansa, a.__dict__ da:
a.__dict__ = {
"f": <bound method>,
"g": <bound method>,
"h": <bound method>,
}2. Aylanma havola
a.__dict__["f"] → MethodType
↓ __self__
aYa'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:
import gc
gc.collect() # butun to'plamni skanerlashHar obyekt aylanma havolali bo'lsa — gc doim ishlaydi.
3. Xotira
MethodType obyekti — 64 bayt (CPython 3.12, 64-bit):
import sys
class A:
def f(self): ...
def g(self): ...
sys.getsizeof(A().f) # 6410 metodli sinf, 100 000 nusxa:
100_000 × 10 × 64 bayt = 64 MBFaqat metod obyektlari uchun. Kesh bo'lmasa — 0 bayt.
Bundan tashqari, __dict__ ham kattalashadi:
# Keshsiz
a.__dict__ # {'x': 1} — 104 bayt
# Kesh bilan (10 metod)
a.__dict__ # {'x': 1, 'f': ..., } — 640+ bayt4. Yaratish arzon
MethodType yaratish — ikki ko'rsatkichni nusxalash:
/* 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:
import timeit
class A:
def f(self): pass
a = A()
timeit.timeit("a.f", globals=globals(), number=10_000_000)
# ~0.6s → 60 nanosekund60 ns — bu lug'at qidiruvidan bir oz sekinroq. Kesh bunga arzimaydi.
5. To'g'ri holat buzilardi
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 qaytarardiKeshni 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:
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:
a.metod(1) # ✅ MethodType yaratilmaydi (LOAD_METHOD)
m = a.metod # ⚠️ MethodType yaratiladi
callback(a.metod) # ⚠️ yaratiladiPython 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:
Runnable r1 = obj::metod;
Runnable r2 = obj::metod;
r1 == r2 // false — Python bilan bir xil8. Amaliy oqibatlari
Bilish kerak bo'lgan uchta narsa:
# 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 tez9. functools.partialmethod bilan solishtirish
Agar bog'langan metodni saqlash kerak bo'lsa va u qayta-qayta ishlatilsa:
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) # 15partial — bu ham obyekt, lekin bir marta yaratiladi.
Xulosa: kesh yo'q, chunki:
- Aylanma havola — gc yuki va
__del__muammosi - Xotira — 100k nusxa × 10 metod = 64 MB
- Yaratish arzon — 60 ns, free list bilan
- To'g'rilik — metod almashtirilsa kesh eskirardi
-
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:
Metod — funksiya + obyekt, va u kirish paytida yasaladi. Sinf lug'atida oddiy funksiya turadi;
a.metodyozilganda funksiyaning__get__deskriptori chaqiriladi vaMethodType(funksiya, a)qaytadi. Shuning uchuna.metod(x),A.metod(a, x)vaa.metod.__func__(a, x)— aynan bir narsa.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'yxatlaridaweakref.WeakMethodkerak.Uch metod turi — bir mexanizm.
function,classmethodvastaticmethod— uchalasi ham deskriptor; ular faqat__get__da nima qaytarishi bilan farq qiladi.@classmethoddacls()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.
Izohlar · 0
Izoh yozish uchun kiring.