8.18-dars: Abstrakt klasslar (ABC)
8-QISM — OBYEKTGA YO'NALTIRILGAN DASTURLASH · 18-dars
1. Kirish va motivatsiya
Bu sinf "shartnoma" bo'lishi kerak edi:
class Ombor:
def saqla(self, k, v):
raise NotImplementedError
def olish(self, k):
raise NotImplementedErrorLekin himoya yo'q:
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 xatoABC bilan — xato darhol:
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,@abstractmethodva nusxa yaratish nazorati abstractpropertyo'rniga to'g'ri kombinatsiyalarregister()— virtual avlodlar__subclasshook__— avtomatik tanishcollections.abc— 25 tayyor ABC- ABC vs
Protocol— qachon qaysi
2. Nazariya — chuqur tushuntirish
2.1. Asosiy sintaksis
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:
class A(ABC): ... # ✅ oddiy
from abc import ABCMeta
class A(metaclass=ABCMeta): ... # ✅ bir xil ABC — shunchaki class ABC(metaclass=ABCMeta).
Mexanizm:
Shakl.__abstractmethods__ # frozenset({'yuza'})Nusxa yaratishni esa object.__new__ rad etadi (C darajasida). Mantiqan u quyidagicha ishlaydi:
# 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:
class Oddiy: pass # ABCMeta YO'Q
Oddiy.__abstractmethods__ = frozenset({"x"})
Oddiy() # TypeError: Can't instantiate abstract class Oddiy ...2.2. Faqat metaklass tekshiradi
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.
def f(): ...
f.__isabstractmethod__ # AttributeError
@abstractmethod
def g(): ...
g.__isabstractmethod__ # True2.3. Kombinatsiyalar
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:
@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
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
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'QUch muhim cheklov:
- Tekshirmaydi — metod bo'lmasa ham
True - Metodlar meros olinmaydi — sukut amalga oshirishlar mavjud emas
- MRO ga kirmaydi —
super()ishlamaydi
Chizilar.register(BoshMasSinf) # ⚠️ hech narsa tekshirilmadi
isinstance(BoshMasSinf(), Chizilar) # True ⚠️
BoshMasSinf().chiz() # ❌ AttributeErrorDekorator sifatida:
@Chizilar.register
class Boshqa2:
def chiz(self): ...2.6. __subclasshook__ — avtomatik tanish
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 ✅ avtomatikUch 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, discardQo'shimchalar: Awaitable, Coroutine, AsyncIterable, AsyncIterator, AsyncGenerator, MappingView, KeysView, ItemsView, ValuesView, Buffer (3.12+).
Ikki xil ishlatish:
# 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) # True2.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
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)
@property
@abstractmethod
def x(self): ...
@classmethod
@abstractmethod
def yarat(cls): ...
@staticmethod
@abstractmethod
def tekshir(q): ...register()
A.register(Boshqa) virtual avlod
isinstance(Boshqa(), A) True
Boshqa.__mro__ ⚠️ A YO'Q
⚠️ Tekshirmaydi, metodlar meros olinmaydi, super() yo'qsubclasshook
@classmethod
def __subclasshook__(cls, C):
if cls is A: ⭐ shart
return any("f" in B.__dict__ for B in C.__mro__)
return NotImplemented ⭐ oddiy tekshiruvgacollections.abc
Sequence → __getitem__, __len__
MutableSequence → + __setitem__, __delitem__, insert
Mapping → __getitem__, __len__, __iter__
Set → __contains__, __len__, __iter__4. Batafsil misollar
Misol 1 — ABC asoslari
"""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:
=== 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__
"""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:
=== ⭐ 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 baytNima ko'rsatdi: 2.5, 2.6, 2.7, 2.8-bo'limlar.
Misol 3 — Interfeys loyihalash
"""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:
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' saqlandiNima ko'rsatdi: 2.1, 2.4-bo'limlar.
Misol 4 — Amaliy: to'lov tizimi
"""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:
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'qNima 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
class A: # ⚠️ himoya yo'q
@abstractmethod
def f(self): ...
class A(ABC): # ✅2. Dekorator tartibi
@abstractmethod
@property # ❌
def x(self): ...
@property
@abstractmethod # ✅
def x(self): ...3. register() ga ishonish
A.register(Yolgon) # ⚠️ tekshirmaydi
class Yolgon(A): ... # ✅ yoki __subclasshook__4. __subclasshook__ da cls tekshiruvi yo'q
@classmethod
def __subclasshook__(cls, C):
return "f" in dir(C) # ⚠️ avlodlar buziladi
if cls is A: ... # ✅
return NotImplemented5. Eskirgan dekoratorlar
@abstractproperty # ⚠️ 3.3 dan eskirgan
@property # ✅
@abstractmethod6. __init_subclass__ da abstrakt sinfni ro'yxatga olish
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
class Nuqta(ABC): # ⚠️ ortiqcha
@dataclass # ✅
class Nuqta: ...8. Juda ko'p abstrakt metod
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.abckonteynerlarda - 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
ABCdan meros oling.@abstractmethodo'zi yetarli emas.3-5 abstrakt metod. Ko'p bo'lsa — interfeysni bo'ling.
Sukut amalga oshirishlar bering. ABC ning asosiy afzalligi.
@abstractmethod— eng ichkarida.@propertydan keyin.register()ni ehtiyot ishlating. Tekshirmaydi, metod bermaydi.__subclasshook__daif cls is X. Avlodlar buzilmasin.__abstractmethods__bilan registry filtri. Chala sinflar tushmasin.Tashqi kod uchun
Protocol. ABC — o'z ierarxiyangiz uchun.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
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
xatoA—ABCemas, yaratildi1 frozenset()True FalseTrueTrue Falseg— sukut metod meros olindi['__getitem__', '__len__']['x']<__main__.A object at 0x...>— abstrakt metod yo'qFalse 0—Iterablefaqat__iter__ni tekshiradi, lekiniter()eski__getitem__protokoli bilan ham ishlaydi.list(A())esa cheksiz davom etardi —IndexErrorhech qachon chiqmaydi['f', 'g']
Vazifa 2: Xatolarni tuzating
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 metodJavoblar
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, OchiruvchiVazifa 3: Serializator ABC
Yozing:
- Abstrakt:
_yoz(obj),_oqi(matn),KENGAYTMA - Bepul:
saqla(obj, yol),yukla(yol),tekshir(matn) @classmethod kengaytmadan(yol)— registry__init_subclass__bilan avtomatik ro'yxat- JSON, CSV, XML amalga oshirishlari
- Chala sinf ro'yxatga tushmasin
Vazifa 4: ABC tekshiruvchisi
Vosita yozing:
@abstractmethodbor,ABCyo'q sinflarni topsin- Noto'g'ri dekorator tartibini
- Eskirgan
abstractpropertyni register()da metod yo'qligini tekshirsin- Juda ko'p abstrakt metodni (>7) ogohlantirsin
__subclasshook__daclstekshiruvi yo'qligini
Vazifa 5: collections.abc bilan
SequencedanHalqa(ring buffer)MutableMappingdanIkkiTomonlamaLugatSetdanIntervalToplam- Har birida minimal metodlar
- Bepul metodlarni sanang
- Tezlik uchun ba'zilarini qayta aniqlang
Vazifa 6: Plagin arxitekturasi
Plagin(ABC)—nom,versiya,ishga_tushir- Ixtiyoriy ilgaklar (abstrakt emas)
- Bog'liqliklar tekshiruvi
- Yuklash tartibi (topologik saralash)
Protocolbilan tashqi plaginlar- 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
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 chiqarishdaXato ishlatish paytida — ehtimol tunda, ishlab chiqarishda.
ABC bilan:
Chala()
# TypeError: Can't instantiate abstract class Chala without an
# implementation for abstract method 'olish'Test yozishdan oldin aniqlanadi.
2. Muammo 2: interfeys hujjatsiz
def ishla(ombor):
...Savollar:
omborqanday metodlarga ega bo'lishi kerak?- Imzolari qanday?
- Nima qaytaradi?
Javob — butun funksiyani o'qish yoki hujjatni topish.
ABC bilan:
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
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) # ⚠️ takrorABC bilan bir marta:
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
class Ombor:
def saqla(self, k, v):
raise NotImplementedErrorMuammolar:
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:
def f(x):
if hasattr(x, "saqla") and hasattr(x, "olish"): # ⚠️ mo'rt
...Bu:
- Imzoni tekshirmaydi
- Har joyda takrorlanadi
hasattristisnolarni yutadi
ABC bilan:
if isinstance(x, Ombor): ... Va collections.abc bilan o'rnatilgan turlar ham ishlaydi:
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:
isinstancebilan tekshiriladigan interfeyslar- Standart konteyner protokollari (
collections.abc) - Umumiy kodni ulashish (mixin metodlar)
7. Nega duck typing YO'QOLMADI
ABC qo'shimcha, almashtiruv emas:
# 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:
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:
type Ombor interface {
Saqla(k, v string)
}
type MeningOmborim struct{}
func (m MeningOmborim) Saqla(k, v string) {}
// ⭐ Ombor ni E'LON QILMAYDI — avtomatik mos keladiGo 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:
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
# ⭐ 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:
- Xatoni kech aniqlaydi — nusxa yaratilib, keyin buziladi
- Interfeysni hujjatlamaydi — nima kerakligi noaniq
- Umumiy kodni ulashmaydi — takrorlanish
isinstancebilan ishlamaydi —hasattrzanjiri mo'rt
Va ABC duck typing ni almashtirmadi — u:
- Ixtiyoriy qatlam
__subclasshook__bilan duck typing ni rasmiylashtiradicollections.abcorqali 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:
ABC xatoni yaratish paytiga ko'chiradi.
NotImplementedErrorfaqat metod chaqirilganda ishlaydi;@abstractmethod+ABCesa chala sinfning **nusxasini yaratishga yo'l qo'ymaydi. Lekin@abstractmethodo'zi faqatisabstractmethodbayrog'ini qo'yadi — tekshiruvniABCMetaqiladi, shuning uchunABC` dan meros olish shart.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 metoddanappend,pop,remove,extend,__iadd__va boshqalar kelib chiqadi.register()hech narsani tekshirmaydi va metod bermaydi. U faqatisinstance/issubclassuchun; MRO ga kirmaydi,super()ishlamaydi, sukut metodlar meros olinmaydi. Avtomatik tanish kerak bo'lsa —__subclasshook__(ichidaif cls is Xtekshiruvi bilan), tashqi kod bilan interfeys kerak bo'lsa —Protocol.
Keyingi darsda __slots__ ni ko'ramiz: xotira optimizatsiyasi, cheklovlari va qachon u haqiqatan kerak.
Izohlar · 0
Izoh yozish uchun kiring.