Python kursi8.8-dars: Ko'p meros va MRO
Python kursi · OOP

8.8-dars: Ko'p meros va MRO

38 daqiqa8/20-dars

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


1. Kirish va motivatsiya

Bu kod ishlaydi:

python
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:

python
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, B

Nega? Va nega bu muhim:

python
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 muhim

Bu darsda:

  • MRO — metod aniqlash tartibi
  • C3 linearizatsiyasi — algoritm qadamma-qadam
  • Nega ba'zi ierarxiyalar TypeError beradi
  • 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.

python
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'rinishida

d.x yozilganda Python:

  1. d.__dict__ da qidiradi
  2. Topilmasa — D.__mro__ bo'ylab tartib bilan: D → B → C → A → object
  3. Birinchi topilgan g'olib

MRO — super() ning ham asosi (8.7-darsda ko'rgan edik).

2.2. Bitta meros — sodda holat

python
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

python
        object
          |
          A
         / \
        B   C
         \ /
          D
python
class 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 OLDIN

Bu 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:

  1. Lokal ustuvorlik — class D(B, C) da B C dan oldin
  2. Monotonlik — avlod MRO si ota-sinf MRO tartibini buzmaydi
  3. 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:

  1. Birinchi ro'yxatning boshini (head) ol
  2. Agar u boshqa hech qaysi ro'yxatning dumida (tail) bo'lmasa — natijaga qo'sh, hamma ro'yxatdan o'chir
  3. Aks holda — keyingi ro'yxatning boshiga o't
  4. Hech qaysi bosh mos kelmasa — TypeError

Misol:

python
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): pass
L[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

python
class A: pass
class B(A): pass
class F(A, B): pass             # ❌ TypeError

Nega:

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:

python
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.

python
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:

  1. Mixin — nomida Mixin bo'lsin (kelishuv)
  2. Bitta aniq imkoniyat — ko'p narsa qilmasin
  3. Mustaqil ishlatilmasin — JsonMixin() ma'nosiz
  4. Holat saqlamasin (ideal holda) — yoki super().__init__() bilan
  5. Asos sinflar ro'yxatida CHAPDA — MRO da oldin bo'lsin
  6. Shartnomani hujjatlang — qanday metodni talab qiladi

Tartib:

python
class X(Mixin1, Mixin2, Asos): ...      # ✅ mixinlar chapda
class X(Asos, Mixin1, Mixin2): ...      # ⚠️ mixinlar Asos ni to'sa olmaydi

MRO chapdan o'ngga — chapdagi ustuvor.

2.7. Ko'p meros: qachon va qachon emas

Xavfsiz holatlar:

python
# 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:

python
# 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 aralashmasi

Amaliy 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

python
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 xil

Metod qayerdan kelgan:

python
next(c for c in D.__mro__ if "f" in c.__dict__)

3. Tez ma'lumotnoma

MRO

python
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 bilan

C3 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 oldin

TypeError

python
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 CHAPDA

Mixin

python
class X(Mixin1, Mixin2, Asos): ...   ✅ mixinlar chapda

Qoidalar:
  • Nomida "Mixin"
  • Bitta imkoniyat
  • Mustaqil ishlatilmaydi
  • super() ni chaqiradi
  • Shartnomani hujjatlang

4. Batafsil misollar

Misol 1 — MRO ni hisoblash

python
"""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:

text
=== 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

python
"""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:

text
=== 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__ chaqirilmadi

Nima ko'rsatdi: 2.6, 2.7-bo'limlar.

Misol 3 — Ko'p meros: qachon va qachon emas

python
"""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:

text
=== ⚠️ 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 → Baza

Nima ko'rsatdi: 2.3, 2.7-bo'limlar.

Misol 4 — Amaliy: plagin tizimi

python
"""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:

text
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,666

Nima 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

python
class B(A): pass
class F(A, B): pass             # ❌ TypeError
class F(B, A): pass             # ✅

2. Mixin o'ngda

python
class X(Asos, Mixin): ...       # ⚠️ mixin ishlamaydi
class X(Mixin, Asos): ...       # ✅

3. Mixin super() chaqirmaydi

python
class Mixin:
    def f(self): return "m"                 # ⚠️ zanjir uziladi
    def f(self): return "m" + super().f()   # ✅

4. Ikki "haqiqiy" sinfdan meros

python
class Kentavr(Odam, Mashina): ...           # ⚠️ holat to'qnashuvi
class Kentavr:
    def __init__(self):
        self.odam = Odam(...)               # ✅ kompozitsiya

5. Ota.__init__(self) olmosda

python
A.__init__(self); B.__init__(self)          # ⚠️ Asos ikki marta
super().__init__(**kw)                      # ✅

6. Chuqur olmos

python
class F(D, E): ...                          # ⚠️ MRO 8+ sinf

7. Mixin nomi noaniq

python
class Json: ...                             # ⚠️ mixinmi, sinfmi?
class JsonMixin: ...                        # ✅

8. Mixin shartnomasi hujjatlanmagan

python
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, CreateModelMixin va boshqalar
  • PEP 253: "Subtyping Built-in Types" — C3 ning kirishi
  • Maqola: "The Python 2.3 Method Resolution Order" — Michele Simionato

8. Eng yaxshi amaliyotlar

  1. Mixinlarni chapga qo'ying. class X(Mixin1, Mixin2, Asos).

  2. Har mixin super() ni chaqirsin. Zanjir uzilmasin.

  3. Mixin — bitta imkoniyat. Nomida Mixin bo'lsin.

  4. Mixin shartnomasini hujjatlang. Nima talab qiladi, nima qo'shadi, tartib qanday.

  5. MRO uzunligini kuzating. 6 dan oshsa — qayta ko'rib chiqing.

  6. Ikki "haqiqiy" sinfdan meros olmang. Kompozitsiya.

  7. __mro__ ni tekshiring. Kutilmagan tartib — muammo belgisi.

  8. Ko'p merosli sinfni test qiling. Har kombinatsiya alohida.


9. Amaliy topshiriq

Vazifa 1: MRO ni hisoblang

python
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
  1. (D, B, C, A, object)
  2. TypeError — A C dan oldin bo'la olmaydi (C A ning avlodi)
  3. W: (W, Y, Z, X, object), V: (V, Z, Y, X, object)
  4. TypeError — C da A, B, D da B, A — ziddiyat
  5. (C, A, B, O, object)
  6. (F, D, A, E, B, C, M, object)

Vazifa 2: Xatolarni tuzating

python
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()   # hujjatlanmagan
Javoblar
python
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'shing

Vazifa 3: C3 algoritmini yozing

  1. merge() funksiyasini yozing
  2. c3(sinf) — rekursiv MRO hisoblovchi
  3. Python natijasi bilan solishtiring
  4. TypeError holatlarini to'g'ri aniqlasin
  5. Har qadamni tushuntirib chiqarsin
  6. 10 xil ierarxiyada sinang

Vazifa 4: Mixin to'plami

Yozing:

  1. SerializatsiyaMixin — JSON, YAML, dict
  2. TekshiruvMixin — maydonlarni tekshiradi
  3. KuzatuvMixin — o'zgarishlar tarixi
  4. KeshMixin — hisoblangan qiymatlar
  5. Har biri super() bilan hamkorlik qilsin
  6. Har biri to'liq hujjatlangan bo'lsin
  7. Turli kombinatsiyalarni sinang

Vazifa 5: MRO vizualizatori

Vosita yozing:

  1. Sinf ierarxiyasini ASCII daraxt sifatida chizsin
  2. MRO ni raqamlar bilan belgilasin
  3. Har metod qaysi sinfdan kelayotganini ko'rsatsin
  4. super() zanjirini kuzatsin
  5. Potensial ziddiyatlarni belgilasin
  6. TypeError sababini tushuntirsin

Vazifa 6: Django uslubidagi ko'rinishlar

  1. Korinish asos sinfi
  2. RoyxatMixin, TafsilotMixin, YaratishMixin
  3. AutentifikatsiyaMixin, RuxsatMixin
  4. Har biri super() bilan ulanadi
  5. Xato bo'lsa zanjir to'xtaydi
  6. 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:

python
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):
    pass
DFS: 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.

python
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

python
class A: pass
class B: pass
class C(A, B): pass
class D(A, B): pass
class E(C, D): pass

Eski algoritm bilan E ning MRO si C yoki D ning MRO tartibini buzishi mumkin edi. Ya'ni:

Ota-sinfda X Y dan 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:

python
class A: pass
class B(A): pass
class F(A, B): pass             # ❌ TypeError

Eski 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: TypeError

Bu — 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:

cpp
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:

ruby
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:

  1. Agar X Y ning avlodi bo'lsa → X Y dan oldin
  2. Agar class D(B, C) → B C dan oldin
  3. 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 → TypeError

8. Amaliy oqibatlar

python
# ⭐ 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 yaratilishida

9. Ish unumdorligi

C3 — sinf yaratilganda bir marta hisoblanadi:

python
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:

  1. 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.

  2. Ba'zi ierarxiyalar mumkin emas. class B(A) bo'lsa, class F(A, B) — TypeError, chunki "A B dan oldin" va "B A dan oldin" bir vaqtda bajarilmaydi. Qoida: asos sinflar ro'yxatida avlod sinf ota-sinfdan chapda turishi kerak.

  3. Mixin — ko'p merosning xavfsiz shakli. Bitta imkoniyat, holatsiz (yoki super().__init__(**kw) bilan), nomida Mixin, 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.

OOP · 8-dars yakunlandi

8.8-dars: Ko'p meros va MRO

38 daqvaqt
0belgi
Keyingi dars: 8.9-dars: Polimorfizm
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0