10.15-dars: Python ma'lumot modeli

class Proksi:
    def __init__(self, asl):
        self._asl = asl

    def __getattr__(self, nom):
        jurnal.info(f"murojaat: {nom}")
        return getattr(self._asl, nom)

royxat = Proksi([3, 1, 2])
royxat.append(4)        # ✅ ishlaydi
royxat.__len__()        # ✅ 4
len(royxat)             # ❌ TypeError: object of type 'Proksi' has no len()
royxat + [5]            # ❌ TypeError: unsupported operand type(s) for +
for x in royxat: ...    # ❌ TypeError: 'Proksi' object is not iterable

type(5)            # int
type(int)          # type      — klass ham obyekt, uning turi type
type(type)         # type      — type o'zining turi
int.__bases__      # (object,)
type.__bases__     # (object,) — type ham object dan meros oladi
object.__bases__   # ()        — ierarxiya ildizi
isinstance(type, object), isinstance(object, type)   # True, True

class Hisob:
    __hash__ = None          # xeshlanmaydi (o'zgaruvchan tur)

class Satrlar:
    def __getitem__(self, i): ...
    __iter__ = None          # iter() va for — TypeError; __getitem__ zaxirasi ham ishlamaydi

id(x) / x is y     identifikatsiya — o'zgarmaydi
type(x)            tur — xatti-harakat
== / tarkib        qiymat
type(type) is type    type.__bases__ == (object,)    object.__bases__ == ()

len(x)  →  type(x).__len__(x)       (x.__len__ emas)
nusxadagi dunder, __getattribute__, __getattr__ — chetlab o'tiladi
proksi: dunderlarni klassga yozing

bool:     __bool__ → __len__ → True
in:       __contains__ → __iter__ → __getitem__
iter:     __iter__ → __getitem__
reversed: __reversed__ → __len__ + __getitem__
!=:       __ne__ → not __eq__
str:      __str__ → __repr__
hash:     __eq__ yozilsa → None

__hash__ = None       __iter__ = None
try: iter(x)          # isinstance(x, Iterable) dan ishonchliroq
except TypeError: ...

"""Hamma narsa obyekt; identifikatsiya/tur/qiymat; type va object; __class__ ni almashtirish."""

import types


def korsat(nom, x):
    print(f"  {nom:18} tur={type(x).__name__:18} turining turi={type(type(x)).__name__}")


print("=== 1. Hamma narsa obyekt ===")


def funksiya():
    pass


class Klass:
    pass


for nom, x in [("5", 5), ("'matn'", "matn"), ("funksiya", funksiya), ("Klass", Klass),
               ("Klass()", Klass()), ("types moduli", types), ("funksiya.__code__", funksiya.__code__),
               ("ValueError", ValueError), ("None", None), ("type", type)]:
    korsat(nom, x)

print("\n=== 2. type va object ===")
print(f"  type(type) is type: {type(type) is type}")
print(f"  type.__bases__: {type.__bases__}, object.__bases__: {object.__bases__}")
print(f"  isinstance(type, object): {isinstance(type, object)}, isinstance(object, type): {isinstance(object, type)}")
print(f"  int.__mro__: {[k.__name__ for k in int.__mro__]}, bool.__mro__: {[k.__name__ for k in bool.__mro__]}")

print("\n=== 3. Identifikatsiya, tur, qiymat ===")
a = [1, 2]
b = a
c = [1, 2]
print(f"  a == c: {a == c}, a is c: {a is c}, a is b: {b is a}")
eski_id = id(a)
a.append(3)
print(f"  append dan keyin: id o'zgarmadi {id(a) == eski_id}, qiymat o'zgardi {a}, b ham: {b}")
s = "salom"
eski_id = id(s)
s += "!"
print(f"  satr += dan keyin: id o'zgardimi {id(s) != eski_id} — yangi obyekt")
t = (1, [2])
t[1].append(3)
print(f"  kortej o'zgarmas, lekin ichidagi ro'yxat o'zgaradi: {t}")

print("\n=== 4. Tur xatti-harakatni belgilaydi: __class__ ni almashtirish ===")


class Qoralama:
    def holat(self):
        return f"qoralama: {self.matn!r}"


class Chop:
    def holat(self):
        return f"chop etilgan: {self.matn!r}"


h = Qoralama()
h.matn = "Hisobot"
print(f"  {h.holat()}")
h.__class__ = Chop
print(f"  __class__ = Chop dan keyin: {h.holat()}, isinstance(h, Qoralama): {isinstance(h, Qoralama)}")
try:
    x = 5
    x.__class__ = float
except TypeError as e:
    print(f"  int uchun: TypeError: {e}")

=== 1. Hamma narsa obyekt ===
  5                  tur=int                turining turi=type
  'matn'             tur=str                turining turi=type
  funksiya           tur=function           turining turi=type
  Klass              tur=type               turining turi=type
  Klass()            tur=Klass              turining turi=type
  types moduli       tur=module             turining turi=type
  funksiya.__code__  tur=code               turining turi=type
  ValueError         tur=type               turining turi=type
  None               tur=NoneType           turining turi=type
  type               tur=type               turining turi=type

=== 2. type va object ===
  type(type) is type: True
  type.__bases__: (<class 'object'>,), object.__bases__: ()
  isinstance(type, object): True, isinstance(object, type): True
  int.__mro__: ['int', 'object'], bool.__mro__: ['bool', 'int', 'object']

=== 3. Identifikatsiya, tur, qiymat ===
  a == c: True, a is c: False, a is b: True
  append dan keyin: id o'zgarmadi True, qiymat o'zgardi [1, 2, 3], b ham: [1, 2, 3]
  satr += dan keyin: id o'zgardimi True — yangi obyekt
  kortej o'zgarmas, lekin ichidagi ro'yxat o'zgaradi: (1, [2, 3])

=== 4. Tur xatti-harakatni belgilaydi: __class__ ni almashtirish ===
  qoralama: 'Hisobot'
  __class__ = Chop dan keyin: chop etilgan: 'Hisobot', isinstance(h, Qoralama): False
  int uchun: TypeError: __class__ assignment only supported for mutable types or ModuleType subclasses

"""Nusxadagi dunder e'tiborsiz; __getattribute__ chetlab o'tiladi; __getattr__ proksisi va uni tuzatish."""

print("=== 1. Nusxaga qo'shilgan __len__ ===")


class Bosh:
    pass


b = Bosh()
b.__len__ = lambda: 5
print(f"  b.__len__(): {b.__len__()}")
try:
    len(b)
except TypeError as e:
    print(f"  len(b): TypeError: {e}")
Bosh.__len__ = lambda self: 7
print(f"  klassga qo'shilgach len(b): {len(b)}   (nusxadagi 5 emas)")

print("\n=== 2. __getattribute__ chetlab o'tiladi ===")
chaqiruvlar = []


class Kuzatilgan:
    def __getattribute__(self, nom):
        chaqiruvlar.append(nom)
        return object.__getattribute__(self, nom)

    def __len__(self):
        return 3

    def __repr__(self):
        return "Kuzatilgan()"


k = Kuzatilgan()
len(k), repr(k), bool(k)
print(f"  len, repr, bool dan keyin __getattribute__ chaqiruvlari: {chaqiruvlar}")
k.__len__()
k.__repr__()
print(f"  aniq k.__len__(), k.__repr__() dan keyin: {chaqiruvlar}")

print("\n=== 3. ⚠️ __getattr__ proksisi ===")


class Proksi:
    def __init__(self, asl):
        object.__setattr__(self, "_asl", asl)
        object.__setattr__(self, "jurnal", [])

    def __getattr__(self, nom):
        self.jurnal.append(nom)
        return getattr(self._asl, nom)


p = Proksi([3, 1, 2])
p.append(4)
print(f"  p.append(4), p.__len__() = {p.__len__()}, jurnal: {p.jurnal}")
for tavsif, amal in [("len(p)", lambda: len(p)), ("p[0]", lambda: p[0]), ("p + [5]", lambda: p + [5]),
                     ("list(p)", lambda: list(p)), ("2 in p", lambda: 2 in p), ("str(p)", lambda: str(p))]:
    try:
        natija = amal()
        print(f"  {tavsif:10} → {natija if tavsif != 'str(p)' else natija.split(' object')[0] + ' object ...>'}")
    except TypeError as e:
        print(f"  {tavsif:10} → TypeError: {e}")

print("\n=== 4. ✅ Tuzatish: maxsus metodlarni klassga generatsiya qilish ===")
UZATILADIGAN = ["__len__", "__getitem__", "__setitem__", "__iter__", "__contains__",
                "__add__", "__radd__", "__eq__", "__repr__", "__str__", "__bool__"]


def proksi_klassi(asl_tur):
    def uzat(nom):
        def metod(self, *args):
            self.jurnal.append(nom)
            return getattr(self._asl, nom)(*args)
        metod.__name__ = nom
        return metod

    lugat = {nom: uzat(nom) for nom in UZATILADIGAN if hasattr(asl_tur, nom)}
    lugat["__hash__"] = None
    return type(f"{asl_tur.__name__.title()}Proksi", (Proksi,), lugat)


RoyxatProksi = proksi_klassi(list)
p = RoyxatProksi([3, 1, 2])
print(f"  len(p)={len(p)}, p[0]={p[0]}, p + [5]={p + [5]}, list(p)={list(p)}, 2 in p={2 in p}, str(p)={p}")
print(f"  jurnal: {p.jurnal}")
print(f"  klass nomi: {type(p).__name__}, oddiy metod hali ham __getattr__ orqali: {p.count(1)}, jurnal oxiri: {p.jurnal[-1]}")

print("\n=== 5. Nega turda: metaklass muammosi ===")
print(f"  repr(int) = {repr(int)!r}  — type.__repr__(int) chaqirildi")
print(f"  int.__repr__(5) = {int.__repr__(5)!r}  — int nusxalari uchun metod")
try:
    int.__repr__()
except TypeError as e:
    print(f"  agar repr(int) → int.__repr__() bo'lganda: TypeError: {e}")

=== 1. Nusxaga qo'shilgan __len__ ===
  b.__len__(): 5
  len(b): TypeError: object of type 'Bosh' has no len()
  klassga qo'shilgach len(b): 7   (nusxadagi 5 emas)

=== 2. __getattribute__ chetlab o'tiladi ===
  len, repr, bool dan keyin __getattribute__ chaqiruvlari: []
  aniq k.__len__(), k.__repr__() dan keyin: ['__len__', '__repr__']

=== 3. ⚠️ __getattr__ proksisi ===
  p.append(4), p.__len__() = 4, jurnal: ['append', '__len__']
  len(p)     → TypeError: object of type 'Proksi' has no len()
  p[0]       → TypeError: 'Proksi' object is not subscriptable
  p + [5]    → TypeError: unsupported operand type(s) for +: 'Proksi' and 'list'
  list(p)    → TypeError: 'Proksi' object is not iterable
  2 in p     → TypeError: argument of type 'Proksi' is not a container or iterable
  str(p)     → <__main__.Proksi object ...>

=== 4. ✅ Tuzatish: maxsus metodlarni klassga generatsiya qilish ===
  len(p)=3, p[0]=3, p + [5]=[3, 1, 2, 5], list(p)=[3, 1, 2], 2 in p=True, str(p)=[3, 1, 2]
  jurnal: ['__len__', '__getitem__', '__add__', '__iter__', '__len__', '__contains__', '__str__']
  klass nomi: ListProksi, oddiy metod hali ham __getattr__ orqali: 1, jurnal oxiri: count

=== 5. Nega turda: metaklass muammosi ===
  repr(int) = "<class 'int'>"  — type.__repr__(int) chaqirildi
  int.__repr__(5) = '5'  — int nusxalari uchun metod
  agar repr(int) → int.__repr__() bo'lganda: TypeError: descriptor '__repr__' of 'int' object needs an argument

"""__getitem__ bilan iteratsiya va in; __len__ bilan bool va reversed; != va str zaxiralari; = None; abc farqlari."""

import collections.abc as abc


class Hafta:
    """Faqat __getitem__ — eski ketma-ketlik protokoli."""
    kunlar = ["Dush", "Sesh", "Chor", "Pay", "Juma", "Shan", "Yak"]

    def __getitem__(self, i):
        print(f"      __getitem__({i})", end="")
        return self.kunlar[i]


print("=== 1. Faqat __getitem__ ===")
h = Hafta()
print(f"  list(h):")
natija = list(h)
print(f"\n    → {natija}")
print(f"  'Chor' in h:")
bor = "Chor" in h
print(f"\n    → {bor}   (Chor topilgach to'xtadi)")
try:
    reversed(h)
except TypeError as e:
    print(f"  reversed(h): TypeError: {e}")
print(f"  bool(h): {bool(h)}   (__bool__ ham __len__ ham yo'q → True)")


class HaftaLen(Hafta):
    def __len__(self):
        return len(self.kunlar)


print("\n=== 2. __getitem__ + __len__ ===")
hl = HaftaLen()
print("  reversed:", end="")
teskari = list(reversed(hl))
print(f"\n    → {teskari[:3]} ...")


class Bosh(Hafta):
    kunlar = []

    def __len__(self):
        return 0


print(f"  bo'sh: bool={bool(Bosh())}   (__len__ = 0)")

print("\n=== 3. !=, str, format, hash zaxiralari ===")


class Nuqta:
    def __init__(self, x):
        self.x = x

    def __eq__(self, boshqa):
        print(f"      __eq__ chaqirildi", end="")
        return isinstance(boshqa, Nuqta) and self.x == boshqa.x

    def __repr__(self):
        return f"Nuqta({self.x})"


print(f"  Nuqta(1) != Nuqta(2):", end="")
farq = Nuqta(1) != Nuqta(2)
print(f" → {farq}")
print(f"  str(Nuqta(1)) = {str(Nuqta(1))!r} (__str__ yo'q → __repr__), f'{{Nuqta(1)}}' = {Nuqta(1)}")
try:
    format(Nuqta(1), ">10")
except TypeError as e:
    print(f"  format(Nuqta(1), '>10'): TypeError: {e}")
print(f"  Nuqta.__hash__: {Nuqta.__hash__}   (__eq__ yozildi → xeshlanmaydi)")

print("\n=== 4. Protokolni None bilan o'chirish ===")


class YopiqHafta(Hafta):
    __iter__ = None


for tavsif, amal in [("iter()", lambda: iter(YopiqHafta())), ("'Dush' in", lambda: "Dush" in YopiqHafta()),
                     ("list()", lambda: list(YopiqHafta()))]:
    try:
        amal()
        print(f"  {tavsif}: ishladi")
    except TypeError as e:
        print(f"  {tavsif}: TypeError: {e}")
print(f"  lekin indeks bilan murojaat qoladi:", end="")
kun = YopiqHafta()[0]
print(f" → {kun}")

print("\n=== 5. collections.abc va haqiqiy xatti-harakat ===")


def iteratsiya_qilsa_boladimi(x):
    try:
        iter(x)
        return True
    except TypeError:
        return False


class Toliq(abc.Sequence):
    def __init__(self, d):
        self.d = d

    def __getitem__(self, i):
        return self.d[i]

    def __len__(self):
        return len(self.d)


print(f"  {'tur':12} {'iter() ishlaydi':16} {'Iterable':9} {'Sequence':9}")
for nom, x in [("list", [1]), ("Hafta", Hafta()), ("HaftaLen", HaftaLen()), ("YopiqHafta", YopiqHafta()),
               ("Toliq", Toliq([1, 2, 2]))]:
    import io, contextlib
    with contextlib.redirect_stdout(io.StringIO()):
        ishlaydi = iteratsiya_qilsa_boladimi(x)
    print(f"  {nom:12} {str(ishlaydi):16} {str(isinstance(x, abc.Iterable)):9} {str(isinstance(x, abc.Sequence)):9}")
t = Toliq([1, 2, 2])
print(f"  Toliq — ABC dan bepul: count(2)={t.count(2)}, index(2)={t.index(2)}, 2 in t={2 in t}, reversed={list(reversed(t))}")

=== 1. Faqat __getitem__ ===
  list(h):
      __getitem__(0)      __getitem__(1)      __getitem__(2)      __getitem__(3)      __getitem__(4)      __getitem__(5)      __getitem__(6)      __getitem__(7)
    → ['Dush', 'Sesh', 'Chor', 'Pay', 'Juma', 'Shan', 'Yak']
  'Chor' in h:
      __getitem__(0)      __getitem__(1)      __getitem__(2)
    → True   (Chor topilgach to'xtadi)
  reversed(h): TypeError: object of type 'Hafta' has no len()
  bool(h): True   (__bool__ ham __len__ ham yo'q → True)

=== 2. __getitem__ + __len__ ===
  reversed:      __getitem__(6)      __getitem__(5)      __getitem__(4)      __getitem__(3)      __getitem__(2)      __getitem__(1)      __getitem__(0)
    → ['Yak', 'Shan', 'Juma'] ...
  bo'sh: bool=False   (__len__ = 0)

=== 3. !=, str, format, hash zaxiralari ===
  Nuqta(1) != Nuqta(2):      __eq__ chaqirildi → True
  str(Nuqta(1)) = 'Nuqta(1)' (__str__ yo'q → __repr__), f'{Nuqta(1)}' = Nuqta(1)
  format(Nuqta(1), '>10'): TypeError: unsupported format string passed to Nuqta.__format__
  Nuqta.__hash__: None   (__eq__ yozildi → xeshlanmaydi)

=== 4. Protokolni None bilan o'chirish ===
  iter(): TypeError: 'YopiqHafta' object is not iterable
  'Dush' in: TypeError: argument of type 'YopiqHafta' is not a container or iterable
  list(): TypeError: 'YopiqHafta' object is not iterable
  lekin indeks bilan murojaat qoladi:      __getitem__(0) → Dush

=== 5. collections.abc va haqiqiy xatti-harakat ===
  tur          iter() ishlaydi  Iterable  Sequence
  list         True             True      True
  Hafta        True             False     False
  HaftaLen     True             False     False
  YopiqHafta   False            False     False
  Toliq        True             True      True
  Toliq — ABC dan bepul: count(2)=2, index(2)=1, 2 in t=True, reversed=[2, 2, 1]

"""Tur bo'yicha protokollarni aniqlash (to'g'ridan-to'g'ri / zaxira / o'chirilgan); o'rnatilgan va o'z turlarimiz."""

import collections
import collections.abc as abc
from dataclasses import dataclass
from fractions import Fraction

TOLIQ_YOQ = object()


def turda(tur, nom):
    """MRO bo'ylab klass lug'atlaridan qidiradi (object dagisini alohida belgilaydi)."""
    for klass in tur.__mro__:
        if nom in vars(klass):
            qiymat = vars(klass)[nom]
            if qiymat is None:
                return "o'chirilgan"
            return "object" if klass is object else "bor"
    return TOLIQ_YOQ


def protokollar(x):
    tur = type(x)
    t = lambda nom: turda(tur, nom)
    natija = {}

    def belgila(nom, asosiy, *zaxiralar):
        holat = t(asosiy)
        if holat == "bor":
            natija[nom] = "✅"
            return
        if holat == "o'chirilgan":
            natija[nom] = "⛔"
            return
        for belgi, shart in zaxiralar:
            if shart():
                natija[nom] = f"↩ {belgi}"
                return
        natija[nom] = "—"

    belgila("iter", "__iter__", ("__getitem__", lambda: t("__getitem__") == "bor"))
    belgila("in", "__contains__", ("__iter__", lambda: t("__iter__") == "bor"),
            ("__getitem__", lambda: t("__getitem__") == "bor" and t("__iter__") is TOLIQ_YOQ))
    belgila("len", "__len__")
    belgila("bool", "__bool__", ("__len__", lambda: t("__len__") == "bor"), ("sukut", lambda: True))
    belgila("reversed", "__reversed__",
            ("len+getitem", lambda: t("__len__") == "bor" and t("__getitem__") == "bor"))
    belgila("hash", "__hash__", ("object", lambda: t("__hash__") == "object"))
    belgila("str", "__str__", ("__repr__", lambda: t("__repr__") == "bor"))
    belgila("chaqirish", "__call__")
    belgila("with", "__enter__")
    belgila("+", "__add__")
    return natija


@dataclass
class Talaba:
    ism: str
    ball: int = 0


@dataclass(frozen=True, order=True)
class Versiya:
    katta: int
    kichik: int


class Hafta:
    def __getitem__(self, i):
        return ["Dush", "Sesh"][i]


class Tovar:
    __hash__ = None
    __iter__ = None

    def __getitem__(self, i):
        return i


OBYEKTLAR = [
    ("list", [1]), ("tuple", (1,)), ("dict", {}), ("str", "a"), ("set", set()),
    ("generator", (x for x in [])), ("Counter", collections.Counter()), ("Fraction", Fraction(1, 2)),
    ("open fayl", open(__file__) if "__file__" in globals() else __import__("io").StringIO()),
    ("funksiya", len), ("Talaba", Talaba("A")), ("Versiya", Versiya(1, 0)),
    ("Hafta", Hafta()), ("Tovar", Tovar()),
]

ustunlar = list(protokollar([]).keys())
print("=== Protokollar xaritasi ===")
print("  ✅ to'g'ridan-to'g'ri   ↩ zaxira orqali   ⛔ = None bilan o'chirilgan   — yo'q\n")
print(f"  {'':11}" + "".join(f"{u:>15}" for u in ustunlar))
for nom, x in OBYEKTLAR:
    p = protokollar(x)
    print(f"  {nom:11}" + "".join(f"{p[u]:>15}" for u in ustunlar))

print("\n=== Xarita haqiqatga mosmi — tekshiruv ===")
tekshiruvlar = {
    "iter": lambda x: iter(x),
    "hash": lambda x: hash(x),
    "bool": lambda x: bool(x),
    "reversed": lambda x: reversed(x),
}
nomuvofiq = []
for nom, x in OBYEKTLAR:
    p = protokollar(x)
    for protokol, amal in tekshiruvlar.items():
        kutilgan = p[protokol] not in ("—", "⛔")
        try:
            amal(x)
            haqiqiy = True
        except (TypeError, ValueError):
            haqiqiy = False
        if kutilgan != haqiqiy:
            nomuvofiq.append((nom, protokol, p[protokol], haqiqiy))
HECH_BIRI = "yo'q — xarita haqiqatga mos"
print(f"  {len(OBYEKTLAR)} obyekt × {len(tekshiruvlar)} amal, nomuvofiqliklar: {nomuvofiq or HECH_BIRI}")
print(f"  dict reversed: {protokollar({})['reversed']} — Python 3.8 dan dict tartibni teskari aylanadi")
print(f"  Talaba hash: {protokollar(Talaba('A'))['hash']} — dataclass eq=True, frozen=False → __hash__ = None")
for _, x in OBYEKTLAR:
    if hasattr(x, "close") and not isinstance(x, abc.Generator):
        x.close()

=== Protokollar xaritasi ===
  ✅ to'g'ridan-to'g'ri   ↩ zaxira orqali   ⛔ = None bilan o'chirilgan   — yo'q

                        iter             in            len           bool       reversed           hash            str      chaqirish           with              +
  list                     ✅              ✅              ✅      ↩ __len__              ✅              ⛔     ↩ __repr__              —              —              ✅
  tuple                    ✅              ✅              ✅      ↩ __len__  ↩ len+getitem              ✅     ↩ __repr__              —              —              ✅
  dict                     ✅              ✅              ✅      ↩ __len__              ✅              ⛔     ↩ __repr__              —              —              —
  str                      ✅              ✅              ✅      ↩ __len__  ↩ len+getitem              ✅              ✅              —              —              ✅
  set                      ✅              ✅              ✅      ↩ __len__              —              ⛔     ↩ __repr__              —              —              —
  generator                ✅     ↩ __iter__              —        ↩ sukut              —       ↩ object     ↩ __repr__              —              —              —
  Counter                  ✅              ✅              ✅      ↩ __len__              ✅              ⛔     ↩ __repr__              —              —              ✅
  Fraction                 —              —              —              ✅              —              ✅              ✅              —              —              ✅
  open fayl                ✅     ↩ __iter__              —        ↩ sukut              —       ↩ object     ↩ __repr__              —              ✅              —
  funksiya                 —              —              —        ↩ sukut              —              ✅     ↩ __repr__              ✅              —              —
  Talaba                   —              —              —        ↩ sukut              —              ⛔     ↩ __repr__              —              —              —
  Versiya                  —              —              —        ↩ sukut              —              ✅     ↩ __repr__              —              —              —
  Hafta        ↩ __getitem__  ↩ __getitem__              —        ↩ sukut              —       ↩ object              —              —              —              —
  Tovar                    ⛔              —              —        ↩ sukut              —              ⛔              —              —              —              —

=== Xarita haqiqatga mosmi — tekshiruv ===
  14 obyekt × 4 amal, nomuvofiqliklar: yo'q — xarita haqiqatga mos
  dict reversed: ✅ — Python 3.8 dan dict tartibni teskari aylanadi
  Talaba hash: ⛔ — dataclass eq=True, frozen=False → __hash__ = None

obj.__len__ = lambda: 10               # ❌ len(obj) e'tibor bermaydi

type(obj).__len__ = lambda self: 10    # ✅ (lekin barcha nusxalarga ta'sir qiladi)

class Proksi:
    def __getattr__(self, nom):
        return getattr(self._asl, nom)
len(Proksi([1]))                       # ❌ TypeError

if isinstance(x, abc.Iterable):        # ❌ __getitem__ turlarini o'tkazib yuboradi
    ...

try:
    it = iter(x)                       # ✅
except TypeError:
    ...

class Nuqta:
    def __eq__(self, b): ...
{Nuqta(1)}                             # ❌ TypeError: unhashable type

    def __hash__(self): return hash(self.x)   # ✅ (yoki o'zgaruvchan bo'lsa ataylab None)

class Pul:
    def __str__(self): return "150 000 so'm"   # ❌ ro'yxatda, debuggerda <Pul object at 0x...>

    def __repr__(self): return "Pul('150000')" # ✅ avval __repr__ — __str__ unga qaytadi

class Savat:
    def __len__(self): return len(self.mahsulotlar)
if savat:                              # ⚠️ bo'sh savat — False; "savat obyekti bormi" degan ma'noda emas

int.__repr__()                         # ❌ TypeError — bu int NUSXALARI uchun metod
type.__repr__(int)                     # ✅ klass uchun — repr(int)

class Jadval(dict):                    # o'zgaruvchan, lekin...
    def __eq__(self, b): ...           # __hash__ = None avtomatik ✅

class Hisob:
    def __getitem__(self, i): ...      # ⚠️ for x in hisob — 0, 1, 2... indekslar bilan chaqiriladi
    __iter__ = None                    # ✅ ataylab taqiqlash

import collections.abc as abc

class G:
    def __getitem__(self, i):
        if i >= 3:
            raise IndexError
        return i * 10

class P:
    def __init__(self, t):
        self._t = t
    def __getattr__(self, n):
        return getattr(self._t, n)

class E:
    def __eq__(self, o):
        return True
1.  print(list(G()))
2.  print(20 in G(), 5 in G())
3.  print(isinstance(G(), abc.Iterable))
4.  p = P([1, 2, 3])
    print(p.__len__(), p.count(2))
5.  try:
        len(P([1]))
    except TypeError:
        print("TypeError")
6.  print(E() == 1, E() != 1)
7.  print(E.__hash__)
8.  class K:
        pass
    k = K()
    k.__len__ = lambda: 7
    print(hasattr(k, "__len__"), k.__len__())
9.  class B:
        def __len__(self):
            return 0
    print(bool(B()), "bor" if B() else "yo'q")
10. print(type(type) is type, isinstance(type, object), issubclass(type, object))
11. class S:
        def __repr__(self):
            return "S!"
    print(str(S()), f"{S()}")
12. class Y:
        __iter__ = None
        def __getitem__(self, i):
            return i
    try:
        iter(Y())
    except TypeError:
        print("TypeError")

1.  class Lazy:
        def __init__(self, yuklovchi):
            self._yuklovchi = yuklovchi
            self._obyekt = None
        def __getattr__(self, nom):
            if self._obyekt is None:
                self._obyekt = self._yuklovchi()
            return getattr(self._obyekt, nom)
    royxat = Lazy(lambda: [1, 2, 3])
    print(len(royxat))

2.  def iteratsiya_qilinadimi(x):
        return isinstance(x, collections.abc.Iterable)

3.  class Foydalanuvchi:
        def __init__(self, id):
            self.id = id
        def __eq__(self, b):
            return self.id == b.id
    faollar = {Foydalanuvchi(1), Foydalanuvchi(2)}

4.  class Matn:
        def __init__(self, s):
            self.s = s
        def __str__(self):
            return self.s
    print([Matn("a"), Matn("b")])

5.  obj = Sozlama()
    obj.__contains__ = lambda k: k in obj.malumot
    print("til" in obj)