8.8-dars: Ko'p meros va MRO
8-QISM — OBYEKTGA YO'NALTIRILGAN DASTURLASH · 8-dars
1. Kirish va motivatsiya
Bu kod ishlaydi:
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
D.__mro__ # (D, B, C, A, object)Bu esa ishlamaydi:
class A: pass
class B(A): pass
class C(A): pass
class E(B, C, A): pass # ✅ ishlaydi
class F(A, B): pass # ❌ TypeError!TypeError: Cannot create a consistent method resolution order (MRO)
for bases A, BNega? Va nega bu muhim:
class Ombor:
def saqla(self): return "ombor"
class Keshlangan(Ombor):
def saqla(self): return "kesh → " + super().saqla()
class Shifrlangan(Ombor):
def saqla(self): return "shifr → " + super().saqla()
class Xavfsiz(Keshlangan, Shifrlangan): pass
class Tez(Shifrlangan, Keshlangan): pass
Xavfsiz().saqla() # 'kesh → shifr → ombor'
Tez().saqla() # 'shifr → kesh → ombor' ⭐ tartib muhimBu darsda:
- MRO — metod aniqlash tartibi
- C3 linearizatsiyasi — algoritm qadamma-qadam
- Nega ba'zi ierarxiyalar
TypeErrorberadi - Olmos merosi va uning yechimi
- Mixin naqshi va tartib qoidalari
- Qachon ko'p meros to'g'ri, qachon xavfli
2. Nazariya — chuqur tushuntirish
2.1. MRO nima
MRO (Method Resolution Order) — atribut qidiruvi qaysi tartibda amalga oshirilishini belgilaydigan sinflar ro'yxati.
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
D.__mro__ # (D, B, C, A, object)
D.mro() # ro'yxat ko'rinishidad.x yozilganda Python:
d.__dict__da qidiradi- Topilmasa —
D.__mro__bo'ylab tartib bilan:D→B→C→A→object - Birinchi topilgan g'olib
MRO — super() ning ham asosi (8.7-darsda ko'rgan edik).
2.2. Bitta meros — sodda holat
class A: pass
class B(A): pass
class C(B): pass
C.__mro__ # (C, B, A, object)Bitta meros zanjirida MRO — shunchaki yuqoriga qarab yurish.
2.3. Olmos merosi
object
|
A
/ \
B C
\ /
Dclass A:
def f(self): return "A"
class B(A): pass
class C(A):
def f(self): return "C"
class D(B, C): pass
D().f() # 'C' ← A emas!
D.__mro__ # (D, B, C, A, object)Sodda "chuqurlikka birinchi" (DFS) algoritm noto'g'ri natija berardi:
DFS: D → B → A → object → C → A → object
Natija: (D, B, A, C, object) ⚠️ A, C dan OLDINBu yomon, chunki C.f A.f ni qayta aniqlagan, lekin DFS A.f ni topardi.
C3 linearizatsiyasi buni to'g'rilaydi: avlod har doim ota-sinfdan oldin.
2.4. C3 linearizatsiyasi
Python 2.3 dan beri (PEP 253) C3 algoritmi ishlatiladi.
Uch kafolat:
- Lokal ustuvorlik —
class D(B, C)daBCdan oldin - Monotonlik — avlod MRO si ota-sinf MRO tartibini buzmaydi
- Avlod ustuvorligi — har sinf o'z ota-sinflaridan oldin
Formula:
L[C] = C + merge(L[B1], L[B2], ..., L[Bn], [B1, B2, ..., Bn])Bu yerda L[X] — X ning linearizatsiyasi (MRO si).
merge amali:
- Birinchi ro'yxatning boshini (head) ol
- Agar u boshqa hech qaysi ro'yxatning dumida (tail) bo'lmasa — natijaga qo'sh, hamma ro'yxatdan o'chir
- Aks holda — keyingi ro'yxatning boshiga o't
- Hech qaysi bosh mos kelmasa —
TypeError
Misol:
class A: pass # L[A] = [A, object]
class B(A): pass # L[B] = [B, A, object]
class C(A): pass # L[C] = [C, A, object]
class D(B, C): passL[D] = D + merge(L[B], L[C], [B, C])
= D + merge([B, A, object], [C, A, object], [B, C])
1. Bosh: B. B boshqa ro'yxatlar dumida bormi?
[C, A, object] dumi = [A, object] → yo'q
[B, C] dumi = [C] → yo'q
✅ B ni ol
= D, B + merge([A, object], [C, A, object], [C])
2. Bosh: A. A dumida bormi?
[C, A, object] dumi = [A, object] → ⚠️ HA
❌ A ni hozir olib bo'lmaydi, keyingi ro'yxatga o't
3. Bosh: C. C dumida bormi?
[A, object] dumi = [object] → yo'q
[C] dumi = [] → yo'q
✅ C ni ol
= D, B, C + merge([A, object], [A, object], [])
4. Bosh: A. Endi dumda emas → ✅ ol
= D, B, C, A + merge([object], [object], [])
5. object → ✅
= D, B, C, A, object Natija: (D, B, C, A, object) — A oxirida, chunki u ikkalasining ham ota-sinfi.
2.5. Qachon TypeError
class A: pass
class B(A): pass
class F(A, B): pass # ❌ TypeErrorNega:
L[F] = F + merge(L[A], L[B], [A, B])
= F + merge([A, object], [B, A, object], [A, B])
1. Bosh: A. A dumida bormi?
[B, A, object] dumi = [A, object] → ⚠️ HA
❌ o't
2. Bosh: B. B dumida bormi?
[A, object] dumi = [object] → yo'q
[A, B] dumi = [B] → ⚠️ HA
❌ o't
3. Bosh: A (uchinchi ro'yxatdan). → ⚠️ yuqoridagi kabi
❌ o't
Hech qaysi bosh mos kelmadi → ❌ TypeError Sabab: class F(A, B) "A B dan oldin" deydi, lekin B(A) "B A dan oldin" deydi. Ziddiyat.
Tuzatish — tartibni almashtiring:
class F(B, A): pass # ✅ ishlaydi
F.__mro__ # (F, B, A, object)Qoida: asos sinflar ro'yxatida avlod sinf ota-sinfdan oldin turishi kerak.
2.6. Mixin naqshi
Mixin — mustaqil ishlatilmaydigan, boshqa sinflarga imkoniyat qo'shadigan sinf.
class JsonMixin:
"""Faqat bitta imkoniyat qo'shadi."""
def json(self) -> str:
return json.dumps(self.lugat())
class TenglikMixin:
def __eq__(self, boshqa):
if type(self) is not type(boshqa):
return NotImplemented
return self.lugat() == boshqa.lugat()
class Foydalanuvchi(JsonMixin, TenglikMixin):
def __init__(self, ism): self.ism = ism
def lugat(self): return {"ism": self.ism}Mixin qoidalari:
- Mixin — nomida
Mixinbo'lsin (kelishuv) - Bitta aniq imkoniyat — ko'p narsa qilmasin
- Mustaqil ishlatilmasin —
JsonMixin()ma'nosiz - Holat saqlamasin (ideal holda) — yoki
super().__init__()bilan - Asos sinflar ro'yxatida CHAPDA — MRO da oldin bo'lsin
- Shartnomani hujjatlang — qanday metodni talab qiladi
Tartib:
class X(Mixin1, Mixin2, Asos): ... # ✅ mixinlar chapda
class X(Asos, Mixin1, Mixin2): ... # ⚠️ mixinlar Asos ni to'sa olmaydiMRO chapdan o'ngga — chapdagi ustuvor.
2.7. Ko'p meros: qachon va qachon emas
Xavfsiz holatlar:
# 1. Mixin — bitta imkoniyat
class Model(JsonMixin, TenglikMixin, Asos): ...
# 2. Interfeys (ABC/Protocol) — kod yo'q
class Fayl(Oquvchi, Yozuvchi): ...
# 3. Hamkorlikdagi meros (super() bilan)
class Xizmat(JurnalMixin, KeshMixin, Asos): ...Xavfli:
# 1. Ikki "haqiqiy" sinf
class Odam: ...
class Mashina: ...
class Kentavr(Odam, Mashina): ... # ⚠️ ikki mustaqil holat
# 2. Chuqur olmos
class A: ...
class B(A): ...
class C(A): ...
class D(B): ...
class E(C): ...
class F(D, E): ... # ⚠️ MRO murakkab
# 3. super() chaqirmaydigan sinflar aralashmasiAmaliy mezon:
Agar ikki asos sinf ham holat (
__init__da atributlar) va mantiq olib kelsa — bu xavfli. Kompozitsiyani ko'rib chiqing.
2.8. MRO bilan ishlash
D.__mro__ # tuple
D.mro() # list (o'zgartirish mumkin)
D.__bases__ # to'g'ridan-to'g'ri ota-sinflar
D.__base__ # birinchi ota-sinf
inspect.getmro(D) # __mro__ bilan bir xilMetod qayerdan kelgan:
next(c for c in D.__mro__ if "f" in c.__dict__)3. Tez ma'lumotnoma
MRO
D.__mro__ (D, B, C, A, object)
D.mro() ro'yxat
D.__bases__ (B, C) — to'g'ridan-to'g'ri
D.__base__ B
Atribut qidiruvi: obj.__dict__ → MRO bo'ylab tartib bilanC3 linearizatsiyasi
L[C] = C + merge(L[B1], ..., L[Bn], [B1, ..., Bn])
merge:
1. Birinchi ro'yxat boshini ol
2. Boshqa ro'yxatlar DUMIDA bo'lmasa → natijaga
3. Bo'lsa → keyingi ro'yxatga o't
4. Hech qaysi mos kelmasa → TypeError
Uch kafolat:
• Lokal ustuvorlik (B, C tartibi saqlanadi)
• Monotonlik (ota-sinf MRO buzilmaydi)
• Avlod ota-sinfdan oldinTypeError
class B(A): pass
class F(A, B): pass ❌ A B dan oldin bo'la olmaydi
class F(B, A): pass ✅
Qoida: avlod sinf ota-sinfdan CHAPDAMixin
class X(Mixin1, Mixin2, Asos): ... ✅ mixinlar chapda
Qoidalar:
• Nomida "Mixin"
• Bitta imkoniyat
• Mustaqil ishlatilmaydi
• super() ni chaqiradi
• Shartnomani hujjatlang4. Batafsil misollar
Misol 1 — MRO ni hisoblash
"""C3 linearizatsiyasi — qadamma-qadam."""
print("=== 1. Sodda holatlar ===\n")
class A: pass
class B(A): pass
class C(B): pass
for S in (A, B, C):
mro = " → ".join(k.__name__ for k in S.__mro__)
print(f" {S.__name__}.__mro__ = ({mro})")
print(f"\n ⭐ Bitta meros: shunchaki yuqoriga qarab yurish")
print("\n=== 2. ⭐ Olmos merosi ===\n")
class Olmos_A:
def f(self): return "A.f"
class Olmos_B(Olmos_A):
pass
class Olmos_C(Olmos_A):
def f(self): return "C.f"
class Olmos_D(Olmos_B, Olmos_C):
pass
print(f" A")
print(f" / \\")
print(f" B C (C da f() qayta aniqlangan)")
print(f" \\ /")
print(f" D\n")
mro = " → ".join(k.__name__.replace("Olmos_", "")
for k in Olmos_D.__mro__)
print(f" D.__mro__ = ({mro})")
print(f" D().f() = {Olmos_D().f()!r} ⭐ C.f, A.f EMAS")
print(f"""
⚠️ Sodda DFS (chuqurlikka birinchi) noto'g'ri berardi:
D → B → A → object → C
Natija: (D, B, A, C, object)
→ D().f() = 'A.f' ❌ noto'g'ri!
⭐ C3: A ikkala shoxning ham ota-sinfi, shuning uchun
u ikkalasidan KEYIN keladi.
""")
print("=== 3. C3 algoritmi — qo'lda hisoblash ===\n")
def c3_merge(royxatlar: list[list], izoh: bool = False) -> list:
"""C3 merge amali."""
natija = []
royxatlar = [list(r) for r in royxatlar if r]
qadam = 0
while royxatlar:
qadam += 1
tanlangan = None
for i, r in enumerate(royxatlar):
bosh = r[0]
# Bosh boshqa ro'yxatlarning DUMIDA bormi?
dumda = any(bosh in boshqa[1:] for boshqa in royxatlar)
if izoh:
holat = "⚠️ dumda" if dumda else "✅ olamiz"
print(f" {qadam}.{i+1} Bosh: {bosh.__name__:<12} {holat}")
if not dumda:
tanlangan = bosh
break
if tanlangan is None:
raise TypeError(
"Cannot create a consistent method resolution order"
)
natija.append(tanlangan)
royxatlar = [[x for x in r if x is not tanlangan] for r in royxatlar]
royxatlar = [r for r in royxatlar if r]
return natija
def c3(sinf: type, izoh: bool = False) -> list:
"""Sinf uchun MRO hisoblaydi."""
if not sinf.__bases__:
return [sinf]
otalar = list(sinf.__bases__)
return [sinf] + c3_merge(
[c3(o) for o in otalar] + [otalar], izoh=izoh
)
print(f" D uchun hisoblash:\n")
print(f" L[B] = {[k.__name__.replace('Olmos_','') for k in c3(Olmos_B)]}")
print(f" L[C] = {[k.__name__.replace('Olmos_','') for k in c3(Olmos_C)]}")
print(f" Otalar = ['B', 'C']\n")
print(f" merge qadamlari:")
natija = [Olmos_D] + c3_merge(
[c3(Olmos_B), c3(Olmos_C), [Olmos_B, Olmos_C]], izoh=True
)
print(f"\n Natija: "
f"{[k.__name__.replace('Olmos_','') for k in natija]}")
print(f" Python: "
f"{[k.__name__.replace('Olmos_','') for k in Olmos_D.__mro__]}")
print(f" Mos keladimi: {natija == list(Olmos_D.__mro__)} ✅")
print("\n=== 4. Murakkab ierarxiya ===\n")
class O: pass
class P(O): pass
class Q(O): pass
class R(O): pass
class S(P, Q): pass
class T(Q, R): pass
class U(S, T): pass
print(f" O")
print(f" / | \\")
print(f" P Q R")
print(f" \\ / \\ /")
print(f" S T")
print(f" \\ /")
print(f" U\n")
for Sinf in (P, Q, R, S, T, U):
mro = " → ".join(k.__name__ for k in Sinf.__mro__)
print(f" {Sinf.__name__}: {mro}")
print(f"\n ⭐ U ning MRO si: "
f"{[k.__name__ for k in U.__mro__]}")
print(f" Tekshirish (o'z algoritmimiz): "
f"{[k.__name__ for k in c3(U)]}")
print(f"""
⭐ E'TIBOR BERING:
• Q S va T dan KEYIN (ikkalasining ota-sinfi)
• O eng OXIRIDA (hammasining ota-sinfi)
• P Q dan oldin (S da tartib: P, Q)
• R Q dan keyin (T da tartib: Q, R)
""")
print("=== ⚠️ 5. TypeError holatlari ===\n")
XATO_HOLATLAR = [
("class F(A, B) — B(A) bo'lganda",
lambda: type("F", (A, B), {})),
("class G(object, A)",
lambda: type("G", (object, A), {})),
]
for tavsif, f in XATO_HOLATLAR:
try:
Sinf = f()
natija = f"⚠️ Yaratildi: {[k.__name__ for k in Sinf.__mro__]}"
except TypeError as e:
natija = f"✅ TypeError: {str(e)[:50]}..."
print(f" {tavsif:<38} {natija}")
print(f"\n ⭐ TUSHUNTIRISH (class F(A, B), B(A) bo'lganda):\n")
print(f" L[A] = [A, object]")
print(f" L[B] = [B, A, object]")
print(f" Otalar = [A, B]\n")
print(f" merge([A, object], [B, A, object], [A, B]):")
try:
c3_merge([c3(A), c3(B), [A, B]], izoh=True)
except TypeError as e:
print(f"\n ❌ TypeError: {e}")
print(f"""
⭐ ZIDDIYAT:
class F(A, B) → "A, B dan OLDIN"
class B(A) → "B, A dan OLDIN"
Ikkalasi bir vaqtda mumkin emas.
✅ TUZATISH: class F(B, A)
""")
class F_togri(B, A): pass
print(f" class F(B, A) → "
f"{[k.__name__ for k in F_togri.__mro__]} ✅")
print("\n=== 6. MRO ni tekshirish vositalari ===\n")
import inspect
def mro_tahlil(Sinf: type) -> None:
print(f" {Sinf.__name__}:")
print(f" __bases__ : {tuple(k.__name__ for k in Sinf.__bases__)}")
print(f" __base__ : {Sinf.__base__.__name__}")
print(f" __mro__ : {tuple(k.__name__ for k in Sinf.__mro__)}")
print(f" mro() : {[k.__name__ for k in Sinf.mro()]}")
print(f" inspect : {[k.__name__ for k in inspect.getmro(Sinf)]}")
mro_tahlil(U)
def metod_manbai(Sinf: type, metod: str) -> str:
"""Metod qaysi sinfdan kelayotganini aytadi."""
for k in Sinf.__mro__:
if metod in k.__dict__:
return k.__name__
return "❌ topilmadi"
class M1:
def a(self): ...
def b(self): ...
class M2:
def b(self): ...
def c(self): ...
class M3(M1, M2):
def c(self): ...
print(f"\n M3(M1, M2) uchun metod manbalari:")
print(f" MRO: {[k.__name__ for k in M3.__mro__]}\n")
for m in "abcd":
print(f" M3.{m} → {metod_manbai(M3, m)}")Natijaning muhim qismi:
=== 2. ⭐ Olmos merosi ===
D.__mro__ = (D → B → C → A → object)
D().f() = 'C.f' ⭐ C.f, A.f EMAS
=== 3. C3 algoritmi — qo'lda hisoblash ===
D uchun hisoblash:
L[B] = ['B', 'A', 'object']
L[C] = ['C', 'A', 'object']
merge qadamlari:
1.1 Bosh: Olmos_B ✅ olamiz
2.1 Bosh: Olmos_A ⚠️ dumda
2.2 Bosh: Olmos_C ✅ olamiz
3.1 Bosh: Olmos_A ✅ olamiz
4.1 Bosh: object ✅ olamiz
Mos keladimi: True ✅
=== ⚠️ 5. TypeError holatlari ===
class F(A, B) — B(A) bo'lganda ✅ TypeError: Cannot create a
consistent method resolution...
class F(B, A) → ['F_togri', 'B', 'A', 'object'] ✅Nima ko'rsatdi: 2.1, 2.3, 2.4, 2.5-bo'limlar.
Misol 2 — Mixin arxitekturasi
"""To'g'ri loyihalangan mixinlar."""
from __future__ import annotations
import json
from dataclasses import dataclass, asdict, fields
print("=== 1. Mixin nima ===\n")
class LugatMixin:
"""Obyektni lug'atga o'giradi.
TALAB: nusxada __dict__ bo'lsin.
"""
def lugat(self) -> dict:
return {k: v for k, v in vars(self).items()
if not k.startswith("_")}
class JsonMixin:
"""JSON serializatsiya.
TALAB: lugat() metodi bo'lsin (LugatMixin beradi).
"""
def json(self, **kw) -> str:
return json.dumps(self.lugat(), ensure_ascii=False, **kw)
@classmethod
def jsondan(cls, matn: str):
return cls(**json.loads(matn))
class TenglikMixin:
"""__eq__ va __hash__.
TALAB: lugat() metodi bo'lsin.
"""
def __eq__(self, boshqa) -> bool:
if type(self) is not type(boshqa):
return NotImplemented
return self.lugat() == boshqa.lugat()
def __hash__(self) -> int:
return hash(tuple(sorted(self.lugat().items())))
class ReprMixin:
"""Avtomatik __repr__."""
def __repr__(self) -> str:
qismlar = ", ".join(f"{k}={v!r}" for k, v in self.lugat().items())
return f"{type(self).__name__}({qismlar})"
class TaqqoslashMixin:
"""<, >, <=, >= — TARTIB_KALITI bo'yicha.
TALAB: TARTIB_KALITI sinf atributi bo'lsin.
"""
TARTIB_KALITI: str = ""
def _tartib(self):
if not self.TARTIB_KALITI:
raise TypeError(f"{type(self).__name__}.TARTIB_KALITI yo'q")
return getattr(self, self.TARTIB_KALITI)
def __lt__(self, boshqa):
if type(self) is not type(boshqa):
return NotImplemented
return self._tartib() < boshqa._tartib()
def __le__(self, boshqa):
return self == boshqa or self < boshqa
def __gt__(self, boshqa):
if type(self) is not type(boshqa):
return NotImplemented
return boshqa < self
def __ge__(self, boshqa):
return self == boshqa or self > boshqa
# ═══ Ishlatish ═══
class Foydalanuvchi(ReprMixin, JsonMixin, TenglikMixin,
TaqqoslashMixin, LugatMixin):
TARTIB_KALITI = "yosh"
def __init__(self, ism: str, yosh: int, email: str = ""):
self.ism = ism
self.yosh = yosh
self.email = email
self._ichki = "ko'rinmaydi"
print(f" MRO: {' → '.join(k.__name__ for k in Foydalanuvchi.__mro__)}\n")
f1 = Foydalanuvchi("Aziz", 30, "aziz@wisar.uz")
f2 = Foydalanuvchi("Malika", 25)
f3 = Foydalanuvchi("Aziz", 30, "aziz@wisar.uz")
print(f" ReprMixin: {f1!r}")
print(f" LugatMixin: {f1.lugat()}")
print(f" JsonMixin: {f1.json()}")
print(f" TenglikMixin: f1 == f3 → {f1 == f3}, f1 == f2 → {f1 == f2}")
print(f" TaqqoslashMixin: f1 > f2 → {f1 > f2}")
print(f" sorted → "
f"{[f.ism for f in sorted([f1, f2])]}")
print(f"\n ⭐ _ichki lugat() ga kirmadi: "
f"{'_ichki' not in f1.lugat()}")
print(f"\n To'plamda ishlaydi (__hash__ bor):")
s = {f1, f2, f3}
print(f" {{f1, f2, f3}} → {len(s)} element (f1 == f3)")
print(f"\n jsondan():")
f4 = Foydalanuvchi.jsondan('{"ism": "Bobur", "yosh": 40}')
print(f" {f4!r}")
print("\n\n=== ⚠️ 2. Mixin tartibi ===\n")
class Asos:
def salom(self): return "asos"
class QichqiriqMixin:
def salom(self): return super().salom().upper()
class BezakMixin:
def salom(self): return f"*** {super().salom()} ***"
class A1(QichqiriqMixin, BezakMixin, Asos): pass
class A2(BezakMixin, QichqiriqMixin, Asos): pass
class A3(Asos, QichqiriqMixin, BezakMixin): pass
for Sinf in (A1, A2, A3):
mro = " → ".join(k.__name__.replace("Mixin", "")
for k in Sinf.__mro__[:-1])
print(f" {Sinf.__name__}: {mro}")
print(f" salom() = {Sinf().salom()!r}\n")
print(f""" ⭐ TARTIB QOIDASI:
class X(Mixin1, Mixin2, Asos)
MRO: X → Mixin1 → Mixin2 → Asos
Chaqiruv: Mixin1 birinchi ishlaydi, super() bilan pastga
⚠️ A3 da mixinlar Asos dan KEYIN → ular hech qachon
ishlamaydi (Asos.salom() super() chaqirmaydi).
""")
print("=== 3. Mixinlar holat bilan ===\n")
class HisoblagichMixin:
"""⭐ Holat saqlaydi — super().__init__() SHART."""
def __init__(self, **kw):
super().__init__(**kw)
self._chaqiruvlar = 0
def sanash(self):
self._chaqiruvlar += 1
return self._chaqiruvlar
class JurnalMixin:
def __init__(self, *, jurnal_yoq: bool = False, **kw):
super().__init__(**kw)
self.jurnal: list[str] = []
self.jurnal_yoq = jurnal_yoq
def yoz(self, xabar: str):
if not self.jurnal_yoq:
self.jurnal.append(xabar)
class KeshMixin:
def __init__(self, *, kesh_hajmi: int = 10, **kw):
super().__init__(**kw)
self._kesh: dict = {}
self.kesh_hajmi = kesh_hajmi
class AsosXizmat:
def __init__(self, nom: str = "xizmat", **kw):
if kw:
raise TypeError(f"Noma'lum: {sorted(kw)}")
super().__init__()
self.nom = nom
class Xizmat(HisoblagichMixin, JurnalMixin, KeshMixin, AsosXizmat):
def ishla(self, x):
n = self.sanash()
self.yoz(f"ishla({x}) #{n}")
return x * 2
print(f" MRO: {' → '.join(k.__name__ for k in Xizmat.__mro__)}\n")
x = Xizmat(nom="test", jurnal_yoq=False, kesh_hajmi=50)
print(f" Barcha mixin argumentlari taqsimlandi:")
for atr in ["nom", "jurnal_yoq", "kesh_hajmi", "_chaqiruvlar"]:
print(f" {atr:<16} {getattr(x, atr)!r}")
x.ishla(1); x.ishla(2); x.ishla(3)
print(f"\n 3 ta ishla():")
print(f" _chaqiruvlar: {x._chaqiruvlar}")
print(f" jurnal: {x.jurnal}")
try:
Xizmat(notogri=1)
except TypeError as e:
print(f"\n Xizmat(notogri=1) → ✅ TypeError: {e}")
print("\n\n=== ⚠️ 4. Mixin shartnomasini buzish ===\n")
class YomonMixin:
"""⚠️ super() chaqirmaydi — zanjirni uzadi."""
def __init__(self, **kw):
self.yomon = True # ⚠️ super() yo'q
class Buzilgan(HisoblagichMixin, YomonMixin, AsosXizmat):
pass
print(f" MRO: {' → '.join(k.__name__ for k in Buzilgan.__mro__)}\n")
b = Buzilgan(nom="test")
print(f" Buzilgan(nom='test').__dict__ = {b.__dict__}")
print(f" ⚠️ 'nom' YO'Q — AsosXizmat.__init__ chaqirilmadi")
print(f" ⚠️ argument 'nom' jimgina yo'qoldi")
print(f"""
⭐ QOIDA: hamkorlikdagi merosda HAR sinf super() ni
chaqirishi SHART. Aks holda zanjir uziladi va
argumentlar jimgina yo'qoladi.
""")
print("=== 5. Mixin hujjatlash ===\n")
print(''' ⭐ HAR MIXIN UCHUN HUJJATLANG:
class KeshMixin:
"""Metod natijalarini keshlaydi.
TALAB QILADI:
_kalit(*args) -> str kesh kalitini yasaydi
sorov(*args) asos metodi (super() orqali)
QO'SHADI:
_kesh: dict ichki kesh
kesh_holati() -> dict statistika
ARGUMENTLAR:
kesh_hajmi: int = 100
TARTIB:
JurnalMixin dan KEYIN qo'yilsa, keshdan
kelgan javoblar jurnalga tushmaydi.
MISOL:
class Xizmat(JurnalMixin, KeshMixin, Asos): ...
"""
''')
print("=== 6. Mixin tekshiruvchisi ===\n")
def mixin_tekshiruvi(Sinf: type) -> dict:
"""Mixin arxitekturasidagi muammolarni topadi."""
muammolar = []
mro = Sinf.__mro__
# 1. super() chaqirmaydigan __init__
for k in mro[:-1]:
if "__init__" not in k.__dict__:
continue
kod = k.__init__.__code__
# super() ishlatilganini __class__ yopilmasi orqali bilamiz
if "__class__" not in kod.co_freevars and k is not mro[-2]:
muammolar.append(
f"{k.__name__}.__init__ da super() yo'q (ehtimol)"
)
# 2. Mixin nomlari o'ngda
nomlar = [k.__name__ for k in Sinf.__bases__]
mixinlar = [i for i, n in enumerate(nomlar) if "Mixin" in n]
mixinsizlar = [i for i, n in enumerate(nomlar) if "Mixin" not in n]
if mixinlar and mixinsizlar and max(mixinlar) > min(mixinsizlar):
muammolar.append(
f"Mixin asos sinfdan o'ngda: {nomlar}"
)
# 3. Bir metodni bir necha sinf aniqlagan
metodlar: dict[str, list[str]] = {}
for k in mro[:-1]:
for nom, q in k.__dict__.items():
if callable(q) and not nom.startswith("__"):
metodlar.setdefault(nom, []).append(k.__name__)
ziddiyat = {m: s for m, s in metodlar.items() if len(s) > 1}
return {
"mro_uzunligi": len(mro),
"asos_sinflar": nomlar,
"muammolar": muammolar,
"ziddiyatli_metodlar": ziddiyat,
}
for Sinf in (Foydalanuvchi, Xizmat, A3, Buzilgan):
n = mixin_tekshiruvi(Sinf)
print(f" {Sinf.__name__}:")
print(f" MRO uzunligi: {n['mro_uzunligi']}")
print(f" Asos sinflar: {n['asos_sinflar']}")
if n["muammolar"]:
for m in n["muammolar"]:
print(f" ⚠️ {m}")
if n["ziddiyatli_metodlar"]:
print(f" Ziddiyatli metodlar: {n['ziddiyatli_metodlar']}")
if not n["muammolar"] and not n["ziddiyatli_metodlar"]:
print(f" ✅ muammo topilmadi")
print()Natijaning muhim qismi:
=== 1. Mixin nima ===
MRO: Foydalanuvchi → ReprMixin → JsonMixin → TenglikMixin →
TaqqoslashMixin → LugatMixin → object
ReprMixin: Foydalanuvchi(ism='Aziz', yosh=30, ...)
JsonMixin: {"ism": "Aziz", "yosh": 30, "email": "aziz@wisar.uz"}
TenglikMixin: f1 == f3 → True, f1 == f2 → False
TaqqoslashMixin: f1 > f2 → True
=== ⚠️ 2. Mixin tartibi ===
A1: A1 → Qichqiriq → Bezak → Asos
salom() = '*** ASOS ***'
A2: A2 → Bezak → Qichqiriq → Asos
salom() = '*** ASOS ***'
A3: A3 → Asos → Qichqiriq → Bezak
salom() = 'asos'
=== ⚠️ 4. Mixin shartnomasini buzish ===
Buzilgan(nom='test').__dict__ = {'yomon': True, '_chaqiruvlar': 0}
⚠️ 'nom' YO'Q — AsosXizmat.__init__ chaqirilmadiNima ko'rsatdi: 2.6, 2.7-bo'limlar.
Misol 3 — Ko'p meros: qachon va qachon emas
"""Ko'p merosning to'g'ri va noto'g'ri qo'llanishi."""
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
print("=== ✅ 1. XAVFSIZ: interfeys merosi ===\n")
class Oquvchi(ABC):
"""Faqat shartnoma — kod yo'q."""
@abstractmethod
def oqi(self, n: int = -1) -> bytes: ...
class Yozuvchi(ABC):
@abstractmethod
def yoz(self, m: bytes) -> int: ...
class Yopiladigan(ABC):
@abstractmethod
def yop(self) -> None: ...
def __enter__(self):
return self
def __exit__(self, *_):
self.yop()
return False
class XotiraFayl(Oquvchi, Yozuvchi, Yopiladigan):
"""✅ Uch interfeys, hech qanday holat ziddiyati yo'q."""
def __init__(self):
self._bufer = bytearray()
self._joy = 0
self._yopiq = False
def oqi(self, n: int = -1) -> bytes:
if self._yopiq:
raise ValueError("Yopilgan")
oxir = len(self._bufer) if n < 0 else min(self._joy + n,
len(self._bufer))
natija = bytes(self._bufer[self._joy:oxir])
self._joy = oxir
return natija
def yoz(self, m: bytes) -> int:
if self._yopiq:
raise ValueError("Yopilgan")
self._bufer.extend(m)
return len(m)
def yop(self) -> None:
self._yopiq = True
print(f" MRO: {' → '.join(k.__name__ for k in XotiraFayl.__mro__)}\n")
with XotiraFayl() as f:
f.yoz(b"Salom, ")
f.yoz(b"dunyo!")
f._joy = 0
print(f" yozildi va o'qildi: {f.oqi()!r}")
print(f" yopilgandan keyin: ", end="")
try:
f.oqi()
except ValueError as e:
print(f"✅ ValueError: {e}")
print(f"""
⭐ NEGA XAVFSIZ:
• Interfeyslar KOD olib kelmaydi (faqat @abstractmethod)
• Holat ziddiyati yo'q
• MRO sodda
• isinstance(f, Oquvchi) ishlaydi
""")
print("=== ✅ 2. XAVFSIZ: mixin ===\n")
@dataclass
class Nuqta:
x: float
y: float
class MasofaMixin:
"""⭐ Bitta imkoniyat, holat yo'q."""
def masofa(self, boshqa) -> float:
return ((self.x - boshqa.x) ** 2 +
(self.y - boshqa.y) ** 2) ** 0.5
class KochirishMixin:
def kochir(self, dx: float, dy: float):
return type(self)(self.x + dx, self.y + dy)
class Nuqta2D(MasofaMixin, KochirishMixin, Nuqta):
pass
n1, n2 = Nuqta2D(0, 0), Nuqta2D(3, 4)
print(f" n1 = {n1}, n2 = {n2}")
print(f" n1.masofa(n2) = {n1.masofa(n2)}")
print(f" n1.kochir(1, 1) = {n1.kochir(1, 1)}")
print(f"\n ✅ Mixinlar holatsiz — ziddiyat mumkin emas")
print("\n\n=== ⚠️ 3. XAVFLI: ikki 'haqiqiy' sinf ===\n")
class Odam:
def __init__(self, ism: str, yosh: int):
self.ism = ism
self.yosh = yosh
self.energiya = 100
def yur(self):
self.energiya -= 5
return f"{self.ism} yurdi"
def holat(self):
return f"Odam: {self.ism}, energiya={self.energiya}"
class Mashina:
def __init__(self, model: str, yoqilgi: float):
self.model = model
self.yoqilgi = yoqilgi
self.energiya = 50 # ⚠️ NOM TO'QNASHUVI
def yur(self): # ⚠️ METOD TO'QNASHUVI
self.yoqilgi -= 1
return f"{self.model} yurdi"
def holat(self):
return f"Mashina: {self.model}, yoqilgi={self.yoqilgi}"
class Kentavr(Odam, Mashina):
"""⚠️ Ikki mustaqil holat va mantiq."""
def __init__(self, ism, yosh, model, yoqilgi):
Odam.__init__(self, ism, yosh)
Mashina.__init__(self, model, yoqilgi) # ⚠️ energiya qayta yozildi
k = Kentavr("Aziz", 30, "Nexia", 40)
print(f" MRO: {' → '.join(c.__name__ for c in Kentavr.__mro__)}\n")
print(f" k.__dict__ = {k.__dict__}")
print(f"\n ⚠️ energiya = {k.energiya} — Odam 100 qo'ygan edi,")
print(f" Mashina 50 ga qayta yozdi")
print(f"\n k.yur() = {k.yur()!r} ← Odam.yur (MRO da birinchi)")
print(f" k.holat() = {k.holat()!r}")
print(f" ⚠️ Mashina.yur va Mashina.holat HECH QACHON chaqirilmaydi")
print(f"""
⭐ MUAMMOLAR:
1. Atribut nomlari to'qnashadi (energiya)
2. Metod nomlari to'qnashadi (yur, holat)
3. __init__ ni qo'lda chaqirish kerak
4. Ikkinchi sinfning metodlari o'lik kod
5. "Kentavr — bu Odam VA Mashina" — mantiqan g'alati
""")
print("=== ✅ 4. YECHIM: kompozitsiya ===\n")
class KentavrKompozitsiya:
"""✅ Ikki mustaqil qism."""
def __init__(self, ism, yosh, model, yoqilgi):
self.odam = Odam(ism, yosh)
self.mashina = Mashina(model, yoqilgi)
def yur(self) -> str:
"""⭐ ANIQ qaysi biri ishlashi ko'rinadi."""
if self.mashina.yoqilgi > 0:
return self.mashina.yur()
return self.odam.yur()
def holat(self) -> str:
return f"{self.odam.holat()} | {self.mashina.holat()}"
kk = KentavrKompozitsiya("Aziz", 30, "Nexia", 2)
print(f" Boshida: {kk.holat()}")
print(f"\n yur() × 3:")
for _ in range(3):
print(f" {kk.yur()}")
print(f"\n Oxirida: {kk.holat()}")
print(f"""
✅ AFZALLIKLARI:
• Har qism o'z holatini saqlaydi (to'qnashuv yo'q)
• Qaysi biri ishlayotgani ANIQ
• Har qismni alohida test qilish mumkin
• Mantiq ochiq (yoqilg'i bo'lsa mashina, aks holda odam)
""")
print("=== ⚠️ 5. Chuqur olmos ===\n")
class Baza:
def f(self): return ["Baza"]
class L1(Baza):
def f(self): return ["L1"] + super().f()
class L2(Baza):
def f(self): return ["L2"] + super().f()
class L3(L1):
def f(self): return ["L3"] + super().f()
class L4(L2):
def f(self): return ["L4"] + super().f()
class L5(L1, L2):
def f(self): return ["L5"] + super().f()
class Murakkab(L3, L4, L5):
def f(self): return ["Murakkab"] + super().f()
print(f" Ierarxiya:")
print(f" Baza")
print(f" / \\")
print(f" L1 L2")
print(f" / \\ /")
print(f" L3 L5 L4")
print(f" \\ | /")
print(f" Murakkab\n")
print(f" MRO: {' → '.join(k.__name__ for k in Murakkab.__mro__)}")
print(f"\n Murakkab().f() = {' → '.join(Murakkab().f())}")
print(f"""
⚠️ Bu MRO ni oldindan aytish DEYARLI MUMKIN EMAS.
Yangi sinf qo'shsangiz — butun tartib o'zgarishi mumkin.
⭐ QOIDA: MRO uzunligi 5-6 dan oshsa — arxitekturani
qayta ko'rib chiqing.
""")
print(f" MRO uzunliklari:")
for S in (Baza, L1, L3, L5, Murakkab):
print(f" {S.__name__:<12} {len(S.__mro__)}")
print("\n=== 6. Qaror jadvali ===\n")
print("""
┌──────────────────────────────┬────────────────────────────┐
│ Holat │ Tavsiya │
├──────────────────────────────┼────────────────────────────┤
│ Faqat shartnoma (ABC) │ ✅ Ko'p meros │
│ Holatsiz mixin │ ✅ Ko'p meros │
│ super() bilan hamkorlik │ ✅ Ko'p meros (ehtiyot) │
│ Bitta "haqiqiy" ota + mixin │ ✅ Ko'p meros │
│ Ikki "haqiqiy" sinf │ ❌ Kompozitsiya │
│ Holat to'qnashuvi bor │ ❌ Kompozitsiya │
│ MRO > 6 sinf │ ⚠️ Qayta loyihalang │
│ Chuqur olmos (3+ daraja) │ ⚠️ Qayta loyihalang │
└──────────────────────────────┴────────────────────────────┘
⭐ AMALIY MEZON:
"Bu ikki asos sinfning HAR IKKALASI ham
__init__ da atribut o'rnatadimi?"
Ha → ⚠️ ehtiyot bo'ling, super() zanjiri kerak
Yo'q → ✅ xavfsiz
""")Natijaning muhim qismi:
=== ⚠️ 3. XAVFLI: ikki 'haqiqiy' sinf ===
k.__dict__ = {'ism': 'Aziz', 'yosh': 30, 'energiya': 50,
'model': 'Nexia', 'yoqilgi': 40}
⚠️ energiya = 50 — Odam 100 qo'ygan edi,
Mashina 50 ga qayta yozdi
k.yur() = 'Aziz yurdi' ← Odam.yur (MRO da birinchi)
⚠️ Mashina.yur va Mashina.holat HECH QACHON chaqirilmaydi
=== ✅ 4. YECHIM: kompozitsiya ===
Boshida: Odam: Aziz, energiya=100 | Mashina: Nexia, yoqilgi=2
yur() × 3:
Nexia yurdi
Nexia yurdi
Aziz yurdi
=== ⚠️ 5. Chuqur olmos ===
MRO: Murakkab → L3 → L4 → L5 → L1 → L2 → Baza → object
Murakkab().f() = Murakkab → L3 → L4 → L5 → L1 → L2 → BazaNima ko'rsatdi: 2.3, 2.7-bo'limlar.
Misol 4 — Amaliy: plagin tizimi
"""MRO va mixinlarga asoslangan plagin arxitekturasi."""
from __future__ import annotations
import time
from abc import ABC, abstractmethod
from typing import Any
print("=== MA'LUMOT QUVURI ===\n")
class Bosqich(ABC):
"""Quvurning bir bosqichi.
SHARTNOMA:
bajar(malumot) -> malumot
Har bosqich super().bajar() ni chaqiradi.
"""
def __init__(self, **kw):
if kw:
raise TypeError(f"Noma'lum argumentlar: {sorted(kw)}")
super().__init__()
self.nom = type(self).__name__
@abstractmethod
def bajar(self, malumot: list[dict]) -> list[dict]:
"""Ma'lumotni qayta ishlaydi."""
class Manba(Bosqich):
"""Zanjirning oxiri — ma'lumot manbai."""
def __init__(self, *, malumot: list[dict] | None = None, **kw):
super().__init__(**kw)
self._malumot = list(malumot or [])
def bajar(self, malumot: list[dict] | None = None) -> list[dict]:
return [dict(q) for q in self._malumot]
# ═══ MIXINLAR ═══
class FiltrMixin:
"""Shartga mos yozuvlarni qoldiradi.
ARGUMENTLAR: filtr — dict, mos kelishi kerak bo'lgan maydonlar
"""
def __init__(self, *, filtr: dict | None = None, **kw):
super().__init__(**kw)
self.filtr = dict(filtr or {})
self.filtrlangan = 0
def bajar(self, malumot=None) -> list[dict]:
natija = super().bajar(malumot)
if not self.filtr:
return natija
oldin = len(natija)
natija = [q for q in natija
if all(q.get(k) == v for k, v in self.filtr.items())]
self.filtrlangan += oldin - len(natija)
return natija
class SaralashMixin:
"""Berilgan kalit bo'yicha saralaydi."""
def __init__(self, *, kalit: str = "", teskari: bool = False, **kw):
super().__init__(**kw)
self.kalit = kalit
self.teskari = teskari
def bajar(self, malumot=None) -> list[dict]:
natija = super().bajar(malumot)
if self.kalit:
natija.sort(key=lambda q: q.get(self.kalit, 0),
reverse=self.teskari)
return natija
class ChegaraMixin:
"""Natijalar sonini cheklaydi."""
def __init__(self, *, chegara: int | None = None, **kw):
super().__init__(**kw)
self.chegara = chegara
def bajar(self, malumot=None) -> list[dict]:
natija = super().bajar(malumot)
return natija[:self.chegara] if self.chegara else natija
class BoyitishMixin:
"""Yangi maydon qo'shadi."""
def __init__(self, *, boyitish: dict | None = None, **kw):
super().__init__(**kw)
self.boyitish = dict(boyitish or {})
def bajar(self, malumot=None) -> list[dict]:
natija = super().bajar(malumot)
for q in natija:
for kalit, f in self.boyitish.items():
q[kalit] = f(q)
return natija
class JurnalMixin:
"""Har bosqichni yozib boradi."""
def __init__(self, **kw):
super().__init__(**kw)
self.jurnal: list[str] = []
def bajar(self, malumot=None) -> list[dict]:
boshlanish = time.perf_counter()
natija = super().bajar(malumot)
vaqt = (time.perf_counter() - boshlanish) * 1000
self.jurnal.append(f"{len(natija):>3} yozuv, {vaqt:.2f}ms")
return natija
class KeshMixin:
"""Natijani keshlaydi."""
def __init__(self, **kw):
super().__init__(**kw)
self._kesh: list[dict] | None = None
self.urish = 0
def bajar(self, malumot=None) -> list[dict]:
if self._kesh is not None:
self.urish += 1
return [dict(q) for q in self._kesh]
natija = super().bajar(malumot)
self._kesh = [dict(q) for q in natija]
return natija
def keshni_tozala(self):
self._kesh = None
# ═══ QUVURLAR ═══
class OddiyQuvur(FiltrMixin, SaralashMixin, Manba):
"""Filtr + saralash."""
class ToliqQuvur(JurnalMixin, KeshMixin, ChegaraMixin, SaralashMixin,
BoyitishMixin, FiltrMixin, Manba):
"""Barcha bosqichlar."""
MALUMOT = [
{"ism": "Aziz", "yosh": 30, "shahar": "Toshkent", "maosh": 5_000_000},
{"ism": "Malika", "yosh": 25, "shahar": "Samarqand", "maosh": 4_500_000},
{"ism": "Bobur", "yosh": 40, "shahar": "Toshkent", "maosh": 8_000_000},
{"ism": "Dilnoza", "yosh": 35, "shahar": "Buxoro", "maosh": 6_000_000},
{"ism": "Sardor", "yosh": 28, "shahar": "Toshkent", "maosh": 5_500_000},
{"ism": "Nilufar", "yosh": 45, "shahar": "Samarqand", "maosh": 9_000_000},
]
print("1. MRO — bosqichlar tartibi:\n")
for Sinf in (OddiyQuvur, ToliqQuvur):
mro = " → ".join(k.__name__.replace("Mixin", "")
for k in Sinf.__mro__[:-2])
print(f" {Sinf.__name__}:")
print(f" {mro}\n")
print("2. Oddiy quvur:\n")
q1 = OddiyQuvur(
malumot=MALUMOT,
filtr={"shahar": "Toshkent"},
kalit="maosh",
teskari=True,
)
natija = q1.bajar()
print(f" Filtr: shahar=Toshkent, saralash: maosh (kamayish)\n")
for q in natija:
print(f" {q['ism']:<10} {q['yosh']:>3} yosh "
f"{q['maosh']:>12,} so'm")
print(f"\n Filtrlangan: {q1.filtrlangan} ta yozuv chiqarildi")
print("\n\n3. To'liq quvur:\n")
q2 = ToliqQuvur(
malumot=MALUMOT,
filtr={},
boyitish={
"toifa": lambda q: "katta" if q["maosh"] >= 6_000_000 else "o'rta",
"yillik": lambda q: q["maosh"] * 12,
},
kalit="yillik",
teskari=True,
chegara=4,
)
natija = q2.bajar()
print(f" Boyitish → saralash (yillik) → chegara(4)\n")
print(f" {'Ism':<10} {'Yosh':>5} {'Toifa':<8} {'Yillik':>16}")
print(" " + "─" * 44)
for q in natija:
print(f" {q['ism']:<10} {q['yosh']:>5} {q['toifa']:<8} "
f"{q['yillik']:>16,}")
print("\n\n4. ⭐ Kesh ishlashi:\n")
print(f" Birinchi chaqiruv:")
q2.bajar()
print(f" jurnal: {q2.jurnal[-1]}")
print(f"\n Ikkinchi va uchinchi chaqiruv:")
q2.bajar(); q2.bajar()
print(f" jurnal: {q2.jurnal[-1]}")
print(f" kesh urishlari: {q2.urish}")
print(f"\n Keshni tozalash:")
q2.keshni_tozala()
q2.bajar()
print(f" jurnal: {q2.jurnal[-1]}")
print(f" kesh urishlari: {q2.urish} ← oshmadi")
print(f"\n Barcha jurnal ({len(q2.jurnal)} yozuv):")
for i, j in enumerate(q2.jurnal, 1):
print(f" {i}. {j}")
print("\n\n5. ⭐ Tartib xatti-harakatni o'zgartiradi:\n")
class ChegaraOldin(ChegaraMixin, SaralashMixin, Manba):
"""⚠️ Chegara saralashdan OLDIN."""
class SaralashOldin(SaralashMixin, ChegaraMixin, Manba):
"""✅ Saralash chegaradan OLDIN."""
for Sinf in (ChegaraOldin, SaralashOldin):
q = Sinf(malumot=MALUMOT, kalit="maosh", teskari=True, chegara=3)
natija = q.bajar()
mro = " → ".join(k.__name__.replace("Mixin", "")
for k in Sinf.__mro__[1:-3])
print(f" {Sinf.__name__} ({mro}):")
for r in natija:
print(f" {r['ism']:<10} {r['maosh']:>12,}")
print()
print(f""" ⭐ TUSHUNTIRISH:
ChegaraOldin: MRO da Chegara birinchi
→ bajar() zanjiri: Chegara → Saralash → Manba
→ QAYTISHDA: Manba → Saralash → Chegara
→ ya'ni saralash chegaradan OLDIN bajariladi ✅
Bu — super() zanjirining muhim xususiyati:
natija TESKARI tartibda qayta ishlanadi.
""")
print("=== 6. Yangi bosqich qo'shish ===\n")
class GuruhlashMixin:
"""⭐ Mavjud kodni O'ZGARTIRMASDAN qo'shildi."""
def __init__(self, *, guruh_kaliti: str = "", **kw):
super().__init__(**kw)
self.guruh_kaliti = guruh_kaliti
def bajar(self, malumot=None) -> list[dict]:
natija = super().bajar(malumot)
if not self.guruh_kaliti:
return natija
guruhlar: dict[Any, list[dict]] = {}
for q in natija:
guruhlar.setdefault(q.get(self.guruh_kaliti), []).append(q)
return [
{
self.guruh_kaliti: k,
"soni": len(v),
"ortacha_maosh": sum(x["maosh"] for x in v) // len(v),
}
for k, v in sorted(guruhlar.items())
]
class HisobotQuvuri(JurnalMixin, GuruhlashMixin, FiltrMixin, Manba):
pass
q3 = HisobotQuvuri(malumot=MALUMOT, guruh_kaliti="shahar", filtr={})
print(f" MRO: {' → '.join(k.__name__.replace('Mixin','') for k in HisobotQuvuri.__mro__[:-2])}\n")
print(f" {'Shahar':<14} {'Soni':>6} {'O`rtacha maosh':>18}")
print(" " + "─" * 40)
for q in q3.bajar():
print(f" {q['shahar']:<14} {q['soni']:>6} {q['ortacha_maosh']:>18,}")
print(f"""
⭐ BU ARXITEKTURA NEGA ISHLAYDI:
1. Har mixin — bitta bosqich, bitta mas'uliyat
2. Har biri super().bajar() ni chaqiradi → zanjir
3. Har biri o'z argumentini NOMLI oladi (**kw uzatiladi)
4. Manba — zanjirning oxiri (super() chaqirmaydi)
5. Yangi bosqich qo'shish MAVJUD KODNI O'ZGARTIRMAYDI
6. Tartib — bajarilish ketma-ketligini belgilaydi
⚠️ NARXI:
• MRO ni tushunish kerak
• Nosozlikni topish qiyinroq (zanjir ko'rinmaydi)
• Tartib hujjatlanishi shart
• Chuqur zanjir → sekinlashish
""")Natijaning muhim qismi:
1. MRO — bosqichlar tartibi:
ToliqQuvur:
ToliqQuvur → Jurnal → Kesh → Chegara → Saralash →
Boyitish → Filtr → Manba
3. To'liq quvur:
Ism Yosh Toifa Yillik
────────────────────────────────────────────
Nilufar 45 katta 108,000,000
Bobur 40 katta 96,000,000
Dilnoza 35 katta 72,000,000
Sardor 28 o'rta 66,000,000
4. ⭐ Kesh ishlashi:
Birinchi chaqiruv:
jurnal: 4 yozuv, 0.06ms
Ikkinchi va uchinchi chaqiruv:
kesh urishlari: 3
=== 6. Yangi bosqich qo'shish ===
Shahar Soni O`rtacha maosh
────────────────────────────────────────
Buxoro 1 6,000,000
Samarqand 2 6,750,000
Toshkent 3 6,166,666Nima ko'rsatdi: 2.4, 2.6, 2.7-bo'limlar.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
| "MRO — chuqurlikka birinchi (DFS)" | C3 linearizatsiyasi |
| "Olmosda ota-sinf ikki marta chaqiriladi" | super() bilan bir marta |
| "Ko'p meros — doim yomon" | Mixin va interfeys uchun to'g'ri |
"class F(A, B) har doim ishlaydi" |
TypeError bo'lishi mumkin |
| "Mixin tartibi ahamiyatsiz" | Xatti-harakatni o'zgartiradi |
| "Mixinlar o'ngda bo'lsin" | Chapda — MRO da ustuvor |
| "MRO ni sinf yaratilganda hisoblab bo'lmaydi" | Hisoblanadi va __mro__ da saqlanadi |
"__bases__ va __mro__ bir xil" |
__bases__ — to'g'ridan-to'g'ri, __mro__ — to'liq |
6. Keng tarqalgan xatolar va yechimlari
1. Asos sinflar tartibi noto'g'ri
class B(A): pass
class F(A, B): pass # ❌ TypeError
class F(B, A): pass # ✅2. Mixin o'ngda
class X(Asos, Mixin): ... # ⚠️ mixin ishlamaydi
class X(Mixin, Asos): ... # ✅3. Mixin super() chaqirmaydi
class Mixin:
def f(self): return "m" # ⚠️ zanjir uziladi
def f(self): return "m" + super().f() # ✅4. Ikki "haqiqiy" sinfdan meros
class Kentavr(Odam, Mashina): ... # ⚠️ holat to'qnashuvi
class Kentavr:
def __init__(self):
self.odam = Odam(...) # ✅ kompozitsiya5. Ota.__init__(self) olmosda
A.__init__(self); B.__init__(self) # ⚠️ Asos ikki marta
super().__init__(**kw) # ✅6. Chuqur olmos
class F(D, E): ... # ⚠️ MRO 8+ sinf7. Mixin nomi noaniq
class Json: ... # ⚠️ mixinmi, sinfmi?
class JsonMixin: ... # ✅8. Mixin shartnomasi hujjatlanmagan
class KeshMixin:
def f(self):
return self._kalit() # ⚠️ qayerdan keladi?7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 8.6, 8.7-darslar (o'tilgan): meros va
super() - 8.9-dars: polimorfizm
- 8.18-dars: ABC — interfeys merosi
- 8.20-dars: kompozitsiya vs meros
- Django:
View,Model,Form— mixin arxitekturasi - DRF:
ListModelMixin,CreateModelMixinva boshqalar - PEP 253: "Subtyping Built-in Types" — C3 ning kirishi
- Maqola: "The Python 2.3 Method Resolution Order" — Michele Simionato
8. Eng yaxshi amaliyotlar
Mixinlarni chapga qo'ying.
class X(Mixin1, Mixin2, Asos).Har mixin
super()ni chaqirsin. Zanjir uzilmasin.Mixin — bitta imkoniyat. Nomida
Mixinbo'lsin.Mixin shartnomasini hujjatlang. Nima talab qiladi, nima qo'shadi, tartib qanday.
MRO uzunligini kuzating. 6 dan oshsa — qayta ko'rib chiqing.
Ikki "haqiqiy" sinfdan meros olmang. Kompozitsiya.
__mro__ni tekshiring. Kutilmagan tartib — muammo belgisi.Ko'p merosli sinfni test qiling. Har kombinatsiya alohida.
9. Amaliy topshiriq
Vazifa 1: MRO ni hisoblang
1. class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
→ D.__mro__ = ?
2. class A: pass
class B(A): pass
class C(B): pass
class D(A, C): pass
→ ?
3. class X: pass
class Y(X): pass
class Z(X): pass
class W(Y, Z): pass
class V(Z, Y): pass
→ W.__mro__ va V.__mro__ = ?
4. class A: pass
class B: pass
class C(A, B): pass
class D(B, A): pass
class E(C, D): pass
→ ?
5. class O: pass
class A(O): pass
class B(O): pass
class C(A, B): pass
class D(B, A): pass
→ C.__mro__ = ?
6. class M: pass
class A(M): pass
class B(M): pass
class C(M): pass
class D(A, B): pass
class E(B, C): pass
class F(D, E): pass
→ F.__mro__ = ?Javoblar
(D, B, C, A, object)-
TypeError—ACdan oldin bo'la olmaydi (CAning avlodi) W: (W, Y, Z, X, object),V: (V, Z, Y, X, object)-
TypeError—CdaA, B,DdaB, A— ziddiyat (C, A, B, O, object)(F, D, A, E, B, C, M, object)
Vazifa 2: Xatolarni tuzating
1. class B(A): pass
class C(A, B): pass
2. class X(Asos, LogMixin, CacheMixin): pass
3. class Mixin:
def f(self): return "mixin"
4. class Kentavr(Odam, Mashina):
def __init__(self, ...):
Odam.__init__(self, ...)
Mashina.__init__(self, ...)
5. class Mixin:
def __init__(self, x):
self.x = x
6. class Json: ... # mixin sifatida ishlatiladi
7. class A(B, C, D, E, F, G): pass
8. class Mixin:
def f(self): return self._yordamchi() # hujjatlanmaganJavoblar
1. class C(B, A): pass
2. class X(LogMixin, CacheMixin, Asos): pass
3. def f(self): return "mixin " + super().f()
4. super().__init__(**kw) bilan hamkorlikdagi meros,
yoki kompozitsiya
5. def __init__(self, *, x=None, **kw):
super().__init__(**kw); self.x = x
6. class JsonMixin: ...
7. MRO juda chuqur — kompozitsiyani ko'rib chiqing
8. Docstring da TALAB QILADI bo'limini qo'shingVazifa 3: C3 algoritmini yozing
merge()funksiyasini yozingc3(sinf)— rekursiv MRO hisoblovchi- Python natijasi bilan solishtiring
TypeErrorholatlarini to'g'ri aniqlasin- Har qadamni tushuntirib chiqarsin
- 10 xil ierarxiyada sinang
Vazifa 4: Mixin to'plami
Yozing:
SerializatsiyaMixin— JSON, YAML, dictTekshiruvMixin— maydonlarni tekshiradiKuzatuvMixin— o'zgarishlar tarixiKeshMixin— hisoblangan qiymatlar- Har biri
super()bilan hamkorlik qilsin - Har biri to'liq hujjatlangan bo'lsin
- Turli kombinatsiyalarni sinang
Vazifa 5: MRO vizualizatori
Vosita yozing:
- Sinf ierarxiyasini ASCII daraxt sifatida chizsin
- MRO ni raqamlar bilan belgilasin
- Har metod qaysi sinfdan kelayotganini ko'rsatsin
super()zanjirini kuzatsin- Potensial ziddiyatlarni belgilasin
TypeErrorsababini tushuntirsin
Vazifa 6: Django uslubidagi ko'rinishlar
Korinishasos sinfiRoyxatMixin,TafsilotMixin,YaratishMixinAutentifikatsiyaMixin,RuxsatMixin- Har biri
super()bilan ulanadi - Xato bo'lsa zanjir to'xtaydi
- Kamida 5 xil kombinatsiya
Vazifa 7: O'ylash
Nega Python 2.3 da MRO algoritmi o'zgartirildi — eski (DFS) algoritm nimasi bilan yomon edi?
Javob
Chunki eski algoritm avlod sinfning qayta aniqlangan metodini "ko'rmasdan" o'tib ketardi.
1. Eski algoritm — chuqurlikka birinchi (DFS)
Python 2.2 gacha MRO shunday hisoblanardi:
Har asos sinf uchun, chapdan o'ngga:
o'sha sinf va uning barcha ota-sinflarini chuqurlikka qo'sh
Takrorlarni olib tashla (BIRINCHI uchraganini qoldirib)Olmos merosi uchun:
class A:
def f(self): return "A.f"
class B(A):
pass
class C(A):
def f(self): return "C.f" # ⭐ qayta aniqlangan
class D(B, C):
passDFS: D → B → A → object → C → A → object
Takrorsiz: D, B, A, object, C
D().f() → 'A.f' ❌ Muammo: C f ni qayta aniqlagan, lekin MRO da A C dan oldin turadi. Ya'ni C.f hech qachon chaqirilmaydi.
2. Nega bu jiddiy muammo
Bu — merosning asosiy va'dasini buzadi:
Avlod sinf ota-sinf metodini qayta aniqlay olishi kerak.
class Ombor:
def saqla(self): return "sekin"
class TezOmbor(Ombor):
def saqla(self): return "tez" # optimizatsiya
class OddiyOmbor(Ombor):
pass
class Mening(OddiyOmbor, TezOmbor):
pass
# Python 2.2: Mening().saqla() → 'sekin' ❌
# Python 2.3: Mening().saqla() → 'tez' ✅Eski algoritmda optimizatsiya jimgina yo'qolardi.
3. Yana bir muammo — monotonlik yo'q
class A: pass
class B: pass
class C(A, B): pass
class D(A, B): pass
class E(C, D): passEski algoritm bilan E ning MRO si C yoki D ning MRO tartibini buzishi mumkin edi. Ya'ni:
Ota-sinfda
XYdan oldin bo'lsa, avlodda ham shunday bo'lishi kerak.
Bu — monotonlik kafolati. Eski algoritmda yo'q edi.
4. C3 linearizatsiyasi
Nomi — 1996 yilgi maqoladan: "A Monotonic Superclass Linearization for Dylan" (Barrett, Cassels, Haahr, Moon, Playford, Withington). Dylan tilida ishlab chiqilgan.
Uch kafolat:
| Kafolat | Ma'nosi |
|---|---|
| Lokal ustuvorlik | class D(B, C) da B C dan oldin |
| Monotonlik | Ota-sinf MRO tartibi buzilmaydi |
| Avlod ustuvorligi | Har sinf o'z ota-sinfidan oldin |
Uchinchisi — eng muhimi. Aynan u DFS muammosini hal qiladi:
D(B, C), B(A), C(A)
C — A ning avlodi → C, A dan OLDIN bo'lishi kerak
Natija: (D, B, C, A, object) ✅5. Narxi — ba'zi ierarxiyalar taqiqlandi
C3 ning muhim oqibati:
class A: pass
class B(A): pass
class F(A, B): pass # ❌ TypeErrorEski algoritmda bu ishlardi (noto'g'ri natija bersa ham):
Python 2.2: F.__mro__ = (F, A, B, object) ⚠️ A, B dan oldin
Python 2.3: TypeErrorBu — yaxshilanish. Endi ziddiyat darhol aniqlanadi, kutilmagan xatti-harakat o'rniga.
6. Boshqa tillar qanday hal qiladi
| Til | Yondashuv |
|---|---|
| Python 3 | C3 linearizatsiyasi |
| Dylan | C3 (asli shu yerdan) |
| Perl 6 / Raku | C3 |
| Java | Ko'p meros yo'q (faqat interfeys) |
| C# | Ko'p meros yo'q |
| C++ | Virtual meros — dasturchi hal qiladi |
| Ruby | Modul (mixin) — chiziqli, olmos yo'q |
| Scala | Trait linearizatsiyasi (C3 ga o'xshash) |
| Go, Rust | Meros yo'q — kompozitsiya va trait |
C++ eng murakkab:
class A { public: int x; };
class B : virtual public A { }; // virtual — bir nusxa
class C : virtual public A { };
class D : public B, public C { }; // A bitta nusxa
// virtual bo'lmasa:
class B : public A { };
class C : public A { };
class D : public B, public C { };
// ⚠️ d.x ikki xil — B::A::x va C::A::x
// Dasturchi d.B::x deb yozishi kerak Python bunday muammoni umuman yo'q qiladi — obyektda A ning bitta nusxasi bo'ladi.
Ruby — boshqa yechim:
module Loggable
def log; "log"; end
end
class Service
include Loggable # modul MRO ga QO'SHILADI
end
Service.ancestors # [Service, Loggable, Object, ...]Ruby da modullar chiziqli qo'shiladi — olmos hosil bo'lmaydi. Lekin bu ko'p merosning to'liq kuchini bermaydi.
7. C3 ning matematik xossalari
C3 — qisman tartibning chiziqli kengaytmasi (linear extension of a partial order).
Ierarxiya — yo'naltirilgan asiklik graf (DAG). C3 uni chiziqli tartibga aylantiradi, shu shartlar bilan:
- Agar
XYning avlodi bo'lsa →XYdan oldin - Agar
class D(B, C)→BCdan oldin - Bu shartlar barcha ota-sinflar uchun ham saqlanadi (monotonlik)
Bunday tartib har doim ham mavjud emas — shuning uchun TypeError.
Misol (ziddiyat):
F(A, B) talab qiladi: A → B
B(A) talab qiladi: B → A
Ikkalasi bir vaqtda mumkin emas → sikl → TypeError8. Amaliy oqibatlar
# ⭐ 1. Qayta aniqlash ISHLAYDI
class Ombor:
def saqla(self): return "sekin"
class TezOmbor(Ombor):
def saqla(self): return "tez"
class Mening(OddiyOmbor, TezOmbor): pass
Mening().saqla() # 'tez' ✅
# ⭐ 2. super() zanjiri BASHORATLI
class A:
def f(self): return "A"
class B(A):
def f(self): return "B" + super().f()
class C(A):
def f(self): return "C" + super().f()
class D(B, C):
def f(self): return "D" + super().f()
D().f() # 'DBCA' — har sinf BIR marta ✅
# ⭐ 3. Ziddiyat DARHOL aniqlanadi
class F(A, B): pass # ❌ TypeError — sinf yaratilishida9. Ish unumdorligi
C3 — sinf yaratilganda bir marta hisoblanadi:
class D(B, C): pass # MRO shu yerda hisoblanadi
D.__mro__ # keshlangan tuple Atribut qidiruvi paytida qayta hisoblanmaydi — shunchaki __mro__ bo'ylab yuriladi. Va CPython 3.11+ da inline caching bor: bir joydan takroriy qidiruv keshlanadi.
10. Nima o'rgandik
| Python 2.2 (DFS) | Python 2.3+ (C3) | |
|---|---|---|
| Qayta aniqlash | Yo'qolishi mumkin | Kafolatlangan |
| Monotonlik | Yo'q | Bor |
| Ziddiyat | Jimgina noto'g'ri natija | TypeError |
| Bashoratlilik | Past | Yuqori |
| Cheklovlar | Yo'q | Ba'zi ierarxiyalar taqiqlangan |
Umumiy dars: ba'zan kamroq ruxsat berish — yaxshiroq. C3 ba'zi ierarxiyalarni taqiqlaydi, lekin ruxsat berganlari to'g'ri ishlaydi.
Guido van Rossum bu haqda:
"Eski MRO ni 'ishlatib bo'ladigan' deb atash mumkin edi, lekin u ko'p merosni ishonchsiz qilardi. C3 bilan ko'p meros — haqiqiy vosita bo'ldi."
Va Michele Simionato (C3 haqidagi rasmiy hujjat muallifi):
"Agar sizning ierarxiyangiz C3 ni 'buzsa', bu ehtimol sizning ierarxiyangiz mantiqan noto'g'ri ekanini bildiradi."
Nimani mustahkamlaydi: 2.3, 2.4, 2.5-bo'limlar.
Xulosa
Bu darsda MRO va ko'p merosni o'rgandik.
Eng muhim uch fikr:
MRO — C3 linearizatsiyasi, chuqurlikka birinchi qidiruv emas. U uch narsani kafolatlaydi: lokal ustuvorlik (asos sinflar tartibi saqlanadi), monotonlik (ota-sinf MRO buzilmaydi) va avlod ustuvorligi — har sinf o'z ota-sinfidan oldin keladi. Aynan uchinchisi olmos merosida qayta aniqlangan metodning yo'qolishiga yo'l qo'ymaydi.
Ba'zi ierarxiyalar mumkin emas.
class B(A)bo'lsa,class F(A, B)—TypeError, chunki "ABdan oldin" va "BAdan oldin" bir vaqtda bajarilmaydi. Qoida: asos sinflar ro'yxatida avlod sinf ota-sinfdan chapda turishi kerak.Mixin — ko'p merosning xavfsiz shakli. Bitta imkoniyat, holatsiz (yoki
super().__init__(**kw)bilan), nomidaMixin, asos sinflar ro'yxatida chapda, va shartnomasi hujjatlangan. Ikki "haqiqiy" sinfdan (ikkalasi ham holat va mantiq olib keladigan) meros olish esa — holat to'qnashuvi va o'lik kod; u yerda kompozitsiya kerak.
Keyingi darsda polimorfizmni ko'ramiz: duck typing, Protocol, virtual asos sinflar va Pythonda "bir interfeys — ko'p amalga oshirish" g'oyasining merosdan mustaqil shakllari.
Izohlar · 0
Izoh yozish uchun kiring.