Python kursi8.18-dars: Abstrakt klasslar (ABC)
Python kursi · OOP

8.18-dars: Abstrakt klasslar (ABC)

41 daqiqa18/20-dars

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


1. Kirish va motivatsiya

Bu sinf "shartnoma" bo'lishi kerak edi:

python
class Ombor:
    def saqla(self, k, v):
        raise NotImplementedError

    def olish(self, k):
        raise NotImplementedError

Lekin himoya yo'q:

python
o = Ombor()                     # ⚠️ yaratildi!
o.saqla("a", 1)                 # ❌ faqat SHU YERDA xato

class Chala(Ombor):
    def saqla(self, k, v): ...
    # olish YO'Q

c = Chala()                     # ⚠️ yaratildi!
c.olish("a")                    # ❌ ishlatilganda xato

ABC bilan — xato darhol:

python
from abc import ABC, abstractmethod

class Ombor(ABC):
    @abstractmethod
    def saqla(self, k, v): ...
    @abstractmethod
    def olish(self, k): ...


Ombor()                         # ❌ TypeError: abstract methods
Chala()                         # ❌ TypeError: abstract method 'olish'

Xato yaratish paytida, ishlatish paytida emas.

Bu darsda:

  • ABC, @abstractmethod va nusxa yaratish nazorati
  • abstractproperty o'rniga to'g'ri kombinatsiyalar
  • register() — virtual avlodlar
  • __subclasshook__ — avtomatik tanish
  • collections.abc — 25 tayyor ABC
  • ABC vs Protocol — qachon qaysi

2. Nazariya — chuqur tushuntirish

2.1. Asosiy sintaksis

python
from abc import ABC, abstractmethod

class Shakl(ABC):
    @abstractmethod
    def yuza(self) -> float:
        """Har avlod MAJBURIY amalga oshiradi."""

    def tavsif(self) -> str:                    # ⭐ oddiy metod
        return f"{type(self).__name__}: {self.yuza():.2f}"

Ikki yozish usuli:

python
class A(ABC): ...                               # ✅ oddiy

from abc import ABCMeta
class A(metaclass=ABCMeta): ...                 # ✅ bir xil

ABC — shunchaki class ABC(metaclass=ABCMeta).

Mexanizm:

python
Shakl.__abstractmethods__                       # frozenset({'yuza'})

Nusxa yaratishni esa object.__new__ rad etadi (C darajasida). Mantiqan u quyidagicha ishlaydi:

python
# object.__new__ ichida (soddalashtirilgan)
if cls.__abstractmethods__:
    raise TypeError(
        f"Can't instantiate abstract class {cls.__name__} "
        f"without an implementation for abstract method 'yuza'"
    )

ABCMeta da __call__ metodi yo'q — uning vazifasi faqat sinf yaratilayotganda __abstractmethods__ ni hisoblab qo'yish. Tekshiruvning o'zi object.__new__ da:

python
class Oddiy: pass                               # ABCMeta YO'Q
Oddiy.__abstractmethods__ = frozenset({"x"})
Oddiy()        # TypeError: Can't instantiate abstract class Oddiy ...

2.2. Faqat metaklass tekshiradi

python
class Yolgon:                                   # ⚠️ ABC EMAS
    @abstractmethod
    def f(self): ...

Yolgon()                        # ⚠️ YARATILADI!

@abstractmethod faqat __isabstractmethod__ = True bayrog'ini qo'yadi. Bayroqli metodlarni ABCMeta yig'adi, nusxa yaratishni esa object.__new__ rad etadi.

python
def f(): ...
f.__isabstractmethod__                          # AttributeError

@abstractmethod
def g(): ...
g.__isabstractmethod__                          # True

2.3. Kombinatsiyalar

python
class A(ABC):
    @property
    @abstractmethod
    def x(self) -> int: ...                     # ⭐ tartib muhim

    @classmethod
    @abstractmethod
    def yarat(cls): ...

    @staticmethod
    @abstractmethod
    def tekshir(q): ...

@abstractmethod eng ichkarida bo'lishi kerak:

python
@abstractmethod
@property                       # ❌ noto'g'ri
def x(self): ...

@property
@abstractmethod                 # ✅ to'g'ri
def x(self): ...

abstractproperty, abstractclassmethod, abstractstaticmethod — eskirgan (3.3 dan).

2.4. Abstrakt metodda kod bo'lishi mumkin

python
class Ombor(ABC):
    @abstractmethod
    def saqla(self, k, v) -> None:
        """⭐ Sukut amalga oshirish — super() bilan chaqiriladi."""
        if not isinstance(k, str):
            raise TypeError("Kalit satr bo'lsin")


class FaylOmbor(Ombor):
    def saqla(self, k, v):
        super().saqla(k, v)                     # ⭐ tekshiruvni ishlatish
        ...

Bu — "shablon" naqshi: abstrakt metod umumiy tekshiruvni beradi.

2.5. register() — virtual avlodlar

python
class Chizilar(ABC):
    @abstractmethod
    def chiz(self): ...


class Boshqa:                                   # meros YO'Q
    def chiz(self): return "chizildi"


Chizilar.register(Boshqa)                       # ⭐

isinstance(Boshqa(), Chizilar)                  # True ✅
issubclass(Boshqa, Chizilar)                    # True ✅
Boshqa.__mro__                                  # (Boshqa, object)  ⚠️ Chizilar YO'Q

Uch muhim cheklov:

  1. Tekshirmaydi — metod bo'lmasa ham True
  2. Metodlar meros olinmaydi — sukut amalga oshirishlar mavjud emas
  3. MRO ga kirmaydi — super() ishlamaydi
python
Chizilar.register(BoshMasSinf)                  # ⚠️ hech narsa tekshirilmadi
isinstance(BoshMasSinf(), Chizilar)             # True ⚠️
BoshMasSinf().chiz()                            # ❌ AttributeError

Dekorator sifatida:

python
@Chizilar.register
class Boshqa2:
    def chiz(self): ...

2.6. __subclasshook__ — avtomatik tanish

python
class Chizilar(ABC):
    @classmethod
    def __subclasshook__(cls, C):
        if cls is Chizilar:                     # ⭐ faqat o'zi uchun
            return any("chiz" in B.__dict__ for B in C.__mro__)
        return NotImplemented                   # ⭐ oddiy tekshiruvga

    @abstractmethod
    def chiz(self): ...


class Boshqa:
    def chiz(self): ...

isinstance(Boshqa(), Chizilar)                  # True ✅ avtomatik

Uch qaytarish qiymati:

Qaytaradi Ma'nosi
True Avlod
False Avlod emas
NotImplemented Oddiy tekshiruvga (meros, register)

if cls is Chizilar — shart: aks holda avlodlar ham shu tekshiruvni ishlatardi.

Bu — collections.abc ishlash usuli.

2.7. collections.abc — 25 tayyor ABC

Asosiy ierarxiya:

Container       __contains__
Hashable        __hash__
Iterable        __iter__
 └── Iterator   + __next__
      └── Generator  + send, throw, close
Reversible      __reversed__
Sized           __len__
Callable        __call__

Collection      = Sized + Iterable + Container
 ├── Sequence           __getitem__, __len__
 │    └── MutableSequence   + __setitem__, __delitem__, insert
 ├── Mapping            __getitem__, __len__, __iter__
 │    └── MutableMapping    + __setitem__, __delitem__
 └── Set                __contains__, __len__, __iter__
      └── MutableSet        + add, discard

Qo'shimchalar: Awaitable, Coroutine, AsyncIterable, AsyncIterator, AsyncGenerator, MappingView, KeysView, ItemsView, ValuesView, Buffer (3.12+).

Ikki xil ishlatish:

python
# 1. Meros — metodlar bepul
class MeningRoyxatim(Sequence):
    def __getitem__(self, i): ...
    def __len__(self): ...
    # __contains__, __iter__, index, count BEPUL

# 2. isinstance — protokol tekshiruvi
isinstance([1, 2], Sequence)                    # True
isinstance("ab", Sequence)                      # True
isinstance({1: 2}, Mapping)                     # True

2.8. ABC vs Protocol

ABC Protocol
Meros Majburiy (yoki register) Kerak emas
Tekshiruv Nusxa yaratishda mypy (statik)
Sukut metodlar Meros olinadi Faqat meros olsangiz
isinstance Har doim @runtime_checkable bilan
Imzo tekshiruvi mypy
Tashqi sinflar register() Avtomatik
Ish vaqti narxi ABCMeta Yo'q

Amaliy qoida:

  • O'z ierarxiyangiz + umumiy kod → ABC
  • Tashqi kod bilan interfeys → Protocol
  • Ikkalasi — normal

3. Tez ma'lumotnoma

Asosiy

python
from abc import ABC, abstractmethod

class A(ABC):
    @abstractmethod
    def f(self): ...            majburiy

    def g(self): ...            meros olinadi

A()                             ❌ TypeError
A.__abstractmethods__           frozenset({'f'})

Kombinatsiyalar (@abstractmethod — ichkarida)

python
@property
@abstractmethod
def x(self): ...

@classmethod
@abstractmethod
def yarat(cls): ...

@staticmethod
@abstractmethod
def tekshir(q): ...

register()

python
A.register(Boshqa)              virtual avlod
isinstance(Boshqa(), A)         True
Boshqa.__mro__                  ⚠️ A YO'Q

⚠️ Tekshirmaydi, metodlar meros olinmaydi, super() yo'q

subclasshook

python
@classmethod
def __subclasshook__(cls, C):
    if cls is A:                            ⭐ shart
        return any("f" in B.__dict__ for B in C.__mro__)
    return NotImplemented                   ⭐ oddiy tekshiruvga

collections.abc

Sequence         → __getitem__, __len__
MutableSequence  → + __setitem__, __delitem__, insert
Mapping          → __getitem__, __len__, __iter__
Set              → __contains__, __len__, __iter__

4. Batafsil misollar

Misol 1 — ABC asoslari

python
"""Abstrakt metodlar va nusxa yaratish nazorati."""

from abc import ABC, ABCMeta, abstractmethod

print("=== 1. Nusxa yaratish nazorati ===\n")


class OmborNotogri:
    """⚠️ ABC EMAS — himoya yo'q."""

    def saqla(self, k, v):
        raise NotImplementedError

    def olish(self, k):
        raise NotImplementedError


class Ombor(ABC):
    """✅ ABC — nusxa yaratish nazorat qilinadi."""

    @abstractmethod
    def saqla(self, k: str, v) -> None:
        """Qiymatni saqlaydi."""

    @abstractmethod
    def olish(self, k: str):
        """Qiymatni oladi."""

    def olish_yoki(self, k: str, sukut=None):
        """⭐ Oddiy metod — meros olinadi."""
        try:
            return self.olish(k)
        except KeyError:
            return sukut

    def kop_saqla(self, m: dict) -> None:
        for k, v in m.items():
            self.saqla(k, v)


print(f"  OmborNotogri():")
o = OmborNotogri()
print(f"    ⚠️ Yaratildi: {o}")
try:
    o.saqla("a", 1)
except NotImplementedError:
    print(f"    ❌ NotImplementedError — faqat ISHLATILGANDA\n")

print(f"  Ombor():")
try:
    Ombor()
except TypeError as e:
    print(f"    ✅ TypeError: {str(e)[:66]}")

print(f"\n  Ombor.__abstractmethods__ = {Ombor.__abstractmethods__}")


print("\n=== 2. Chala amalga oshirish ===\n")


class Chala(Ombor):
    def saqla(self, k, v):
        pass
    # olish YO'Q


class Toliq(Ombor):
    def __init__(self):
        self._d = {}

    def saqla(self, k, v):
        self._d[k] = v

    def olish(self, k):
        return self._d[k]


for Sinf in (Chala, Toliq):
    print(f"  {Sinf.__name__}:")
    print(f"    __abstractmethods__ = {set(Sinf.__abstractmethods__) or '{}'}")
    try:
        o = Sinf()
        print(f"    ✅ Yaratildi")
    except TypeError as e:
        print(f"    ❌ TypeError: {str(e)[:60]}")

print(f"\n  Toliq bepul metodlarni oldi:")
t = Toliq()
t.kop_saqla({"a": 1, "b": 2})
print(f"    t.kop_saqla({{'a':1, 'b':2}})")
print(f"    t.olish('a')          = {t.olish('a')}")
print(f"    t.olish_yoki('yoq', 0) = {t.olish_yoki('yoq', 0)}")


print("\n\n=== ⚠️ 3. @abstractmethod — faqat bayroq ===\n")


class Yolgon:
    """⚠️ metaclass=ABCMeta YO'Q."""

    @abstractmethod
    def f(self): ...


y = Yolgon()
print(f"  class Yolgon:  (ABC emas)")
print(f"    Yolgon() → ⚠️ yaratildi: {y}")
print(f"    hasattr(Yolgon, '__abstractmethods__') = "
      f"{hasattr(Yolgon, '__abstractmethods__')}")

print(f"\n  ⭐ @abstractmethod nima qiladi:")


def oddiy(): ...


@abstractmethod
def abstrakt(): ...


for f in (oddiy, abstrakt):
    bayroq = getattr(f, "__isabstractmethod__", "— (yo'q)")
    print(f"    {f.__name__:<10} __isabstractmethod__ = {bayroq}")

print(f"""
  ⭐ @abstractmethod FAQAT bayroq qo'yadi.
     ABCMeta sinf yaratilganda __abstractmethods__ ni hisoblaydi,
     nusxa yaratishni esa object.__new__ rad etadi:

       if cls.__abstractmethods__:
           raise TypeError(...)

  ⚠️ ABC dan meros olmasangiz — himoya YO'Q.
""")

print(f"  Ikki teng yozuv:")
print(f"    class A(ABC): ...")
print(f"    class A(metaclass=ABCMeta): ...")
print(f"\n    ABC.__mro__  = {[c.__name__ for c in ABC.__mro__]}")
print(f"    type(ABC)    = {type(ABC).__name__}")


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


class ToliqABC(ABC):
    @abstractmethod
    def oddiy_metod(self): ...

    @property
    @abstractmethod
    def xususiyat(self) -> int:
        """⭐ @property TASHQARIDA."""

    @classmethod
    @abstractmethod
    def fabrika(cls): ...

    @staticmethod
    @abstractmethod
    def yordamchi(q): ...


print(f"  Abstrakt a'zolar: {sorted(ToliqABC.__abstractmethods__)}\n")

print(f"  {'Nom':<16} {'Turi':<18} {'Abstraktmi'}")
print("  " + "─" * 48)
for nom in sorted(ToliqABC.__abstractmethods__):
    q = ToliqABC.__dict__[nom]
    abs_ = getattr(q, "__isabstractmethod__", False)
    print(f"  {nom:<16} {type(q).__name__:<18} {abs_}")


class ToliqAmalga(ToliqABC):
    def oddiy_metod(self): return "metod"

    @property
    def xususiyat(self): return 42

    @classmethod
    def fabrika(cls): return cls()

    @staticmethod
    def yordamchi(q): return q * 2


t = ToliqAmalga()
print(f"\n  Amalga oshirilgan:")
print(f"    t.oddiy_metod()          = {t.oddiy_metod()!r}")
print(f"    t.xususiyat              = {t.xususiyat}")
print(f"    ToliqAmalga.fabrika()    = {ToliqAmalga.fabrika()}")
print(f"    ToliqAmalga.yordamchi(5) = {ToliqAmalga.yordamchi(5)}")

print(f"\n  ⚠️ Dekorator TARTIBI:")
print(f"     @property        ✅ tashqarida")
print(f"     @abstractmethod  ✅ ichkarida")

print(f"\n  Eskirgan (3.3 dan):")
for nom in ["abstractproperty", "abstractclassmethod",
            "abstractstaticmethod"]:
    print(f"    ⚠️ abc.{nom}")


print("\n=== 5. Abstrakt metodda kod ===\n")


class Quvur(ABC):
    """⭐ Abstrakt metod umumiy tekshiruv beradi."""

    @abstractmethod
    def bajar(self, malumot: list) -> list:
        """Avlodlar super().bajar(malumot) ni chaqirishi mumkin."""
        if not isinstance(malumot, list):
            raise TypeError(f"list kutildi: {type(malumot).__name__}")
        if not malumot:
            raise ValueError("Bo'sh ma'lumot")
        return malumot                          # ⭐ tekshirilgan


class Saralash(Quvur):
    def bajar(self, malumot):
        malumot = super().bajar(malumot)        # ⭐ tekshiruv
        return sorted(malumot)


class Filtr(Quvur):
    def __init__(self, shart):
        self.shart = shart

    def bajar(self, malumot):
        malumot = super().bajar(malumot)
        return [x for x in malumot if self.shart(x)]


class Buzilgan(Quvur):
    def bajar(self, malumot):
        return malumot[::-1]                    # ⚠️ super() yo'q


MALUMOT = [3, 1, 4, 1, 5, 9, 2, 6]

print(f"  Kirish: {MALUMOT}\n")
print(f"    Saralash: {Saralash().bajar(MALUMOT)}")
print(f"    Filtr(>3): {Filtr(lambda x: x > 3).bajar(MALUMOT)}")

print(f"\n  Tekshiruv (super() bilan):")
for Sinf, kirish in [(Saralash, "matn"), (Saralash, []),
                     (Buzilgan, "matn")]:
    o = Sinf() if Sinf is not Filtr else Sinf(lambda x: True)
    try:
        n = f"⚠️ o'tdi: {o.bajar(kirish)!r}"
    except (TypeError, ValueError) as e:
        n = f"✅ {type(e).__name__}: {e}"
    print(f"    {Sinf.__name__}.bajar({kirish!r:<8}) → {n}")

print(f"""
  ⭐ NAQSH: abstrakt metodda UMUMIY tekshiruv,
     avlodlar super() bilan ishlatadi.

  ⚠️ Lekin MAJBURIY emas — Buzilgan super() ni chaqirmadi.
     Majburlash uchun shablon metod naqshi kerak (8.6-dars).
""")


print("=== 6. Ko'p daraja ===\n")


class Daraja1(ABC):
    @abstractmethod
    def a(self): ...

    @abstractmethod
    def b(self): ...


class Daraja2(Daraja1):
    """⭐ Faqat bir qismini amalga oshiradi — hali abstrakt."""

    def a(self): return "Daraja2.a"

    @abstractmethod
    def c(self): ...                            # ⭐ yangi abstrakt


class Daraja3(Daraja2):
    def b(self): return "Daraja3.b"
    def c(self): return "Daraja3.c"


print(f"  {'Sinf':<12} {'Abstrakt a`zolar':<28} {'Yaratsa bo`ladi'}")
print("  " + "─" * 56)
for S in (Daraja1, Daraja2, Daraja3):
    a = sorted(S.__abstractmethods__)
    try:
        S(); ok = "✅"
    except TypeError:
        ok = "❌"
    print(f"  {S.__name__:<12} {str(a):<28} {ok}")

d = Daraja3()
print(f"\n  Daraja3(): a={d.a()!r}, b={d.b()!r}, c={d.c()!r}")

print(f"""
  ⭐ Oraliq abstrakt sinf:
     • Ba'zi metodlarni amalga oshiradi
     • Yangi abstrakt metod qo'shishi mumkin
     • O'zi hali abstrakt qoladi
""")

Natijaning muhim qismi:

text
=== 1. Nusxa yaratish nazorati ===

  OmborNotogri():
    ⚠️ Yaratildi: <__main__.OmborNotogri object at 0x...>
    ❌ NotImplementedError — faqat ISHLATILGANDA

  Ombor():
    ✅ TypeError: Can't instantiate abstract class Ombor without an
  Ombor.__abstractmethods__ = frozenset({'saqla', 'olish'})

=== ⚠️ 3. @abstractmethod — faqat bayroq ===

  class Yolgon:  (ABC emas)
    Yolgon() → ⚠️ yaratildi

    oddiy      __isabstractmethod__ = — (yo'q)
    abstrakt   __isabstractmethod__ = True

=== 6. Ko'p daraja ===

  Sinf         Abstrakt a`zolar             Yaratsa bo`ladi
  ────────────────────────────────────────────────────────
  Daraja1      ['a', 'b']                   ❌
  Daraja2      ['b', 'c']                   ❌
  Daraja3      []                           ✅

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

Misol 2 — register() va __subclasshook__

python
"""Virtual avlodlar va avtomatik tanish."""

from abc import ABC, abstractmethod
from collections.abc import (Sized, Iterable, Container, Hashable,
                             Callable, Collection, Sequence, Mapping,
                             Set, MutableSequence, MutableMapping)

print("=== ⭐ 1. register() ===\n")


class Chizilar(ABC):
    @abstractmethod
    def chiz(self) -> str: ...

    def ikki_marta(self) -> str:
        """⭐ Sukut metod."""
        return self.chiz() * 2


class Meros(Chizilar):
    """✅ Meros olgan."""
    def chiz(self): return "M"


class Virtual:
    """⭐ Meros OLMAGAN, lekin ro'yxatga olinadi."""
    def chiz(self): return "V"


class Yolgon:
    """⚠️ chiz() metodi YO'Q."""
    pass


Chizilar.register(Virtual)
Chizilar.register(Yolgon)                       # ⚠️ tekshirilmaydi!


@Chizilar.register                              # ⭐ dekorator sifatida
class Dekorator:
    def chiz(self): return "D"


SINFLAR = [Meros, Virtual, Yolgon, Dekorator]

print(f"  {'Sinf':<12} {'isinstance':<12} {'MRO da bormi':<14} "
      f"{'chiz()':<10} {'ikki_marta()'}")
print("  " + "─" * 66)
for S in SINFLAR:
    o = S()
    inst = isinstance(o, Chizilar)
    mro = Chizilar in S.__mro__
    try:
        c = repr(o.chiz())
    except AttributeError:
        c = "❌"
    try:
        i = repr(o.ikki_marta())
    except AttributeError:
        i = "❌ AttributeError"
    print(f"  {S.__name__:<12} {inst!s:<12} {mro!s:<14} {c:<10} {i}")

print(f"""
  ⚠️ register() UCH CHEKLOVI:

     1. TEKSHIRMAYDI — Yolgon da chiz() yo'q, lekin isinstance True
     2. METODLAR MEROS OLINMAYDI — ikki_marta() yo'q
     3. MRO GA KIRMAYDI — super() ishlamaydi

  ⭐ register() FAQAT isinstance/issubclass uchun.
""")

print(f"  MRO lar:")
for S in SINFLAR:
    print(f"    {S.__name__:<12} {[c.__name__ for c in S.__mro__]}")


print("\n\n=== ⭐ 2. __subclasshook__ ===\n")


class AvtoChizilar(ABC):
    """⭐ chiz() bo'lgan HAR sinfni tanadi."""

    @classmethod
    def __subclasshook__(cls, C):
        if cls is AvtoChizilar:                 # ⭐ SHART
            return any("chiz" in B.__dict__ for B in C.__mro__)
        return NotImplemented                   # ⭐ oddiy tekshiruvga

    @abstractmethod
    def chiz(self) -> str: ...


class Avlod(AvtoChizilar):
    """⭐ Meros olgan — sukut metodlar bor."""
    def chiz(self): return "A"


TEKSHIRUV = [Meros(), Virtual(), Yolgon(), Dekorator(), Avlod(),
             "matn", [1, 2], 42]

print(f"  {'Obyekt':<14} {'chiz() bor':<14} {'isinstance'}")
print("  " + "─" * 46)
for o in TEKSHIRUV:
    bor = hasattr(o, "chiz")
    inst = isinstance(o, AvtoChizilar)
    nom = type(o).__name__
    belgi = "✅" if bor == inst else "⚠️"
    print(f"  {nom:<14} {bor!s:<14} {inst!s}  {belgi}")

print(f"""
  ⭐ __subclasshook__ QAYTARISH QIYMATLARI:

     True            → avlod
     False           → avlod emas
     NotImplemented  → ⭐ oddiy tekshiruvga (meros, register)

  ⚠️ `if cls is AvtoChizilar` SHART — aks holda
     avlodlar ham shu tekshiruvni ishlatardi:
""")


class YomonHook(ABC):
    @classmethod
    def __subclasshook__(cls, C):
        return any("f" in B.__dict__ for B in C.__mro__)   # ⚠️ cls yo'q

    @abstractmethod
    def f(self): ...


class MaxsusYomon(YomonHook):
    def f(self): ...

    @abstractmethod
    def g(self): ...                            # ⭐ yangi talab


class FaqatF:
    def f(self): ...


print(f"    isinstance(FaqatF(), YomonHook)     = "
      f"{isinstance(FaqatF(), YomonHook)}")
print(f"    isinstance(FaqatF(), MaxsusYomon)   = "
      f"{isinstance(FaqatF(), MaxsusYomon)}   "
      f"⚠️ g() yo'q, lekin True!")


print("\n\n=== 3. collections.abc — protokollar ===\n")

PROTOKOLLAR = [Sized, Iterable, Container, Hashable, Callable,
               Collection, Sequence, Mapping, Set]

OBYEKTLAR = [
    ("list", [1, 2]),
    ("tuple", (1, 2)),
    ("str", "ab"),
    ("dict", {"a": 1}),
    ("set", {1, 2}),
    ("frozenset", frozenset({1})),
    ("range", range(3)),
    ("generator", (x for x in [1])),
    ("int", 42),
    ("funksiya", print),
]

print(f"  {'Obyekt':<12} " +
      " ".join(f"{P.__name__[:8]:<9}" for P in PROTOKOLLAR))
print("  " + "─" * 96)
for nom, o in OBYEKTLAR:
    qatorlar = ["✅" if isinstance(o, P) else "  " for P in PROTOKOLLAR]
    print(f"  {nom:<12} " + " ".join(f"{q:<9}" for q in qatorlar))

print(f"""
  ⭐ KUZATUVLAR:
     • str — Sequence ✅, lekin MutableSequence ❌
     • dict — Mapping va Collection ✅
     • generator — Iterable ✅, Sized ❌ (uzunligi noma'lum)
     • int — faqat Hashable
     • funksiya — Callable va Hashable
""")


print("=== 4. Meros — metodlar bepul ===\n")


class QoldaRoyxat:
    """⚠️ Hammasi qo'lda."""
    def __init__(self, el): self._el = list(el)
    def __getitem__(self, i): return self._el[i]
    def __len__(self): return len(self._el)


class AbcRoyxat(Sequence):
    """✅ Sequence dan meros."""
    def __init__(self, el): self._el = list(el)
    def __getitem__(self, i): return self._el[i]
    def __len__(self): return len(self._el)


class AbcMutable(MutableSequence):
    """✅ 5 metod → to'liq ro'yxat."""
    def __init__(self, el=()): self._el = list(el)
    def __getitem__(self, i): return self._el[i]
    def __setitem__(self, i, q): self._el[i] = q
    def __delitem__(self, i): del self._el[i]
    def __len__(self): return len(self._el)
    def insert(self, i, q): self._el.insert(i, q)
    def __repr__(self): return f"AbcMutable({self._el})"


METODLAR = ["__contains__", "__iter__", "__reversed__", "index",
            "count", "append", "extend", "pop", "remove", "reverse",
            "__iadd__"]

print(f"  {'Metod':<16} {'Qo`lda':<10} {'Sequence':<12} "
      f"{'MutableSequence'}")
print("  " + "─" * 56)
for m in METODLAR:
    q = "✅" if hasattr(QoldaRoyxat, m) else "❌"
    s = "✅" if hasattr(AbcRoyxat, m) else "❌"
    ms = "✅" if hasattr(AbcMutable, m) else "❌"
    print(f"  {m:<16} {q:<10} {s:<12} {ms}")

print(f"\n  MutableSequence bepul metodlari amalda:")
a = AbcMutable([3, 1, 2])
print(f"    a = {a}")
for kod, f in [
    ("a.append(4)",     lambda: a.append(4)),
    ("a.extend([5,6])", lambda: a.extend([5, 6])),
    ("a.remove(1)",     lambda: a.remove(1)),
    ("a.pop()",         lambda: a.pop()),
    ("a.reverse()",     lambda: a.reverse()),
    ("a += [9]",        lambda: a.__iadd__([9])),
]:
    f()
    print(f"    {kod:<18} → {a}")

print(f"\n  Talab qilinadigan metodlar:")
for ABC_ in (Sequence, MutableSequence, Mapping, MutableMapping, Set):
    print(f"    {ABC_.__name__:<18} {sorted(ABC_.__abstractmethods__)}")


print("\n\n=== 5. Set ABC — to'plam amallari bepul ===\n")


class Diapazon(Set):
    """⭐ Elementlar SAQLANMAYDI."""

    def __init__(self, b, t): self.b, self.t = b, t

    def __contains__(self, x):
        return isinstance(x, int) and self.b <= x < self.t

    def __iter__(self):
        return iter(range(self.b, self.t))

    def __len__(self):
        return max(0, self.t - self.b)

    def __repr__(self):
        return f"Diapazon({self.b}, {self.t})"

    # ⚠️ Set mixin metodlari (&, |, -, ^) natijani cls._from_iterable(it)
    #    orqali yasaydi, u esa sukut bo'yicha cls(it) ni chaqiradi.
    #    Diapazon(it) — noto'g'ri imzo (b va t kerak) → TypeError.
    #    Konstruktor bitta iterable qabul qilmasa, buni qayta aniqlang:
    @classmethod
    def _from_iterable(cls, it):
        return frozenset(it)


d1, d2 = Diapazon(0, 10), Diapazon(5, 15)

print(f"  d1 = {d1}, d2 = {d2}\n")
print(f"  Uch metod yozdik, bepul olindi:\n")

for kod, f in [
    ("d1 & d2",         lambda: sorted(d1 & d2)),
    ("d1 | d2",         lambda: len(d1 | d2)),
    ("d1 - d2",         lambda: sorted(d1 - d2)),
    ("d1 ^ d2",         lambda: len(d1 ^ d2)),
    ("d1 <= d2",        lambda: d1 <= d2),
    ("d1 < Diapazon(0,20)", lambda: d1 < Diapazon(0, 20)),
    ("d1.isdisjoint(Diapazon(20,30))",
     lambda: d1.isdisjoint(Diapazon(20, 30))),
    ("d1 & {1, 2, 99}",  lambda: sorted(d1 & {1, 2, 99})),
]:
    print(f"    {kod:<34} → {f()!r}")

import sys
print(f"\n  ⭐ Xotira: Diapazon(0, 1000000) = "
      f"{sys.getsizeof(Diapazon(0, 1_000_000))} bayt")
print(f"     set(range(1000000))          = "
      f"{sys.getsizeof(set(range(1_000_000))) / 1_048_576:.0f} MB "
      f"(faqat jadval, int obyektlarisiz)")

print(f"""
  ⚠️ TUZOQ: _from_iterable yozilmasa, d1 & d2 quyidagicha yiqiladi:
     TypeError: Diapazon.__init__() missing 1 required positional
     argument: 't'

     Sabab: Set.__and__ natijani cls._from_iterable(it) bilan yasaydi,
     sukut bo'yicha bu cls(it). Konstruktoringiz bitta iterable
     qabul qilmasa — _from_iterable ni qayta aniqlang.
""")


print("\n\n=== 6. ABC vs Protocol ===\n")

from typing import Protocol, runtime_checkable


class OmborABC(ABC):
    @abstractmethod
    def saqla(self, k: str, v: str) -> None: ...

    def kop_saqla(self, m: dict) -> None:
        """⭐ Sukut amalga oshirish."""
        for k, v in m.items():
            self.saqla(k, v)


@runtime_checkable
class OmborProto(Protocol):
    def saqla(self, k: str, v: str) -> None: ...


class Tashqi:
    """Uchinchi tomon sinfi — o'zgartira olmaymiz."""
    def saqla(self, k, v): pass


t = Tashqi()

print(f"  {'Tekshiruv':<36} {'Natija'}")
print("  " + "─" * 50)
print(f"  {'isinstance(Tashqi(), OmborABC)':<36} "
      f"{isinstance(t, OmborABC)}   ⚠️")
print(f"  {'isinstance(Tashqi(), OmborProto)':<36} "
      f"{isinstance(t, OmborProto)}   ✅")

OmborABC.register(Tashqi)
print(f"\n  OmborABC.register(Tashqi) dan keyin:")
print(f"  {'isinstance(Tashqi(), OmborABC)':<36} "
      f"{isinstance(t, OmborABC)}   ✅")
print(f"  {'hasattr(t, `kop_saqla`)':<36} "
      f"{hasattr(t, 'kop_saqla')}   ⚠️ sukut metod yo'q")

print(f"""
  ┌──────────────────────┬─────────────────┬─────────────────┐
  │ Mezon                │ ABC             │ Protocol        │
  ├──────────────────────┼─────────────────┼─────────────────┤
  │ Meros                │ ✅ majburiy     │ ❌ kerak emas   │
  │ Tashqi sinf          │ register()      │ ✅ avtomatik    │
  │ Sukut metodlar       │ ✅ meros        │ ⚠️ meros olsang │
  │ Nusxa yaratishda     │ ✅ tekshiradi   │ ❌              │
  │ mypy imzo tekshiruvi │ ❌              │ ✅              │
  │ Ish vaqti narxi      │ ⚠️ ABCMeta      │ ✅ yo'q         │
  └──────────────────────┴─────────────────┴─────────────────┘

  ⭐ AMALIY QOIDA:
     O'z ierarxiyangiz + umumiy kod  → ABC
     Tashqi kod bilan interfeys      → Protocol
     Ikkalasi ham                    → normal
""")

Natijaning muhim qismi:

text
=== ⭐ 1. register() ===

  Sinf         isinstance   MRO da bormi   chiz()     ikki_marta()
  ──────────────────────────────────────────────────────────────────
  Meros        True         True           'M'        'MM'
  Virtual      True         False          'V'        ❌ AttributeError
  Yolgon       True         False          ❌         ❌ AttributeError
  Dekorator    True         False          'D'        ❌ AttributeError

=== ⭐ 2. __subclasshook__ ===

  Obyekt         chiz() bor     isinstance
  ──────────────────────────────────────────────
  Meros          True           True  ✅
  Yolgon         False          False ✅
  str            False          False ✅

=== 5. Set ABC — to'plam amallari bepul ===

    d1 & d2                            → [5, 6, 7, 8, 9]
    d1.isdisjoint(Diapazon(20,30))     → True

  ⭐ Xotira: Diapazon(0, 1000000) = 48 bayt

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

Misol 3 — Interfeys loyihalash

python
"""ABC bilan to'g'ri arxitektura."""

from __future__ import annotations

import json
from abc import ABC, abstractmethod
from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Any, ClassVar

print("=== KESH INTERFEYSI ===\n")


class KeshXatosi(Exception):
    """Kesh amallarining xatosi."""


class Kesh(ABC):
    """Kesh uchun umumiy shartnoma.

    ⭐ ABSTRAKT (avlodlar majburiy):
        _ol, _qoy, _ochir, _tozala, __len__, __iter__

    ⭐ BEPUL (meros olinadi):
        ol, qoy, ochir, ol_yoki_hisobla, kop_ol, kop_qoy,
        __contains__, __getitem__, __setitem__, __delitem__,
        statistika, TTL boshqaruvi
    """

    SUKUT_TTL: ClassVar[float | None] = None

    def __init__(self, *, ttl: float | None = None,
                 maks: int | None = None):
        self.ttl = ttl if ttl is not None else self.SUKUT_TTL
        self.maks = maks
        self._urish = 0
        self._otkazish = 0
        self._chiqarish = 0

    # ═══ ABSTRAKT ═══

    @abstractmethod
    def _ol(self, k: str) -> tuple[Any, float] | None:
        """Xom qiymat va vaqt tamg'asini qaytaradi (yoki None)."""

    @abstractmethod
    def _qoy(self, k: str, v: Any, vaqt: float) -> None:
        """Xom saqlash."""

    @abstractmethod
    def _ochir(self, k: str) -> bool:
        """O'chiradi, bor-yo'qligini qaytaradi."""

    @abstractmethod
    def _tozala(self) -> None:
        """Hammasini o'chiradi."""

    @abstractmethod
    def __len__(self) -> int: ...

    @abstractmethod
    def __iter__(self) -> Iterator[str]: ...

    # ═══ BEPUL — umumiy mantiq ═══

    @staticmethod
    def _hozir() -> float:
        return datetime.now().timestamp()

    def _eskirganmi(self, vaqt: float) -> bool:
        return self.ttl is not None and self._hozir() - vaqt > self.ttl

    def ol(self, k: str, sukut: Any = None) -> Any:
        """⭐ TTL tekshiruvi bilan."""
        natija = self._ol(k)
        if natija is None:
            self._otkazish += 1
            return sukut
        v, vaqt = natija
        if self._eskirganmi(vaqt):
            self._ochir(k)
            self._chiqarish += 1
            self._otkazish += 1
            return sukut
        self._urish += 1
        return v

    def qoy(self, k: str, v: Any) -> None:
        if not isinstance(k, str):
            raise TypeError(f"Kalit satr bo'lsin: {type(k).__name__}")
        if self.maks and len(self) >= self.maks and k not in self:
            self._joy_bosh()
        self._qoy(k, v, self._hozir())

    def _joy_bosh(self) -> None:
        """⭐ Avlodlar qayta aniqlashi mumkin (sukut: birinchisi)."""
        for k in self:
            self._ochir(k)
            self._chiqarish += 1
            break

    def ochir(self, k: str) -> bool:
        return self._ochir(k)

    def tozala(self) -> None:
        self._tozala()

    def ol_yoki_hisobla(self, k: str, hisobla) -> Any:
        """⭐ Eng ko'p ishlatiladigan naqsh."""
        SENTINEL = object()
        v = self.ol(k, SENTINEL)
        if v is SENTINEL:
            v = hisobla()
            self.qoy(k, v)
        return v

    def kop_ol(self, kalitlar) -> dict[str, Any]:
        SENTINEL = object()
        return {k: v for k in kalitlar
                if (v := self.ol(k, SENTINEL)) is not SENTINEL}

    def kop_qoy(self, m: dict[str, Any]) -> None:
        for k, v in m.items():
            self.qoy(k, v)

    def eskirganlarni_tozala(self) -> int:
        """TTL o'tganlarni o'chiradi."""
        ochirildi = 0
        for k in list(self):
            n = self._ol(k)
            if n and self._eskirganmi(n[1]):
                self._ochir(k)
                ochirildi += 1
        self._chiqarish += ochirildi
        return ochirildi

    def statistika(self) -> dict[str, Any]:
        jami = self._urish + self._otkazish
        return {
            "hajm": len(self),
            "urish": self._urish,
            "otkazish": self._otkazish,
            "chiqarish": self._chiqarish,
            "nisbat": f"{self._urish / jami:.0%}" if jami else "—",
            "ttl": self.ttl,
            "maks": self.maks,
        }

    # ═══ Konteyner protokoli ═══

    def __contains__(self, k) -> bool:
        SENTINEL = object()
        return self.ol(k, SENTINEL) is not SENTINEL

    def __getitem__(self, k: str) -> Any:
        SENTINEL = object()
        v = self.ol(k, SENTINEL)
        if v is SENTINEL:
            raise KeyError(k)
        return v

    def __setitem__(self, k: str, v: Any) -> None:
        self.qoy(k, v)

    def __delitem__(self, k: str) -> None:
        if not self._ochir(k):
            raise KeyError(k)

    def __bool__(self) -> bool:
        return len(self) > 0

    def __repr__(self) -> str:
        return (f"{type(self).__name__}({len(self)} element, "
                f"ttl={self.ttl}, maks={self.maks})")


# ═══ AMALGA OSHIRISHLAR ═══

class XotiraKesh(Kesh):
    """Oddiy lug'at."""

    def __init__(self, **kw):
        super().__init__(**kw)
        self._d: dict[str, tuple[Any, float]] = {}

    def _ol(self, k): return self._d.get(k)
    def _qoy(self, k, v, vaqt): self._d[k] = (v, vaqt)
    def _ochir(self, k): return self._d.pop(k, None) is not None
    def _tozala(self): self._d.clear()
    def __len__(self): return len(self._d)
    def __iter__(self): return iter(list(self._d))


class LruKesh(XotiraKesh):
    """⭐ Eng kam ishlatilganini chiqaradi."""

    def __init__(self, **kw):
        super().__init__(**kw)
        self._tartib: list[str] = []

    def _ol(self, k):
        n = super()._ol(k)
        if n is not None and k in self._tartib:
            self._tartib.remove(k)
            self._tartib.append(k)              # ⭐ oxiriga
        return n

    def _qoy(self, k, v, vaqt):
        super()._qoy(k, v, vaqt)
        if k in self._tartib:
            self._tartib.remove(k)
        self._tartib.append(k)

    def _ochir(self, k):
        if k in self._tartib:
            self._tartib.remove(k)
        return super()._ochir(k)

    def _tozala(self):
        super()._tozala()
        self._tartib.clear()

    def _joy_bosh(self):
        """⭐ Eng eski ishlatilganini chiqaradi."""
        if self._tartib:
            self._ochir(self._tartib[0])
            self._chiqarish += 1


class JurnalliKesh(XotiraKesh):
    """Har amalni yozib boradi."""

    def __init__(self, **kw):
        super().__init__(**kw)
        self.jurnal: list[str] = []

    def _ol(self, k):
        n = super()._ol(k)
        self.jurnal.append(f"OL {k} → {'bor' if n else 'yo`q'}")
        return n

    def _qoy(self, k, v, vaqt):
        self.jurnal.append(f"QOY {k}")
        super()._qoy(k, v, vaqt)

    def _ochir(self, k):
        n = super()._ochir(k)
        self.jurnal.append(f"OCHIR {k} → {n}")
        return n


class ChalaKesh(Kesh):
    """⚠️ Barcha abstrakt metodlar amalga oshirilmagan."""
    def _ol(self, k): return None
    def _qoy(self, k, v, vaqt): pass


print("1. Nusxa yaratish nazorati:\n")

print(f"  Kesh.__abstractmethods__ = "
      f"{sorted(Kesh.__abstractmethods__)}\n")

for Sinf in (Kesh, ChalaKesh, XotiraKesh, LruKesh):
    a = sorted(Sinf.__abstractmethods__)
    try:
        Sinf()
        n = "✅ yaratildi"
    except TypeError as e:
        n = f"❌ TypeError: yetishmayotgan {a}"
    print(f"  {Sinf.__name__:<16} {n}")


print("\n\n2. ⭐ Bepul metodlar:\n")

k = XotiraKesh(ttl=None, maks=100)
k.qoy("a", 1)
k["b"] = 2
k.kop_qoy({"c": 3, "d": 4})

print(f"  {k!r}")
print(f"    k.ol('a')            = {k.ol('a')}")
print(f"    k['b']               = {k['b']}")
print(f"    'c' in k             = {'c' in k}")
print(f"    k.kop_ol(['a','c','x']) = {k.kop_ol(['a', 'c', 'x'])}")
print(f"    len(k)               = {len(k)}")
print(f"    list(k)              = {list(k)}")
print(f"    bool(k)              = {bool(k)}")

hisoblandi = []
for _ in range(3):
    v = k.ol_yoki_hisobla("qimmat", lambda: (hisoblandi.append(1), 42)[1])
print(f"\n    ol_yoki_hisobla('qimmat', ...) × 3")
print(f"      natija: {v}, hisoblandi: {len(hisoblandi)} marta   ⭐")

del k["a"]
print(f"\n    del k['a'] → {list(k)}")
try:
    del k["yoq"]
except KeyError as e:
    print(f"    del k['yoq'] → ✅ KeyError: {e}")

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


print("\n\n3. ⭐ TTL:\n")

import time

kt = XotiraKesh(ttl=0.05)
kt.qoy("tez", "qiymat")

print(f"  kt = XotiraKesh(ttl=0.05)")
print(f"    kt.ol('tez') = {kt.ol('tez')!r}   (darhol)")
time.sleep(0.06)
print(f"    0.06s kutildi...")
print(f"    kt.ol('tez') = {kt.ol('tez')!r}   ⭐ eskirdi")
print(f"    len(kt)      = {len(kt)}   ⭐ avtomatik o'chirildi")

kt2 = XotiraKesh(ttl=0.05)
kt2.kop_qoy({f"k{i}": i for i in range(5)})
time.sleep(0.06)
kt2.qoy("yangi", 99)
print(f"\n  kt2: 5 ta eski + 1 ta yangi")
print(f"    eskirganlarni_tozala() → {kt2.eskirganlarni_tozala()} ta")
print(f"    qolgan: {list(kt2)}")


print("\n\n4. ⭐ LRU chiqarish:\n")

lru = LruKesh(maks=3)
lru.kop_qoy({"a": 1, "b": 2, "c": 3})
print(f"  lru = LruKesh(maks=3), a/b/c qo'yildi")
print(f"    tartib: {lru._tartib}")

lru.ol("a")
print(f"\n    lru.ol('a') → tartib: {lru._tartib}   ⭐ a oxiriga")

lru.qoy("d", 4)
print(f"    lru.qoy('d', 4) → {list(lru)}")
print(f"      ⭐ 'b' chiqarildi (eng kam ishlatilgan)")

print(f"\n  Oddiy XotiraKesh bilan solishtirish:")
oddiy = XotiraKesh(maks=3)
oddiy.kop_qoy({"a": 1, "b": 2, "c": 3})
oddiy.ol("a")
oddiy.qoy("d", 4)
print(f"    XotiraKesh: {list(oddiy)}   ⚠️ 'a' chiqarildi (birinchisi)")
print(f"    LruKesh:    {list(lru)}   ✅ 'a' saqlandi")


print("\n\n5. Jurnalli kesh:\n")

j = JurnalliKesh()
j.qoy("x", 1)
j.ol("x")
j.ol("yoq")
j.ochir("x")

print(f"  Jurnal:")
for q in j.jurnal:
    print(f"    {q}")


print("\n\n6. ⭐ Polimorfizm:\n")


def kesh_sinovi(kesh: Kesh, nom: str) -> dict:
    """⭐ Aniq turni BILMAYDI."""
    kesh.tozala()
    for i in range(20):
        kesh.qoy(f"k{i % 7}", i)
    for i in range(15):
        kesh.ol(f"k{i % 10}")
    return {"nom": nom, **kesh.statistika()}


KESHLAR = [
    (XotiraKesh(maks=5), "XotiraKesh"),
    (LruKesh(maks=5), "LruKesh"),
    (JurnalliKesh(maks=5), "JurnalliKesh"),
]

print(f"  {'Kesh':<16} {'Hajm':<7} {'Urish':<8} {'O`tkazish':<11} "
      f"{'Chiqarish':<11} {'Nisbat'}")
print("  " + "─" * 66)
for kesh, nom in KESHLAR:
    n = kesh_sinovi(kesh, nom)
    print(f"  {n['nom']:<16} {n['hajm']:<7} {n['urish']:<8} "
          f"{n['otkazish']:<11} {n['chiqarish']:<11} {n['nisbat']}")

print(f"""

  ⭐ BU INTERFEYSDA:

     ABSTRAKT (6 ta) — avlodlar majburiy:
       _ol, _qoy, _ochir, _tozala, __len__, __iter__

     BEPUL (15+) — asos sinfda bir marta:
       ol, qoy, ochir, tozala, ol_yoki_hisobla,
       kop_ol, kop_qoy, eskirganlarni_tozala, statistika,
       __contains__, __getitem__, __setitem__, __delitem__,
       __bool__, __repr__

     KENGAYTIRISH NUQTASI:
       _joy_bosh()  — LruKesh qayta aniqladi

     ⭐ NATIJA: yangi kesh yozish uchun 6 metod yetadi.
        TTL, statistika, konteyner protokoli — bepul.
""")

Natijaning muhim qismi:

text
1. Nusxa yaratish nazorati:

  Kesh             ❌ TypeError: yetishmayotgan ['__iter__', '__len__', ...]
  ChalaKesh        ❌ TypeError: yetishmayotgan ['__iter__', '__len__', ...]
  XotiraKesh       ✅ yaratildi

2. ⭐ Bepul metodlar:

    ol_yoki_hisobla('qimmat', ...) × 3
      natija: 42, hisoblandi: 1 marta   ⭐

3. ⭐ TTL:

    kt.ol('tez') = 'qiymat'   (darhol)
    kt.ol('tez') = None   ⭐ eskirdi
    len(kt)      = 0   ⭐ avtomatik o'chirildi

4. ⭐ LRU chiqarish:

    XotiraKesh: ['b', 'c', 'd']   ⚠️ 'a' chiqarildi (birinchisi)
    LruKesh:    ['a', 'c', 'd']   ✅ 'a' saqlandi

Nima ko'rsatdi: 2.1, 2.4-bo'limlar.

Misol 4 — Amaliy: to'lov tizimi

python
"""ABC, Protocol va register birga."""

from __future__ import annotations

import inspect
import re
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from datetime import datetime
from decimal import Decimal
from enum import Enum
from typing import Any, ClassVar, Protocol, runtime_checkable

print("=== TO'LOV TIZIMI ===\n")


class Holat(str, Enum):
    KUTILMOQDA = "kutilmoqda"
    TASDIQLANGAN = "tasdiqlangan"
    RAD_ETILGAN = "rad_etilgan"
    QAYTARILGAN = "qaytarilgan"

    def __str__(self): return self.value


class TolovXatosi(Exception):
    def __init__(self, xabar: str, kod: str = ""):
        self.kod = kod
        super().__init__(f"[{kod}] {xabar}" if kod else xabar)


@dataclass(frozen=True, slots=True)
class Pul:
    miqdor: Decimal
    valyuta: str = "UZS"

    def __post_init__(self):
        if not isinstance(self.miqdor, Decimal):
            object.__setattr__(self, "miqdor", Decimal(str(self.miqdor)))
        if self.miqdor < 0:
            raise ValueError("Manfiy bo'lmasin")
        object.__setattr__(self, "valyuta", self.valyuta.upper())

    def __str__(self):
        return f"{self.miqdor:,.2f} {self.valyuta}"


@dataclass
class Tranzaksiya:
    id: str
    summa: Pul
    usul: str
    holat: Holat = Holat.KUTILMOQDA
    vaqt: datetime = field(default_factory=datetime.now)
    tafsilot: dict[str, Any] = field(default_factory=dict)

    def __str__(self):
        return f"{self.id} {self.summa} [{self.holat}] via {self.usul}"


# ═══ PROTOCOL — tashqi kod uchun ═══

@runtime_checkable
class Tekshiruvchi(Protocol):
    """⭐ Meros TALAB QILMAYDI."""
    def tekshir(self, malumot: dict) -> bool: ...


# ═══ ABC — o'z ierarxiyamiz ═══

class TolovUsuli(ABC):
    """To'lov usuli uchun shartnoma.

    ABSTRAKT: _amalga_oshir, komissiya, _tekshir_malumot
    BEPUL:    tolov, qaytarish, tarix, statistika, chegara nazorati
    """

    NOM: ClassVar[str] = ""
    VALYUTALAR: ClassVar[frozenset[str]] = frozenset({"UZS"})
    MIN: ClassVar[Decimal] = Decimal("1000")
    MAKS: ClassVar[Decimal] = Decimal("100000000")

    _royxat: ClassVar[dict[str, type["TolovUsuli"]]] = {}

    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        if not cls.NOM:
            cls.NOM = cls.__name__.lower()
        # ⚠️ cls.__abstractmethods__ bu yerda hali YO'Q — ABCMeta uni
        #    __init_subclass__ ishlagandan KEYIN o'rnatadi. inspect.isabstract
        #    aynan shu holatda abstrakt metodlarni qo'lda tekshiradi.
        if not inspect.isabstract(cls):         # ⭐ faqat to'liq sinflar
            TolovUsuli._royxat[cls.NOM] = cls

    def __init__(self):
        self._tarix: list[Tranzaksiya] = []
        self._hisoblagich = 0

    # ═══ ABSTRAKT ═══

    @abstractmethod
    def _amalga_oshir(self, summa: Pul, malumot: dict) -> dict:
        """Haqiqiy to'lov. Tafsilotlarni qaytaradi."""

    @abstractmethod
    def komissiya(self, summa: Pul) -> Pul:
        """Komissiya miqdori."""

    @abstractmethod
    def _tekshir_malumot(self, malumot: dict) -> None:
        """Usulga xos ma'lumotni tekshiradi."""

    @property
    @abstractmethod
    def bir_zumdami(self) -> bool:
        """Darhol amalga oshadimi."""

    # ═══ BEPUL ═══

    @classmethod
    def yarat(cls, nom: str) -> "TolovUsuli":
        if nom not in cls._royxat:
            raise KeyError(
                f"Noma'lum usul: {nom!r}. Mavjud: {sorted(cls._royxat)}"
            )
        return cls._royxat[nom]()

    @classmethod
    def mavjudlar(cls) -> list[str]:
        return sorted(cls._royxat)

    @staticmethod
    def _id_yasa(prefiks: str, n: int) -> str:
        return f"{prefiks}-{datetime.now():%Y%m%d}-{n:04d}"

    def _tekshir_summa(self, summa: Pul) -> None:
        """⭐ Umumiy tekshiruv — barcha usullar uchun."""
        if summa.valyuta not in self.VALYUTALAR:
            raise TolovXatosi(
                f"{self.NOM} {summa.valyuta} ni qo'llab-quvvatlamaydi. "
                f"Mavjud: {sorted(self.VALYUTALAR)}", "VALYUTA"
            )
        if summa.miqdor < self.MIN:
            raise TolovXatosi(
                f"Minimal summa: {self.MIN:,}", "MIN_SUMMA"
            )
        if summa.miqdor > self.MAKS:
            raise TolovXatosi(
                f"Maksimal summa: {self.MAKS:,}", "MAKS_SUMMA"
            )

    def tolov(self, summa: Pul, **malumot) -> Tranzaksiya:
        """⭐ Shablon metod — tartib belgilangan."""
        self._tekshir_summa(summa)              # 1. umumiy
        self._tekshir_malumot(malumot)          # 2. usulga xos

        self._hisoblagich += 1
        t = Tranzaksiya(
            id=self._id_yasa(self.NOM[:3].upper(), self._hisoblagich),
            summa=summa,
            usul=self.NOM,
        )
        try:
            t.tafsilot = self._amalga_oshir(summa, malumot)   # 3. amal
            t.holat = (Holat.TASDIQLANGAN if self.bir_zumdami
                       else Holat.KUTILMOQDA)
        except TolovXatosi:
            t.holat = Holat.RAD_ETILGAN
            self._tarix.append(t)
            raise
        t.tafsilot["komissiya"] = str(self.komissiya(summa))
        self._tarix.append(t)
        return t

    def qaytarish(self, tranzaksiya_id: str) -> Tranzaksiya:
        t = next((x for x in self._tarix if x.id == tranzaksiya_id), None)
        if t is None:
            raise TolovXatosi(f"Topilmadi: {tranzaksiya_id}", "TOPILMADI")
        if t.holat != Holat.TASDIQLANGAN:
            raise TolovXatosi(
                f"Faqat tasdiqlangan qaytariladi (holat: {t.holat})",
                "HOLAT"
            )
        t.holat = Holat.QAYTARILGAN
        return t

    @property
    def tarix(self) -> tuple[Tranzaksiya, ...]:
        return tuple(self._tarix)

    def statistika(self) -> dict[str, Any]:
        holatlar: dict[str, int] = {}
        for t in self._tarix:
            holatlar[str(t.holat)] = holatlar.get(str(t.holat), 0) + 1
        tasdiqlangan = [t for t in self._tarix
                        if t.holat == Holat.TASDIQLANGAN]
        return {
            "usul": self.NOM,
            "jami": len(self._tarix),
            "holatlar": holatlar,
            "summa": str(Pul(sum((t.summa.miqdor for t in tasdiqlangan),
                                 Decimal(0)))) if tasdiqlangan else "—",
            "bir_zumda": self.bir_zumdami,
        }

    def __repr__(self):
        return f"{type(self).__name__}({len(self._tarix)} tranzaksiya)"


# ═══ AMALGA OSHIRISHLAR ═══

class Karta(TolovUsuli):
    NOM = "karta"
    VALYUTALAR = frozenset({"UZS", "USD"})
    MIN = Decimal("1000")
    MAKS = Decimal("50000000")
    KOMISSIYA = Decimal("0.015")

    @property
    def bir_zumdami(self) -> bool:
        return True

    def komissiya(self, summa: Pul) -> Pul:
        return Pul(summa.miqdor * self.KOMISSIYA, summa.valyuta)

    def _tekshir_malumot(self, malumot: dict) -> None:
        raqam = str(malumot.get("raqam", "")).replace(" ", "")
        if not re.fullmatch(r"\d{16}", raqam):
            raise TolovXatosi("Karta raqami 16 raqam bo'lsin", "KARTA")
        if not self._luhn(raqam):
            raise TolovXatosi("Karta raqami noto'g'ri (Luhn)", "LUHN")
        if not re.fullmatch(r"\d{2}/\d{2}", str(malumot.get("amal", ""))):
            raise TolovXatosi("Amal muddati OO/YY", "MUDDAT")

    @staticmethod
    def _luhn(raqam: str) -> bool:
        """⭐ Sof funksiya — statik metod."""
        jami = 0
        for i, belgi in enumerate(reversed(raqam)):
            d = int(belgi)
            if i % 2 == 1:
                d *= 2
                if d > 9:
                    d -= 9
            jami += d
        return jami % 10 == 0

    def _amalga_oshir(self, summa, malumot):
        raqam = str(malumot["raqam"]).replace(" ", "")
        return {"oxirgi4": raqam[-4:], "tur": "karta"}


class Naqd(TolovUsuli):
    NOM = "naqd"
    MIN = Decimal("100")
    MAKS = Decimal("10000000")

    @property
    def bir_zumdami(self) -> bool:
        return True

    def komissiya(self, summa: Pul) -> Pul:
        return Pul(Decimal(0), summa.valyuta)

    def _tekshir_malumot(self, malumot: dict) -> None:
        if not malumot.get("kassir"):
            raise TolovXatosi("Kassir ko'rsatilsin", "KASSIR")

    def _amalga_oshir(self, summa, malumot):
        return {"kassir": malumot["kassir"], "tur": "naqd"}


class BankOtkazma(TolovUsuli):
    NOM = "bank"
    VALYUTALAR = frozenset({"UZS", "USD", "EUR"})
    MIN = Decimal("50000")
    MAKS = Decimal("1000000000")

    @property
    def bir_zumdami(self) -> bool:
        return False                            # ⭐ kutiladi

    def komissiya(self, summa: Pul) -> Pul:
        return Pul(min(Decimal("50000"),
                       summa.miqdor * Decimal("0.003")), summa.valyuta)

    def _tekshir_malumot(self, malumot: dict) -> None:
        hisob = str(malumot.get("hisob", ""))
        if not re.fullmatch(r"\d{20}", hisob):
            raise TolovXatosi("Hisob raqami 20 raqam", "HISOB")
        if not malumot.get("mfo"):
            raise TolovXatosi("MFO ko'rsatilsin", "MFO")

    def _amalga_oshir(self, summa, malumot):
        return {"hisob": f"...{str(malumot['hisob'])[-4:]}",
                "mfo": malumot["mfo"], "tur": "bank"}


class ChalaUsul(TolovUsuli):
    """⚠️ To'liq emas — ro'yxatga TUSHMAYDI."""
    NOM = "chala"

    def komissiya(self, summa): return Pul(Decimal(0))


print("1. ⭐ Avtomatik ro'yxat (faqat to'liq sinflar):\n")

print(f"  Mavjud usullar: {TolovUsuli.mavjudlar()}")
print(f"  ⭐ 'chala' YO'Q — abstrakt metodlari qolgan\n")

print(f"  {'Sinf':<16} {'Abstrakt qolgan':<40} {'Ro`yxatda'}")
print("  " + "─" * 70)
for S in (TolovUsuli, ChalaUsul, Karta, Naqd, BankOtkazma):
    a = sorted(S.__abstractmethods__)
    r = "✅" if S.NOM in TolovUsuli._royxat else "❌"
    print(f"  {S.__name__:<16} {str(a)[:38]:<40} {r}")

print(f"\n  Nusxa yaratish:")
for S in (TolovUsuli, ChalaUsul, Karta):
    try:
        S(); n = "✅"
    except TypeError:
        n = "❌ TypeError"
    print(f"    {S.__name__}() → {n}")


print("\n\n2. To'lovlar:\n")

karta = TolovUsuli.yarat("karta")
naqd = TolovUsuli.yarat("naqd")
bank = TolovUsuli.yarat("bank")

TOLOVLAR = [
    (karta, Pul(Decimal("500000")),
     {"raqam": "4242424242424242", "amal": "12/28"}),
    (naqd, Pul(Decimal("250000")), {"kassir": "Aziz K."}),
    (bank, Pul(Decimal("15000000")),
     {"hisob": "20208000900123456789", "mfo": "00014"}),
    (karta, Pul(Decimal("1200000")),
     {"raqam": "5555 5555 5555 4444", "amal": "06/27"}),
]

for usul, summa, malumot in TOLOVLAR:
    t = usul.tolov(summa, **malumot)
    print(f"  {t}")
    print(f"    komissiya: {t.tafsilot['komissiya']}, "
          f"tafsilot: {t.tafsilot}")


print("\n\n3. Tekshiruvlar:\n")

XATOLAR = [
    ("Karta: qisqa raqam", karta, Pul(Decimal("100000")),
     {"raqam": "1234", "amal": "12/28"}),
    ("Karta: Luhn xato", karta, Pul(Decimal("100000")),
     {"raqam": "4242424242424241", "amal": "12/28"}),
    ("Karta: muddat yo'q", karta, Pul(Decimal("100000")),
     {"raqam": "4242424242424242"}),
    ("Karta: EUR", karta, Pul(Decimal("100000"), "EUR"),
     {"raqam": "4242424242424242", "amal": "12/28"}),
    ("Naqd: min summa", naqd, Pul(Decimal("50")), {"kassir": "A"}),
    ("Naqd: kassir yo'q", naqd, Pul(Decimal("100000")), {}),
    ("Bank: hisob xato", bank, Pul(Decimal("100000")),
     {"hisob": "123", "mfo": "00014"}),
    ("Bank: min summa", bank, Pul(Decimal("10000")),
     {"hisob": "20208000900123456789", "mfo": "00014"}),
]

for tavsif, usul, summa, malumot in XATOLAR:
    try:
        usul.tolov(summa, **malumot)
        n = "⚠️ O'TDI"
    except TolovXatosi as e:
        n = f"✅ {e}"
    print(f"  {tavsif:<22} {n}")


print("\n\n4. Qaytarish:\n")

t = karta.tarix[0]
print(f"  Asl: {t}")
q = karta.qaytarish(t.id)
print(f"  Qaytarilgandan keyin: {q}")

try:
    karta.qaytarish(t.id)
except TolovXatosi as e:
    print(f"  Qayta qaytarish → ✅ {e}")

kutilayotgan = bank.tarix[0]
try:
    bank.qaytarish(kutilayotgan.id)
except TolovXatosi as e:
    print(f"  Kutilayotganni qaytarish → ✅ {e}")


print("\n\n5. ⭐ Polimorfizm:\n")


def hisobot(usullar: list[TolovUsuli]) -> None:
    """⭐ Aniq turni bilmaydi."""
    print(f"  {'Usul':<10} {'Jami':<7} {'Bir zumda':<12} "
          f"{'Summa':<22} {'Holatlar'}")
    print("  " + "─" * 74)
    for u in usullar:
        s = u.statistika()
        print(f"  {s['usul']:<10} {s['jami']:<7} "
              f"{s['bir_zumda']!s:<12} {s['summa']:<22} {s['holatlar']}")


hisobot([karta, naqd, bank])

print(f"\n  Komissiyalar taqqoslash (1,000,000 UZS):")
SUMMA = Pul(Decimal("1000000"))
for nom in TolovUsuli.mavjudlar():
    u = TolovUsuli.yarat(nom)
    print(f"    {nom:<10} {u.komissiya(SUMMA)}")


print("\n\n6. ⭐ Protocol bilan tashqi tekshiruvchi:\n")


class TashqiTekshiruvchi:
    """Uchinchi tomon — meros olmagan."""

    def __init__(self, qora_royxat: set[str]):
        self.qora_royxat = qora_royxat

    def tekshir(self, malumot: dict) -> bool:
        raqam = str(malumot.get("raqam", "")).replace(" ", "")
        return raqam[-4:] not in self.qora_royxat


class QoidalarTekshiruvchi:
    def __init__(self, maks_urinish: int = 3):
        self.maks_urinish = maks_urinish
        self._urinishlar: dict[str, int] = {}

    def tekshir(self, malumot: dict) -> bool:
        k = str(malumot.get("raqam", ""))[-4:]
        self._urinishlar[k] = self._urinishlar.get(k, 0) + 1
        return self._urinishlar[k] <= self.maks_urinish


TEKSHIRUVCHILAR = [
    TashqiTekshiruvchi({"4444", "0000"}),
    QoidalarTekshiruvchi(maks_urinish=2),
]

print(f"  Protocol tekshiruvi:")
for t in TEKSHIRUVCHILAR:
    print(f"    isinstance({type(t).__name__}, Tekshiruvchi) = "
          f"{isinstance(t, Tekshiruvchi)}   ✅ meros yo'q")

print(f"\n  Ishlatish:")
SINOVLAR = [
    {"raqam": "4242424242424242"},
    {"raqam": "5555555555554444"},
    {"raqam": "4242424242424242"},
    {"raqam": "4242424242424242"},
]

for i, m in enumerate(SINOVLAR, 1):
    natijalar = [t.tekshir(m) for t in TEKSHIRUVCHILAR]
    ok = all(natijalar)
    print(f"    {i}. ...{m['raqam'][-4:]} → qora ro'yxat: {natijalar[0]}, "
          f"urinish: {natijalar[1]}  {'✅' if ok else '❌'}")


print("\n\n7. register() bilan eski kod:\n")


class EskiUsul:
    """⚠️ Eski kod — o'zgartira olmaymiz."""

    NOM = "eski"

    def tolov(self, summa, **kw):
        return f"Eski to'lov: {summa}"


TolovUsuli.register(EskiUsul)

e = EskiUsul()
print(f"  TolovUsuli.register(EskiUsul)")
print(f"    isinstance(e, TolovUsuli) = {isinstance(e, TolovUsuli)}   ✅")
print(f"    EskiUsul.__mro__ = {[c.__name__ for c in EskiUsul.__mro__]}")
print(f"    ⚠️ TolovUsuli MRO da YO'Q")

for m in ["statistika", "qaytarish", "komissiya"]:
    print(f"    hasattr(e, {m!r}) = {hasattr(e, m)}   ⚠️")

print(f"""
  ⚠️ register() FAQAT isinstance uchun.
     Sukut metodlar meros OLINMAYDI.

  ✅ Haqiqiy integratsiya uchun ADAPTER:

     class EskiAdapter(TolovUsuli):
         NOM = "eski-adapter"
         def __init__(self):
             super().__init__()
             self._eski = EskiUsul()
         def _amalga_oshir(self, summa, malumot):
             return {{"natija": self._eski.tolov(summa)}}
         ...


  ⭐ BU TIZIMDA:

     ABC (TolovUsuli):
       • 4 abstrakt a'zo (3 metod + 1 property)
       • 10+ bepul metod (tolov, qaytarish, statistika, ...)
       • Shablon metod: tolov() tartibni belgilaydi
       • __init_subclass__ + __abstractmethods__ bilan
         faqat TO'LIQ sinflar ro'yxatga tushadi

     Protocol (Tekshiruvchi):
       • Tashqi sinflar meros olmasdan mos keladi
       • runtime_checkable bilan isinstance

     register():
       • Eski kod uchun — lekin cheklovlari bilan
""")

Natijaning muhim qismi:

text
1. ⭐ Avtomatik ro'yxat (faqat to'liq sinflar):

  Mavjud usullar: ['bank', 'karta', 'naqd']
  ⭐ 'chala' YO'Q — abstrakt metodlari qolgan

2. To'lovlar:

  KAR-20260908-0001 500,000.00 UZS [tasdiqlangan] via karta
    komissiya: 7,500.00 UZS, tafsilot: {'oxirgi4': '4242', ...}
  BAN-20260908-0001 15,000,000.00 UZS [kutilmoqda] via bank

3. Tekshiruvlar:

  Karta: Luhn xato        ✅ [LUHN] Karta raqami noto'g'ri (Luhn)
  Karta: EUR              ✅ [VALYUTA] karta EUR ni qo'llab-quvvatlamaydi
  Bank: min summa         ✅ [MIN_SUMMA] Minimal summa: 50,000

6. ⭐ Protocol bilan tashqi tekshiruvchi:

    isinstance(TashqiTekshiruvchi, Tekshiruvchi) = True   ✅ meros yo'q

Nima ko'rsatdi: 2.1, 2.4, 2.5, 2.8-bo'limlar.


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

Noto'g'ri fikr To'g'risi
"@abstractmethod o'zi to'sadi" ABCMeta tekshiradi
"Abstrakt metod bo'sh bo'lishi kerak" Kod bo'lishi mumkin (super() bilan)
"register() metodlarni tekshiradi" Hech narsa tekshirmaydi
"register() metodlarni beradi" Meros olinmaydi
"abstractproperty ishlatish kerak" Eskirgan; @property + @abstractmethod
"ABC — Java interfeysi" Sukut amalga oshirish bo'lishi mumkin
"Protocol ABC ni almashtiradi" Turli maqsad
"__subclasshook__ da cls tekshiruvi shart emas" Avlodlar buziladi

6. Keng tarqalgan xatolar va yechimlari

1. ABC dan meros olmaslik

python
class A:                        # ⚠️ himoya yo'q
    @abstractmethod
    def f(self): ...
class A(ABC):                   # ✅

2. Dekorator tartibi

python
@abstractmethod
@property                       # ❌
def x(self): ...

@property
@abstractmethod                 # ✅
def x(self): ...

3. register() ga ishonish

python
A.register(Yolgon)              # ⚠️ tekshirmaydi
class Yolgon(A): ...            # ✅ yoki __subclasshook__

4. __subclasshook__ da cls tekshiruvi yo'q

python
@classmethod
def __subclasshook__(cls, C):
    return "f" in dir(C)                # ⚠️ avlodlar buziladi
    if cls is A: ...                    # ✅
    return NotImplemented

5. Eskirgan dekoratorlar

python
@abstractproperty               # ⚠️ 3.3 dan eskirgan
@property                       # ✅
@abstractmethod

6. __init_subclass__ da abstrakt sinfni ro'yxatga olish

python
def __init_subclass__(cls, **kw):
    _royxat[cls.NOM] = cls              # ⚠️ chala sinflar ham
    if not cls.__abstractmethods__:     # ❌ AttributeError — hali yo'q
        _royxat[cls.NOM] = cls
    if not inspect.isabstract(cls):     # ✅
        _royxat[cls.NOM] = cls

__init_subclass__ sinf yaratilishining o'rtasida chaqiriladi, ABCMeta esa __abstractmethods__ ni undan keyin o'rnatadi. inspect.isabstract() bu holatni biladi va abstrakt metodlarni qo'lda tekshiradi.

7. ABC ni ma'lumot sinfi uchun ishlatish

python
class Nuqta(ABC):               # ⚠️ ortiqcha
@dataclass                      # ✅
class Nuqta: ...

8. Juda ko'p abstrakt metod

python
class Ombor(ABC):
    # 15 ta @abstractmethod     ⚠️ amalga oshirish qiyin
    # 3-5 ta abstrakt + bepul   ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 8.6-dars (o'tilgan): meros va shablon metod
  • 8.9-dars: polimorfizm, Protocol
  • 8.14-dars: collections.abc konteynerlarda
  • 8.20-dars: kompozitsiya vs meros
  • 9-qism: istisnolar ierarxiyasi
  • numbers, io, collections.abc — standart ABC lar
  • PEP 3119: Introducing Abstract Base Classes

8. Eng yaxshi amaliyotlar

  1. ABC dan meros oling. @abstractmethod o'zi yetarli emas.

  2. 3-5 abstrakt metod. Ko'p bo'lsa — interfeysni bo'ling.

  3. Sukut amalga oshirishlar bering. ABC ning asosiy afzalligi.

  4. @abstractmethod — eng ichkarida. @property dan keyin.

  5. register() ni ehtiyot ishlating. Tekshirmaydi, metod bermaydi.

  6. __subclasshook__ da if cls is X. Avlodlar buzilmasin.

  7. __abstractmethods__ bilan registry filtri. Chala sinflar tushmasin.

  8. Tashqi kod uchun Protocol. ABC — o'z ierarxiyangiz uchun.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
1.  class A(ABC):
        @abstractmethod
        def f(self): ...
    try: A()
    except TypeError: print("xato")
2.  class A:
        @abstractmethod
        def f(self): ...
    print(type(A()).__name__)
3.  class A(ABC):
        @abstractmethod
        def f(self): ...
    class B(A):
        def f(self): return 1
    print(B().f(), B.__abstractmethods__)
4.  class A(ABC):
        @abstractmethod
        def f(self): ...
    class B: pass
    A.register(B)
    print(isinstance(B(), A), A in B.__mro__)
5.  @abstractmethod
    def f(): ...
    print(f.__isabstractmethod__)
6.  from collections.abc import Sized
    print(isinstance([1], Sized), isinstance(42, Sized))
7.  class A(ABC):
        @abstractmethod
        def f(self): ...
        def g(self): return "g"
    class B(A):
        def f(self): return "f"
    print(B().g())
8.  from collections.abc import Sequence
    print(sorted(Sequence.__abstractmethods__))
9.  class A(ABC):
        @property
        @abstractmethod
        def x(self): ...
    print(sorted(A.__abstractmethods__))
10. class A(ABC): pass
    print(A())
11. from collections.abc import Iterable
    class A:
        def __getitem__(self, i): return i
    print(isinstance(A(), Iterable), next(iter(A())))
12. class A(ABC):
        @abstractmethod
        def f(self): ...
    class B(A):
        @abstractmethod
        def g(self): ...
    print(sorted(B.__abstractmethods__))
Javoblar
  1. xato
  2. A — ABC emas, yaratildi
  3. 1 frozenset()
  4. True False
  5. True
  6. True False
  7. g — sukut metod meros olindi
  8. ['__getitem__', '__len__']
  9. ['x']
  10. <__main__.A object at 0x...> — abstrakt metod yo'q
  11. False 0 — Iterable faqat __iter__ ni tekshiradi, lekin iter() eski __getitem__ protokoli bilan ham ishlaydi. list(A()) esa cheksiz davom etardi — IndexError hech qachon chiqmaydi
  12. ['f', 'g']

Vazifa 2: Xatolarni tuzating

python
1.  class A:
        @abstractmethod
        def f(self): ...
2.  class A(ABC):
        @abstractmethod
        @property
        def x(self): ...
3.  A.register(Yolgon)     # Yolgon da metodlar yo'q
4.  @classmethod
    def __subclasshook__(cls, C):
        return "f" in dir(C)
5.  class A(ABC):
        @abstractproperty
        def x(self): ...
6.  def __init_subclass__(cls, **kw):
        _royxat[cls.NOM] = cls
7.  class Nuqta(ABC):
        x: float
        y: float
8.  class Ombor(ABC):
        # 20 ta abstrakt metod
Javoblar
python
1.  class A(ABC):
2.  @property
    @abstractmethod
3.  Meros oling yoki __subclasshook__ yozing
4.  if cls is A: return ...
    return NotImplemented
5.  @property + @abstractmethod
6.  if not inspect.isabstract(cls): _royxat[cls.NOM] = cls
7.  @dataclass ishlating
8.  Interfeysni bo'ling: Oquvchi, Yozuvchi, Ochiruvchi

Vazifa 3: Serializator ABC

Yozing:

  1. Abstrakt: _yoz(obj), _oqi(matn), KENGAYTMA
  2. Bepul: saqla(obj, yol), yukla(yol), tekshir(matn)
  3. @classmethod kengaytmadan(yol) — registry
  4. __init_subclass__ bilan avtomatik ro'yxat
  5. JSON, CSV, XML amalga oshirishlari
  6. Chala sinf ro'yxatga tushmasin

Vazifa 4: ABC tekshiruvchisi

Vosita yozing:

  1. @abstractmethod bor, ABC yo'q sinflarni topsin
  2. Noto'g'ri dekorator tartibini
  3. Eskirgan abstractproperty ni
  4. register() da metod yo'qligini tekshirsin
  5. Juda ko'p abstrakt metodni (>7) ogohlantirsin
  6. __subclasshook__ da cls tekshiruvi yo'qligini

Vazifa 5: collections.abc bilan

  1. Sequence dan Halqa (ring buffer)
  2. MutableMapping dan IkkiTomonlamaLugat
  3. Set dan IntervalToplam
  4. Har birida minimal metodlar
  5. Bepul metodlarni sanang
  6. Tezlik uchun ba'zilarini qayta aniqlang

Vazifa 6: Plagin arxitekturasi

  1. Plagin(ABC) — nom, versiya, ishga_tushir
  2. Ixtiyoriy ilgaklar (abstrakt emas)
  3. Bog'liqliklar tekshiruvi
  4. Yuklash tartibi (topologik saralash)
  5. Protocol bilan tashqi plaginlar
  6. Xato bo'lsa boshqalari ishlashda davom etsin

Vazifa 7: O'ylash

Nega Python ABC ni qo'shdi — duck typing yetarli bo'lsa ham?

Javob

Chunki duck typing katta tizimlarda uch muammo tug'diradi: xato kech aniqlanadi, interfeys hujjatsiz qoladi, va umumiy kod takrorlanadi.

1. Muammo 1: xato kech aniqlanadi

python
class Ombor:
    def saqla(self, k, v):
        raise NotImplementedError


class Chala(Ombor):
    def saqla(self, k, v): ...
    # olish YO'Q — lekin hech kim bilmaydi


o = Chala()                     # ✅ yaratildi
# ... 200 qator kod ...
o.olish("kalit")                # ❌ ishlab chiqarishda

Xato ishlatish paytida — ehtimol tunda, ishlab chiqarishda.

ABC bilan:

python
Chala()
# TypeError: Can't instantiate abstract class Chala without an
# implementation for abstract method 'olish'

Test yozishdan oldin aniqlanadi.

2. Muammo 2: interfeys hujjatsiz

python
def ishla(ombor):
    ...

Savollar:

  • ombor qanday metodlarga ega bo'lishi kerak?
  • Imzolari qanday?
  • Nima qaytaradi?

Javob — butun funksiyani o'qish yoki hujjatni topish.

ABC bilan:

python
def ishla(ombor: Ombor):
    ...

class Ombor(ABC):
    @abstractmethod
    def saqla(self, k: str, v: Any) -> None:
        """Qiymatni saqlaydi.

        Raises:
            OmborTolgan: joy yetmasa
        """

Interfeys — bir joyda, hujjatlangan.

3. Muammo 3: umumiy kod takrorlanadi

python
class XotiraOmbor:
    def kop_saqla(self, m):
        for k, v in m.items(): self.saqla(k, v)      # ⚠️ takror

class FaylOmbor:
    def kop_saqla(self, m):
        for k, v in m.items(): self.saqla(k, v)      # ⚠️ takror

class RedisOmbor:
    def kop_saqla(self, m):
        for k, v in m.items(): self.saqla(k, v)      # ⚠️ takror

ABC bilan bir marta:

python
class Ombor(ABC):
    @abstractmethod
    def saqla(self, k, v): ...

    def kop_saqla(self, m):                          # ⭐ bepul
        for k, v in m.items():
            self.saqla(k, v)

collections.abc da bu eng aniq ko'rinadi: MutableSequence 5 metoddan 11+ metod yasaydi.

4. Nima uchun NotImplementedError yetarli emas

python
class Ombor:
    def saqla(self, k, v):
        raise NotImplementedError

Muammolar:

NotImplementedError ABC
Nusxa yaratish Mumkin To'siladi
Xato vaqti Ishlatilganda Yaratilganda
__abstractmethods__ Introspeksiya
IDE ogohlantirishi
mypy
Chala sinfni aniqlash

5. isinstance muammosi

Duck typing bilan:

python
def f(x):
    if hasattr(x, "saqla") and hasattr(x, "olish"):   # ⚠️ mo'rt
        ...

Bu:

  • Imzoni tekshirmaydi
  • Har joyda takrorlanadi
  • hasattr istisnolarni yutadi

ABC bilan:

python
if isinstance(x, Ombor): ...

Va collections.abc bilan o'rnatilgan turlar ham ishlaydi:

python
isinstance([1, 2], Sequence)    # True
isinstance("ab", Sequence)      # True
isinstance({1: 2}, Mapping)     # True

hasattr bilan bu mumkin emas edi (str da __getitem__ bor, lekin dict da ham).

6. PEP 3119 motivatsiyasi (2007)

Guido va Talin yozdi:

"The primary motivation is to provide a way to define interfaces that can be tested with isinstance()... Python's duck typing works well for small programs, but as programs grow, the lack of explicit interfaces becomes a problem."

Uch maqsad:

  1. isinstance bilan tekshiriladigan interfeyslar
  2. Standart konteyner protokollari (collections.abc)
  3. Umumiy kodni ulashish (mixin metodlar)

7. Nega duck typing YO'QOLMADI

ABC qo'shimcha, almashtiruv emas:

python
# 1. Duck typing — hali ham asosiy
def f(x): return x.metod()

# 2. ABC — kerak bo'lganda
def f(x: Ombor): return x.saqla(...)

# 3. Protocol — statik duck typing
def f(x: OmborProto): ...

Va collections.abc duck typing ni rasmiylashtiradi:

python
class Sized(metaclass=ABCMeta):
    @abstractmethod
    def __len__(self): ...

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Sized:
            return _check_methods(C, "__len__")      # ⭐ duck typing!
        return NotImplemented

Ya'ni isinstance(x, Sized) — aslida __len__ bormi degan savol. Duck typing, lekin rasmiy nom bilan.

8. Boshqa tillar

Til Mexanizm
Python ABC (ixtiyoriy) + duck typing + Protocol
Java interface (majburiy)
C# interface + abstract class
Go Interfeys — strukturaviy (avtomatik)
Rust trait — aniq impl kerak
Ruby Duck typing + modul (ABC yo'q)
TypeScript interface — strukturaviy

Go eng qiziq:

go
type Ombor interface {
    Saqla(k, v string)
}

type MeningOmborim struct{}
func (m MeningOmborim) Saqla(k, v string) {}
// ⭐ Ombor ni E'LON QILMAYDI — avtomatik mos keladi

Go da interfeys strukturaviy — Python Protocol bilan bir xil g'oya, lekin kompilyatsiya paytida tekshiriladi.

Lekin Go da sukut metodlar yo'q — embedding kerak.

Rust — eng qat'iy:

rust
trait Ombor {
    fn saqla(&self, k: &str, v: &str);

    fn kop_saqla(&self, m: &HashMap<String, String>) {  // ⭐ sukut
        for (k, v) in m { self.saqla(k, v); }
    }
}

impl Ombor for MeningOmborim {          // ⭐ ANIQ e'lon
    fn saqla(&self, k: &str, v: &str) { ... }
}

Rust trait — ABC va Protocol ning eng yaxshi tomonlarini birlashtiradi: sukut metodlar + kompilyatsiya paytida tekshiruv.

9. Amaliy tanlash

python
# ⭐ 1. Kichik skript — duck typing
def f(x): return x.metod()

# ⭐ 2. Kutubxona API — Protocol
class Ombor(Protocol):
    def saqla(self, k: str, v: str) -> None: ...

def ishla(o: Ombor): ...        # ✅ tashqi sinflar ham

# ⭐ 3. O'z ierarxiyangiz + umumiy kod — ABC
class AsosOmbor(ABC):
    @abstractmethod
    def saqla(self, k, v): ...

    def kop_saqla(self, m): ...  # ⭐ bepul

# ⭐ 4. Ish vaqtida tekshiruv — ABC + isinstance
if not isinstance(o, Ombor):
    raise TypeError(...)

10. Xulosa

ABC qo'shildi, chunki duck typing:

  1. Xatoni kech aniqlaydi — nusxa yaratilib, keyin buziladi
  2. Interfeysni hujjatlamaydi — nima kerakligi noaniq
  3. Umumiy kodni ulashmaydi — takrorlanish
  4. isinstance bilan ishlamaydi — hasattr zanjiri mo'rt

Va ABC duck typing ni almashtirmadi — u:

  • Ixtiyoriy qatlam
  • __subclasshook__ bilan duck typing ni rasmiylashtiradi
  • collections.abc orqali o'rnatilgan turlarni ham qamraydi

Umumiy naqsh (yana): Python har muammo uchun ixtiyoriy qatlam beradi:

Ehtiyoj Vosita
Hech narsa Duck typing
Hujjat Docstring + tur ko'rsatkichi
Statik tekshiruv Protocol + mypy
Ish vaqtida tekshiruv ABC + isinstance
Umumiy kod ABC + sukut metodlar
To'liq validatsiya pydantic

Siz kerakli darajani tanlaysiz — va hech biri majburiy emas.

Nimani mustahkamlaydi: 2.1, 2.5, 2.8-bo'limlar.


Xulosa

Bu darsda abstrakt asos sinflarni o'rgandik.

Eng muhim uch fikr:

  1. ABC xatoni yaratish paytiga ko'chiradi. NotImplementedError faqat metod chaqirilganda ishlaydi; @abstractmethod + ABC esa chala sinfning **nusxasini yaratishga yo'l qo'ymaydi. Lekin @abstractmethodo'zi faqatisabstractmethodbayrog'ini qo'yadi — tekshiruvniABCMetaqiladi, shuning uchunABC` dan meros olish shart.

  2. ABC ning asosiy afzalligi — sukut amalga oshirishlar. Bu uni Java interfeysidan farqlaydi: 3-5 abstrakt metod yozib, o'nlab bepul metod berish mumkin. collections.abc.MutableSequence — eng aniq misol: 5 metoddan append, pop, remove, extend, __iadd__ va boshqalar kelib chiqadi.

  3. register() hech narsani tekshirmaydi va metod bermaydi. U faqat isinstance/issubclass uchun; MRO ga kirmaydi, super() ishlamaydi, sukut metodlar meros olinmaydi. Avtomatik tanish kerak bo'lsa — __subclasshook__ (ichida if cls is X tekshiruvi bilan), tashqi kod bilan interfeys kerak bo'lsa — Protocol.

Keyingi darsda __slots__ ni ko'ramiz: xotira optimizatsiyasi, cheklovlari va qachon u haqiqatan kerak.

OOP · 18-dars yakunlandi

8.18-dars: Abstrakt klasslar (ABC)

41 daqvaqt
0belgi
Keyingi dars: 8.19-dars: slots
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0