Python kursi8.2-dars: Klass va obyekt
Python kursi · OOP

8.2-dars: Klass va obyekt

32 daqiqa2/20-dars

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


1. Kirish va motivatsiya

Eng oddiy sinf:

python
class Bosh:
    pass

Uch qator emas — ikki qator. Lekin bu ikki qator ortida ancha narsa turadi:

python
Bosh                            # <class '__main__.Bosh'>
type(Bosh)                      # <class 'type'>       ← sinf ham obyekt
Bosh.__name__                   # 'Bosh'
Bosh.__bases__                  # (<class 'object'>,)  ← avtomatik meros
len(dir(Bosh))                  # 26 — bepul kelgan atributlar

b = Bosh()
type(b)                         # <class '__main__.Bosh'>
b.__dict__                      # {} — bo'sh, lekin bor
b.nimadir = 5                   # ⭐ ish vaqtida atribut qo'shildi
b.__dict__                      # {'nimadir': 5}

Savollar:

  • Bosh() yozganda aniq nima bo'ladi?
  • Obyekt xotirada qanday saqlanadi?
  • b.nimadir qidiruvi qayerlarga qaraydi?
  • Nega Bosh ham obyekt?

Bu darsda:

  • class sintaksisi va uning ish tartibi
  • Nusxa yaratish — __new__ va __init__
  • Obyekt xotirada: __dict__
  • Atribut qidiruv tartibi
  • type(), isinstance(), id()
  • Sinf tanasi — bu oddiy kod

2. Nazariya — chuqur tushuntirish

2.1. class sintaksisi

python
class Nom:
    """Docstring."""

    SINF_ATRIBUTI = 10          # barcha nusxalar uchun umumiy

    def __init__(self, x):      # konstruktor (aslida — initsializator)
        self.x = x              # nusxa atributi

    def metod(self):            # oddiy metod
        return self.x * 2

Nomlash kelishuvi (PEP 8):

Nima Uslub Misol
Sinf PascalCase Foydalanuvchi, HTTPUlanish
Metod snake_case saqla, hisobla_jami
Sinf konstantasi SCREAMING_SNAKE MAKS_URINISH
Ichki _prefiks _ichki_holat

2.2. Sinf tanasi — bu oddiy kod

Bu — Pythonning muhim, lekin kam bilinadigan xususiyati:

python
class A:
    print("Bu sinf yaratilayotganda ISHLAYDI!")
    x = 1
    y = x + 1                   # oddiy o'zgaruvchi kabi
    for i in range(3):          # tsikl ham mumkin
        pass
    z = [q for q in range(3)]   # ⚠️ ehtiyot bo'ling (8.2.6)

A.x, A.y, A.i                   # 1, 2, 2 ← i ham atribut bo'ldi!

Nima bo'ladi:

  1. Python class A: ni ko'radi
  2. Yangi nom fazosi (lug'at) yaratadi
  3. Tana kodini shu fazoda bajaradi
  4. type("A", bases, nom_fazosi) chaqiradi
  5. Natijani A nomiga bog'laydi
python
# class A: x = 1  ≡
A = type("A", (object,), {"x": 1})

Shuning uchun sinf tanasidagi har o'zgaruvchi sinf atributi bo'ladi — hatto tsikl hisoblagichi ham.

2.3. Nusxa yaratish: __new__ va __init__

Nom(argumentlar) yozilganda uch qadam:

1. __call__ (metaklassda)     type.__call__(Nom, args)
        ↓
2. __new__                    obyektni YARATADI, qaytaradi
        ↓
3. __init__                   obyektni SOZLAYDI, None qaytaradi
python
class Kuzatuv:
    def __new__(cls, *args, **kwargs):
        print(f"  1. __new__  — obyekt yaratiladi (cls={cls.__name__})")
        obj = super().__new__(cls)
        print(f"     yaratildi: id={id(obj)}")
        return obj              # ⚠️ QAYTARISH SHART

    def __init__(self, x):
        print(f"  2. __init__ — sozlanadi (self id={id(self)})")
        self.x = x

k = Kuzatuv(5)

Farqlari:

__new__ __init__
Birinchi argument cls (sinf) self (nusxa)
Vazifa Obyekt yaratish Obyekt sozlash
Qaytaradi Yangi obyekt None
Statik metodmi Ha (yashirin) Yo'q
Qachon yoziladi Kamdan-kam Deyarli doim

__new__ boshqa narsa qaytarsa — __init__ chaqirilmaydi:

python
class A:
    def __new__(cls):
        return 42               # A nusxasi emas
    def __init__(self):
        print("chaqirilmaydi")

A()                             # 42, "chaqirilmaydi" chiqmaydi

Qachon __new__ kerak:

python
# 1. O'zgarmas turdan meros
class MusbatInt(int):
    def __new__(cls, qiymat):
        if qiymat < 0:
            raise ValueError("Musbat bo'lsin")
        return super().__new__(cls, qiymat)
        # __init__ da kech — int allaqachon yaratilgan

# 2. Nusxalarni keshlash
class Rang:
    _kesh = {}
    def __new__(cls, nom):
        if nom not in cls._kesh:
            cls._kesh[nom] = super().__new__(cls)
        return cls._kesh[nom]

99% holatda faqat __init__ yozasiz.

2.4. __dict__ — obyekt xotirada

Har obyektning o'z lug'ati bor:

python
class Nuqta:
    olcham = 2                  # sinf atributi

    def __init__(self, x, y):
        self.x = x              # nusxa atributi
        self.y = y

p = Nuqta(3, 4)

p.__dict__                      # {'x': 3, 'y': 4}
Nuqta.__dict__                  # {'olcham': 2, '__init__': <function>, ...}

Ikki alohida lug'at:

    Nuqta.__dict__                    p.__dict__
  ┌──────────────────┐            ┌──────────────┐
  │ olcham: 2        │            │ x: 3         │
  │ __init__: <fn>   │            │ y: 4         │
  │ __module__: ...  │            └──────────────┘
  │ __doc__: None    │
  └──────────────────┘                   │
           ▲                             │
           └────── p.__class__ ──────────┘

Nusxa atributi sinf atributini "to'sadi":

python
p.olcham                        # 2 — sinfdan
p.olcham = 99                   # nusxa lug'atiga YOZILADI
p.__dict__                      # {'x': 3, 'y': 4, 'olcham': 99}
Nuqta.olcham                    # 2 — o'zgarmadi
del p.olcham
p.olcham                        # 2 — yana sinfdan

2.5. Atribut qidiruv tartibi

obj.nom yozilganda Python quyidagi tartibda qidiradi:

1. type(obj).__mro__ da DATA deskriptor  (property, __set__ bor)
2. obj.__dict__
3. type(obj).__mro__ (sinf va ota-sinflar)
4. type(obj).__getattr__(nom)            ← faqat topilmasa
5. AttributeError

Sodda holat (deskriptorsiz):

obj.__dict__  →  sinf  →  ota-sinflar  →  __getattr__  →  AttributeError
python
class Ota:
    a = "ota-a"
    b = "ota-b"

class Bola(Ota):
    b = "bola-b"
    c = "bola-c"

x = Bola()
x.c = "nusxa-c"
x.d = "nusxa-d"

x.a                             # 'ota-a'    ← Ota dan
x.b                             # 'bola-b'   ← Bola dan
x.c                             # 'nusxa-c'  ← nusxadan (sinfni to'sdi)
x.d                             # 'nusxa-d'  ← faqat nusxada
x.e                             # AttributeError

Yozish har doim nusxaga boradi:

python
x.a = "yangi"                   # Ota.a EMAS, x.__dict__ ga
Ota.a                           # 'ota-a' — o'zgarmadi

2.6. Sinf tanasidagi qamrov tuzog'i

python
class A:
    x = 10
    y = x * 2                   # ✅ ishlaydi — oddiy kod

    def metod(self):
        return x                # ❌ NameError!

Nega? Sinf tanasi — alohida qamrov, lekin u yopilma zanjiriga kirmaydi (7.8-darsda ko'rgan edik).

python
class A:
    x = 10
    lst = [x for _ in range(3)]         # ⚠️ Python 3 da NameError

Comprehension o'z qamrovini yaratadi va sinf qamrovini ko'rmaydi.

Yechim:

python
class A:
    x = 10
    lst = [x for _ in range(3)]         # ❌

class A:
    X = 10
    LST = [X] * 3                        # ✅ comprehension emas

class A:
    X = 10
    LST = [i for i in (X,) for _ in range(3)]   # ✅ birinchi iterable ko'rinadi

Birinchi for dagi iterable tashqi qamrovda hisoblanadi — shuning uchun (X,) ishlaydi.

2.7. type(), isinstance(), is

python
class A: pass
class B(A): pass

b = B()

type(b) is B                    # True
type(b) is A                    # False  ⚠️ aniq tur
isinstance(b, B)                # True
isinstance(b, A)                # True   ✅ meros hisobga olinadi
issubclass(B, A)                # True

Qaysi birini ishlatish:

python
# ✅ Odatda isinstance
if isinstance(x, (int, float)): ...

# ⚠️ type() faqat aniq tur kerak bo'lsa
if type(x) is dict: ...         # OrderedDict ni rad etadi

# ✅ Eng yaxshisi — umuman tekshirmaslik (duck typing)
try:
    x.metod()
except AttributeError:
    ...

is va ==:

python
a = [1, 2]
b = [1, 2]
a == b                          # True  — qiymat
a is b                          # False — obyekt

x = None
x is None                       # ✅ doim shunday
x == None                       # ⚠️ ishlaydi, lekin PEP 8 rad etadi

2.8. Obyekt hayoti

python
class Kuzatuv:
    def __init__(self, nom):
        self.nom = nom
        print(f"  + {nom} tug'ildi")

    def __del__(self):
        print(f"  - {self.nom} o'ldi")


k = Kuzatuv("A")
k = None                        # havola yo'qoldi → __del__

Havolalar hisobi (reference counting):

python
import sys

x = Kuzatuv("B")
sys.getrefcount(x)              # 2 (x + getrefcount argumenti)
y = x
sys.getrefcount(x)              # 3
del y
sys.getrefcount(x)              # 2
del x                           # 0 → __del__ chaqiriladi

__del__ ga tayanmang:

  • Chaqirilishi kafolatlanmagan (dastur to'satdan tugasa)
  • Aylanma havolalarda kechikadi
  • Ichidagi istisno yutiladi

Resurs uchun kontekst menejeri (with) ishlating — 8.14 va 12-darslarda.


3. Tez ma'lumotnoma

Sinf e'lon qilish

python
class Nom:                      # PascalCase
    """Docstring."""

    KONSTANTA = 10              # sinf atributi

    def __init__(self, x):      # initsializator
        self.x = x              # nusxa atributi

    def metod(self):            # self — birinchi parametr
        return self.x

Nusxa yaratish

Nom(args)
   ↓
__new__(cls, ...)   obyektni yaratadi  →  qaytaradi
   ↓
__init__(self, ...) sozlaydi           →  None

Atribut qidiruv

obj.nom:
  1. data deskriptor (property)
  2. obj.__dict__
  3. type(obj).__mro__
  4. __getattr__
  5. AttributeError

obj.nom = x:   HAR DOIM obj.__dict__ ga

Tekshirish

python
type(x) is A            aniq tur
isinstance(x, A)        meros bilan       ✅ odatda shu
issubclass(B, A)        sinflar uchun
x is None               ✅ None uchun doim is

__dict__

python
obj.__dict__            {'x': 3}
Sinf.__dict__           mappingproxy(...)  — o'zgarmas ko'rinish
vars(obj)               obj.__dict__ bilan bir xil

4. Batafsil misollar

Misol 1 — Sinf qanday yaratiladi

python
"""class buyrug'i aslida nima qiladi."""

print("=== 1. Sinf tanasi — oddiy kod ===\n")

print("  class A: e'lon qilinmoqda...")


class A:
    print("    ← sinf tanasi ISHLADI")
    x = 1
    y = x + 1                       # oldingi atributdan foydalanish
    z = [1, 2, 3]

    for i in range(3):              # ⚠️ i ham atribut bo'ladi
        pass

    def metod(self):
        return "metod"


print(f"\n  A.x = {A.x}, A.y = {A.y}")
print(f"  A.i = {A.i}   ⚠️ tsikl hisoblagichi ham atribut bo'ldi!")

print(f"\n  A.__dict__ dagi o'z atributlari:")
for nom, qiymat in A.__dict__.items():
    if not nom.startswith("__"):
        print(f"    {nom:<10} {qiymat!r}")


print("\n=== 2. class ≡ type(...) ===\n")

# Odatiy usul
class Nuqta1:
    olcham = 2
    def masofa(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5


# Aynan shu narsa, qo'lda
def masofa_fn(self):
    return (self.x ** 2 + self.y ** 2) ** 0.5


Nuqta2 = type("Nuqta2", (object,), {
    "olcham": 2,
    "masofa": masofa_fn,
})

for Sinf in (Nuqta1, Nuqta2):
    p = Sinf()
    p.x, p.y = 3, 4
    print(f"  {Sinf.__name__:<10} olcham={Sinf.olcham}  "
          f"masofa={p.masofa()}  type={type(Sinf).__name__}")

print(f"""
  ⭐ class buyrug'i:
     1. Yangi nom fazosi (lug'at) yaratadi
     2. Tana kodini shu fazoda bajaradi
     3. type(nom, otalar, nom_fazosi) chaqiradi
     4. Natijani nomga bog'laydi
""")


print("=== 3. Bo'sh sinf nima oladi ===\n")

class Bosh:
    pass


print(f"  Bosh.__name__     = {Bosh.__name__!r}")
print(f"  Bosh.__bases__    = {Bosh.__bases__}")
print(f"  Bosh.__module__   = {Bosh.__module__!r}")
print(f"  Bosh.__doc__      = {Bosh.__doc__!r}")
print(f"  Bosh.__mro__      = {Bosh.__mro__}")
print(f"  type(Bosh)        = {type(Bosh)}")

bepul = [a for a in dir(Bosh) if a.startswith("__")]
print(f"\n  Bepul kelgan atributlar ({len(bepul)} ta):")
for i in range(0, min(len(bepul), 24), 4):
    print(f"    {'  '.join(f'{a:<22}' for a in bepul[i:i+3])}")

print(f"""
  ⭐ Bularning hammasi object dan meros.
     class Bosh:  ≡  class Bosh(object):
""")


print("=== 4. ⚠️ Sinf tanasidagi qamrov tuzog'i ===\n")

print("""  ✅ Ishlaydi — oddiy ifoda:

     class A:
         x = 10
         y = x * 2               # x ko'rinadi

  ❌ Ishlamaydi — comprehension:

     class B:
         x = 10
         lst = [x for _ in range(3)]     # NameError: name 'x' is not defined

  ❌ Ishlamaydi — metod ichida:

     class C:
         x = 10
         def f(self):
             return x            # NameError — self.x yoki C.x kerak
""")


class TogriUsul:
    X = 10
    Y = X * 2                       # ✅ oddiy ifoda
    LST1 = [X] * 3                  # ✅ comprehension emas
    LST2 = list(range(X))           # ✅ funksiya chaqiruvi
    LST3 = [i for i in (X,)]        # ✅ birinchi iterable tashqarida

    def metod(self):
        return self.X               # ✅ self orqali


print(f"  TogriUsul.Y    = {TogriUsul.Y}")
print(f"  TogriUsul.LST1 = {TogriUsul.LST1}")
print(f"  TogriUsul.LST2 = {TogriUsul.LST2}")
print(f"  TogriUsul.LST3 = {TogriUsul.LST3}")
print(f"  TogriUsul().metod() = {TogriUsul().metod()}")

# Xatoni ko'rsatamiz
try:
    exec("""
class Xato:
    x = 10
    lst = [x for _ in range(3)]
""")
except NameError as e:
    print(f"\n  Comprehension xatosi: NameError: {e}")

print(f"""
  ⭐ SABAB (7.8-darsda ko'rgan edik):
     Sinf tanasi — alohida qamrov, lekin u YOPILMA
     zanjiriga KIRMAYDI. Comprehension o'z qamrovini
     yaratadi va sinf qamrovini ko'rmaydi.

     Faqat BIRINCHI for dagi iterable tashqi qamrovda
     hisoblanadi — shuning uchun [i for i in (X,)] ishlaydi.
""")


print("=== 5. Sinf atributini o'zgartirish ===\n")

class Hisoblagich:
    jami = 0                        # sinf atributi — umumiy

    def __init__(self, nom):
        self.nom = nom
        Hisoblagich.jami += 1       # ⭐ sinf orqali


a, b, c = Hisoblagich("a"), Hisoblagich("b"), Hisoblagich("c")

print(f"  Hisoblagich.jami = {Hisoblagich.jami}")
print(f"  a.jami = {a.jami}  (sinfdan o'qildi)")

print(f"\n  ⚠️ TUZOQ — nusxa orqali yozish:")
a.jami = 100                        # nusxa lug'atiga yozildi
print(f"    a.jami = 100 dan keyin:")
print(f"      a.jami            = {a.jami}    ← nusxadan")
print(f"      b.jami            = {b.jami}      ← hali sinfdan")
print(f"      Hisoblagich.jami  = {Hisoblagich.jami}      ← o'zgarmadi")
print(f"      a.__dict__        = {a.__dict__}")

del a.jami
print(f"\n    del a.jami dan keyin: a.jami = {a.jami}  ← yana sinfdan")

print(f"""
  ⭐ QOIDA:
     O'qish  → nusxa, keyin sinf
     Yozish  → HAR DOIM nusxaga

     Sinf atributini o'zgartirish uchun sinf orqali yozing:
       Hisoblagich.jami += 1     ✅
       self.jami += 1            ⚠️ nusxa atributi yaratadi
""")

Natijaning muhim qismi:

text
=== 1. Sinf tanasi — oddiy kod ===

  class A: e'lon qilinmoqda...
    ← sinf tanasi ISHLADI

  A.x = 1, A.y = 2
  A.i = 2   ⚠️ tsikl hisoblagichi ham atribut bo'ldi!

=== 2. class ≡ type(...) ===

  Nuqta1     olcham=2  masofa=5.0  type=type
  Nuqta2     olcham=2  masofa=5.0  type=type

=== 5. Sinf atributini o'zgartirish ===

  Hisoblagich.jami = 3

  ⚠️ TUZOQ — nusxa orqali yozish:
    a.jami = 100 dan keyin:
      a.jami            = 100    ← nusxadan
      b.jami            = 3      ← hali sinfdan
      Hisoblagich.jami  = 3      ← o'zgarmadi

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

Misol 2 — __new__ va __init__

python
"""Nusxa yaratishning ikki bosqichi."""

print("=== 1. Chaqiruv tartibi ===\n")

class Kuzatuv:
    def __new__(cls, *args, **kwargs):
        print(f"    1. __new__(cls={cls.__name__}, args={args})")
        obj = super().__new__(cls)
        print(f"       → obyekt yaratildi, id={id(obj) % 100000}")
        return obj

    def __init__(self, x, y=0):
        print(f"    2. __init__(self id={id(self) % 100000}, x={x}, y={y})")
        self.x, self.y = x, y

    def __repr__(self):
        return f"Kuzatuv({self.x}, {self.y})"


print("  k = Kuzatuv(5, 10)")
k = Kuzatuv(5, 10)
print(f"  natija: {k}\n")

print(f"  ⭐ Ikkalasi ham BIR XIL argumentlarni oladi")


print("\n=== 2. ⚠️ __new__ boshqa narsa qaytarsa ===\n")

class Gaalati:
    def __new__(cls, qiymat):
        print(f"    __new__ chaqirildi")
        if qiymat < 0:
            return "manfiy"          # ⚠️ Gaalati nusxasi EMAS
        return super().__new__(cls)

    def __init__(self, qiymat):
        print(f"    __init__ chaqirildi")
        self.qiymat = qiymat


print("  Gaalati(5):")
a = Gaalati(5)
print(f"    natija: {type(a).__name__}\n")

print("  Gaalati(-5):")
b = Gaalati(-5)
print(f"    natija: {b!r} ({type(b).__name__})")

print(f"""
  ⭐ QOIDA: __init__ FAQAT __new__ cls nusxasini
     qaytarganda chaqiriladi.
""")


print("=== 3. Qachon __new__ kerak ===\n")

print("  A) O'zgarmas turdan meros:\n")


class MusbatInt(int):
    """int o'zgarmas — __init__ da kech."""

    def __new__(cls, qiymat):
        if qiymat < 0:
            raise ValueError(f"Musbat bo'lsin: {qiymat}")
        return super().__new__(cls, qiymat)


class NotogriUrinish(int):
    """⚠️ __init__ ishlamaydi — int allaqachon yaratilgan."""

    def __init__(self, qiymat):
        if qiymat < 0:
            raise ValueError("Musbat bo'lsin")
        # self allaqachon int — o'zgartirib bo'lmaydi


for Sinf in (MusbatInt, NotogriUrinish):
    for q in (5, -5):
        try:
            n = Sinf(q)
            natija = f"✅ {n} (tur: {type(n).__name__})"
        except ValueError as e:
            natija = f"❌ {e}"
        print(f"    {Sinf.__name__}({q:>3}) → {natija}")
    print()

print(f"""  ⚠️ NotogriUrinish(-5) o'tib ketdi, lekin qiymati -5.
     __init__ chaqirilganda obyekt ALLAQACHON yaratilgan.


  B) Nusxalarni keshlash (flyweight):
""")


class Rang:
    _kesh: dict[str, "Rang"] = {}

    def __new__(cls, nom: str):
        nom = nom.lower()
        if nom not in cls._kesh:
            print(f"      YANGI Rang('{nom}') yaratildi")
            obj = super().__new__(cls)
            obj.nom = nom
            cls._kesh[nom] = obj
        else:
            print(f"      KESHDAN Rang('{nom}')")
        return cls._kesh[nom]

    def __repr__(self):
        return f"Rang({self.nom!r})"


print(f"    r1 = Rang('qizil')")
r1 = Rang("qizil")
print(f"    r2 = Rang('QIZIL')")
r2 = Rang("QIZIL")
print(f"    r3 = Rang('kok')")
r3 = Rang("kok")

print(f"\n    r1 is r2 = {r1 is r2}   ← bir xil obyekt")
print(f"    r1 is r3 = {r3 is r1}")
print(f"    kesh: {Rang._kesh}")

print(f"""
  C) Singleton (⚠️ ehtiyot bo'ling — global holat):

     class Yagona:
         _nusxa = None
         def __new__(cls):
             if cls._nusxa is None:
                 cls._nusxa = super().__new__(cls)
             return cls._nusxa
""")


print("=== 4. __init_subclass__ — merosni kuzatish ===\n")

class Plagin:
    _royxat: list[type] = []

    def __init_subclass__(cls, /, nom: str = "", **kwargs):
        """⭐ Har avlod sinf yaratilganda chaqiriladi."""
        super().__init_subclass__(**kwargs)
        cls.nom = nom or cls.__name__.lower()
        Plagin._royxat.append(cls)
        print(f"    Ro'yxatga olindi: {cls.__name__} (nom={cls.nom!r})")

    def ishla(self):
        raise NotImplementedError


print("  Sinflar e'lon qilinmoqda:")


class JsonPlagin(Plagin, nom="json"):
    def ishla(self): return "JSON"


class XmlPlagin(Plagin, nom="xml"):
    def ishla(self): return "XML"


class CsvPlagin(Plagin):
    def ishla(self): return "CSV"


print(f"\n  Avtomatik ro'yxat:")
for p in Plagin._royxat:
    print(f"    {p.nom:<8} → {p().ishla()}")

print(f"""
  ⭐ __init_subclass__ metaklasssiz plagin tizimi yaratadi.
     Har avlod sinf AVTOMATIK ro'yxatga tushadi.
""")


print("=== 5. To'liq hayot tsikli ===\n")

import sys


class Hayot:
    def __new__(cls, nom):
        print(f"    __new__     {nom}")
        return super().__new__(cls)

    def __init__(self, nom):
        print(f"    __init__    {nom}")
        self.nom = nom

    def __del__(self):
        print(f"    __del__     {self.nom}")


print("  h = Hayot('A')")
h = Hayot("A")

print(f"\n  Havolalar soni: {sys.getrefcount(h) - 1}")
h2 = h
print(f"  h2 = h dan keyin: {sys.getrefcount(h) - 1}")
del h2
print(f"  del h2 dan keyin: {sys.getrefcount(h) - 1}")

print(f"\n  del h:")
del h

print(f"""
  ⚠️ __del__ ga TAYANMANG:
     • Dastur to'satdan tugasa chaqirilmaydi
     • Aylanma havolalarda kechikadi (gc kutadi)
     • Ichidagi istisno YUTILADI
     • Chaqirilish vaqti aniq emas

  ✅ Resurs uchun kontekst menejeri:

     class Fayl:
         def __enter__(self): ...
         def __exit__(self, *_): self.yop()

     with Fayl("a.txt") as f:
         ...                    # chiqishda ANIQ yopiladi
""")

Natijaning muhim qismi:

text
=== 1. Chaqiruv tartibi ===

  k = Kuzatuv(5, 10)
    1. __new__(cls=Kuzatuv, args=(5, 10))
       → obyekt yaratildi, id=6048
    2. __init__(self id=6048, x=5, y=10)
  natija: Kuzatuv(5, 10)

=== 3. Qachon __new__ kerak ===

    MusbatInt(  5) → ✅ 5 (tur: MusbatInt)
    MusbatInt( -5) → ❌ Musbat bo'lsin: -5
    NotogriUrinish(  5) → ✅ 5 (tur: NotogriUrinish)
    NotogriUrinish( -5) → ❌ Musbat bo'lsin

=== 4. __init_subclass__ — merosni kuzatish ===

    Ro'yxatga olindi: JsonPlagin (nom='json')
    Ro'yxatga olindi: XmlPlagin (nom='xml')
    Ro'yxatga olindi: CsvPlagin (nom='csvplagin')

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

Misol 3 — Atribut qidiruvi va __dict__

python
"""Atribut qayerdan keladi — bosqichma-bosqich."""

print("=== 1. Ikki alohida lug'at ===\n")

class Nuqta:
    """Nuqta sinfi."""
    olcham = 2                      # sinf atributi
    birlik = "px"

    def __init__(self, x, y):
        self.x = x                  # nusxa atributi
        self.y = y

    def masofa(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5


p1 = Nuqta(3, 4)
p2 = Nuqta(6, 8)

print(f"  Nuqta.__dict__ (o'z atributlari):")
for nom, q in Nuqta.__dict__.items():
    if not nom.startswith("__"):
        print(f"    {nom:<10} {q!r}")

print(f"\n  p1.__dict__ = {p1.__dict__}")
print(f"  p2.__dict__ = {p2.__dict__}")

print(f"""
  ⭐ Sinf lug'ati BITTA, nusxa lug'ati HAR NUSXAGA ALOHIDA.
     Metodlar sinf lug'atida — har nusxada takrorlanmaydi.
     Shuning uchun 1000 nusxa yaratsak ham metod bitta.
""")

print(f"  p1.masofa is p2.masofa           = {p1.masofa is p2.masofa}")
print(f"  Nuqta.masofa is Nuqta.masofa     = {Nuqta.masofa is Nuqta.masofa}")
print(f"  p1.masofa.__func__ is Nuqta.masofa = "
      f"{p1.masofa.__func__ is Nuqta.masofa}")
print(f"\n  ⭐ p1.masofa — har safar YANGI bog'langan metod obyekti,")
print(f"     lekin ichidagi funksiya BIR XIL.")


print("\n=== 2. ⭐ Qidiruv zanjiri ===\n")

class Bobo:
    a = "bobo-a"
    b = "bobo-b"
    c = "bobo-c"


class Ota(Bobo):
    b = "ota-b"
    c = "ota-c"


class Bola(Ota):
    c = "bola-c"


x = Bola()
x.d = "nusxa-d"
x.c = "nusxa-c"

print(f"  MRO: {' → '.join(k.__name__ for k in Bola.__mro__)}\n")

print(f"  {'Atribut':<10} {'Qiymat':<12} {'Qayerdan'}")
print("  " + "─" * 40)

for atr in "abcd":
    qiymat = getattr(x, atr, None)
    if atr in x.__dict__:
        manba = "nusxa"
    else:
        manba = next((k.__name__ for k in type(x).__mro__
                      if atr in k.__dict__), "?")
    print(f"  x.{atr:<8} {qiymat!r:<12} {manba}")

try:
    x.e
except AttributeError as e:
    print(f"  x.e       AttributeError: {e}")

print(f"""
  Qidiruv tartibi:
    1. data deskriptor (property) — sinf zanjirida
    2. x.__dict__                 — nusxa
    3. type(x).__mro__            — Bola → Ota → Bobo → object
    4. __getattr__                — agar bo'lsa
    5. AttributeError
""")


print("=== 3. ⚠️ Yozish har doim nusxaga ===\n")

print(f"  Boshlang'ich: Bobo.a = {Bobo.a!r}, x.a = {x.a!r}")

x.a = "YANGI"
print(f"\n  x.a = 'YANGI' dan keyin:")
print(f"    x.a         = {x.a!r}       ← nusxadan")
print(f"    Bola.a      = {Bola.a!r}    ← o'zgarmadi")
print(f"    Bobo.a      = {Bobo.a!r}    ← o'zgarmadi")
print(f"    x.__dict__  = {x.__dict__}")

del x.a
print(f"\n  del x.a dan keyin: x.a = {x.a!r}  ← yana Bobo dan")

print(f"""
  ⚠️ ENG KO'P UCHRAYDIGAN XATO:

     class A:
         royxat = []            # ⚠️ BARCHA nusxalar uchun UMUMIY!

         def qosh(self, x):
             self.royxat.append(x)      # ⚠️ sinf ro'yxatini o'zgartiradi
""")


class YomonSinf:
    royxat = []                     # ⚠️ umumiy


class YaxshiSinf:
    def __init__(self):
        self.royxat = []            # ✅ har nusxaga alohida


for Sinf in (YomonSinf, YaxshiSinf):
    a, b = Sinf(), Sinf()
    a.royxat.append("a dan")
    b.royxat.append("b dan")
    belgi = "⚠️" if a.royxat == b.royxat else "✅"
    print(f"  {belgi} {Sinf.__name__:<12} a.royxat={a.royxat}  "
          f"b.royxat={b.royxat}")

print(f"""
  ⭐ QOIDA:
     O'zgaruvchan (list, dict, set) → __init__ ichida
     O'zgarmas (int, str, tuple)    → sinf atributi mumkin
""")


print("=== 4. vars(), getattr(), setattr() ===\n")

class Sozlama:
    def __init__(self, **kwargs):
        for nom, q in kwargs.items():
            setattr(self, nom, q)   # dinamik atribut


s = Sozlama(host="localhost", port=8080, debug=True)

print(f"  vars(s)  = {vars(s)}")
print(f"  s.__dict__ is vars(s) = {s.__dict__ is vars(s)}")

print(f"\n  Dinamik kirish:")
for nom in ["host", "port", "yoq"]:
    q = getattr(s, nom, "<yo'q>")
    bor = hasattr(s, nom)
    print(f"    getattr(s, {nom!r:<8}) = {q!r:<14} hasattr={bor}")

setattr(s, "yangi", 42)
print(f"\n  setattr(s, 'yangi', 42) → vars(s) = {vars(s)}")

delattr(s, "debug")
print(f"  delattr(s, 'debug')     → vars(s) = {vars(s)}")

print(f"""
  ⭐ Qachon getattr/setattr:
     • Nom ish vaqtida aniqlanadi
     • Konfiguratsiya, serializatsiya
     • Plagin tizimlari

  ⚠️ Nom oldindan ma'lum bo'lsa — oddiy nuqta:
     s.host           ✅
     getattr(s, "host")  ⚠️ ortiqcha
""")


print("=== 5. __getattr__ va __getattribute__ ===\n")

class Ehtiyotkor:
    """Topilmagan atribut uchun sukut qiymat."""

    def __init__(self):
        self.bor = "bor qiymat"

    def __getattr__(self, nom):
        """⭐ FAQAT oddiy qidiruv muvaffaqiyatsiz bo'lganda."""
        print(f"      __getattr__({nom!r}) chaqirildi")
        return f"<{nom} yo'q>"


e = Ehtiyotkor()
print(f"  e.bor      →")
print(f"    natija: {e.bor!r}   (__getattr__ chaqirilmadi)")
print(f"  e.yoq      →")
print(f"    natija: {e.yoq!r}")


class Kuzatuvchi:
    """HAR atribut kirishini kuzatadi."""

    def __init__(self):
        self.x = 1

    def __getattribute__(self, nom):
        """⚠️ HAR kirishda chaqiriladi — ehtiyot bo'ling."""
        if not nom.startswith("_"):
            print(f"      kirish: {nom}")
        return super().__getattribute__(nom)   # ⚠️ super() SHART


k = Kuzatuvchi()
print(f"\n  k.x →")
_ = k.x

print(f"""
  ┌──────────────────┬────────────────────────────────────┐
  │ __getattribute__ │ HAR atribut kirishida              │
  │ __getattr__      │ FAQAT topilmaganda                 │
  └──────────────────┴────────────────────────────────────┘

  ⚠️ __getattribute__ ichida self.x yozsangiz — CHEKSIZ REKURSIYA.
     Doim super().__getattribute__(nom) ishlating.

  ⭐ __getattr__ ishlatilishi:
     • ORM: user.filter_by_email()
     • Mock obyektlar
     • Lazy yuklash
     • Proxy / adapter
""")

Natijaning muhim qismi:

text
=== 1. Ikki alohida lug'at ===

  p1.__dict__ = {'x': 3, 'y': 4}
  p2.__dict__ = {'x': 6, 'y': 8}

  p1.masofa is p2.masofa           = False
  p1.masofa.__func__ is Nuqta.masofa = True

=== 2. ⭐ Qidiruv zanjiri ===

  MRO: Bola → Ota → Bobo → object

  Atribut    Qiymat       Qayerdan
  ────────────────────────────────────────
  x.a        'bobo-a'     Bobo
  x.b        'ota-b'      Ota
  x.c        'nusxa-c'    nusxa
  x.d        'nusxa-d'    nusxa

=== 3. ⚠️ Yozish har doim nusxaga ===

  ⚠️ YomonSinf    a.royxat=['a dan', 'b dan']  b.royxat=['a dan', 'b dan']
  ✅ YaxshiSinf   a.royxat=['a dan']  b.royxat=['b dan']

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

Misol 4 — Amaliy: kitob katalogi

python
"""To'liq sinf — barcha tushunchalar birga."""

from datetime import date

print("=== KITOB KATALOGI ===\n")


class Kitob:
    """Katalogdagi bitta kitob.

    Nusxa yaratilganda ISBN tekshiriladi va katalogga
    avtomatik ro'yxatga olinadi.
    """

    # ── Sinf atributlari (barcha nusxalar uchun umumiy) ──
    JAMI = 0                                    # nechta yaratildi
    KATALOG: dict[str, "Kitob"] = {}            # ISBN → Kitob
    JANRLAR = frozenset({"badiiy", "ilmiy", "darslik", "bolalar"})

    def __new__(cls, nom, muallif, isbn, *args, **kwargs):
        """⭐ Bir xil ISBN — bir xil obyekt (keshlash)."""
        isbn = cls._isbn_tozala(isbn)
        if isbn in cls.KATALOG:
            print(f"    [kesh] {isbn} allaqachon bor")
            return cls.KATALOG[isbn]
        obj = super().__new__(cls)
        obj._yangi = True
        return obj

    def __init__(self, nom: str, muallif: str, isbn: str,
                 yil: int = 2026, janr: str = "badiiy"):
        # ⚠️ Keshdan kelgan obyektni qayta sozlamaymiz
        if not getattr(self, "_yangi", False):
            return
        del self._yangi

        isbn = self._isbn_tozala(isbn)
        if len(isbn) != 13 or not isbn.isdigit():
            raise ValueError(f"ISBN 13 raqamdan iborat bo'lsin: {isbn!r}")
        if janr not in self.JANRLAR:
            raise ValueError(
                f"Janr {sorted(self.JANRLAR)} dan biri bo'lsin: {janr!r}"
            )
        if not 1450 <= yil <= date.today().year + 1:
            raise ValueError(f"Yil noto'g'ri: {yil}")
        if not nom.strip():
            raise ValueError("Nom bo'sh bo'lmasin")

        self.nom = nom.strip()
        self.muallif = muallif.strip()
        self.isbn = isbn
        self.yil = yil
        self.janr = janr
        self._olingan = False

        # Sinf holatini yangilash — SINF orqali
        Kitob.JAMI += 1
        Kitob.KATALOG[isbn] = self

    @staticmethod
    def _isbn_tozala(isbn: str) -> str:
        return isbn.replace("-", "").replace(" ", "")

    @property
    def olingan(self) -> bool:
        return self._olingan

    def ol(self) -> None:
        if self._olingan:
            raise RuntimeError(f"{self.nom!r} allaqachon olingan")
        self._olingan = True

    def qaytar(self) -> None:
        self._olingan = False

    def __repr__(self) -> str:
        return (f"Kitob({self.nom!r}, {self.muallif!r}, "
                f"{self.isbn!r}, yil={self.yil})")

    def __str__(self) -> str:
        holat = "olingan" if self._olingan else "javonda"
        return f"«{self.nom}» — {self.muallif} ({self.yil}) [{holat}]"


print("1. Kitoblar yaratish:\n")

MALUMOT = [
    ("O'tkan kunlar", "Abdulla Qodiriy", "978-9943-01-001-1", 1926, "badiiy"),
    ("Mehrobdan chayon", "Abdulla Qodiriy", "9789943010028", 1929, "badiiy"),
    ("Python asoslari", "Guido van Rossum", "978-9943-01-003-5", 2024, "darslik"),
    ("Kichkina shahzoda", "A. de Saint-Exupery", "9789943010042", 1943, "bolalar"),
]

kitoblar = []
for m in MALUMOT:
    k = Kitob(*m)
    kitoblar.append(k)
    print(f"  ✅ {k}")

print(f"\n  Kitob.JAMI = {Kitob.JAMI}")
print(f"  Katalogda: {len(Kitob.KATALOG)} ta")


print("\n\n2. ⭐ Keshlash (__new__):\n")

takror = Kitob("O'tkan kunlar (2-nashr)", "A. Qodiriy",
               "978-9943-01-001-1", 2020, "badiiy")

print(f"  takror is kitoblar[0]  = {takror is kitoblar[0]}")
print(f"  takror.nom             = {takror.nom!r}   ← eski nom saqlandi")
print(f"  Kitob.JAMI             = {Kitob.JAMI}   ← oshmadi")


print("\n\n3. Invariant himoyasi:\n")

XATO_SINOVLAR = [
    ("ISBN qisqa",  ("Nom", "Muallif", "12345", 2026, "badiiy")),
    ("ISBN harfli", ("Nom", "Muallif", "978994301abcd", 2026, "badiiy")),
    ("Janr noto'g'ri", ("Nom", "Muallif", "9789943019991", 2026, "fantastika")),
    ("Yil kelajakda", ("Nom", "Muallif", "9789943019992", 2099, "badiiy")),
    ("Nom bo'sh",   ("   ", "Muallif", "9789943019993", 2026, "badiiy")),
]

for tavsif, args in XATO_SINOVLAR:
    try:
        Kitob(*args)
        natija = "⚠️ o'tdi"
    except ValueError as e:
        natija = f"✅ ValueError: {e}"
    print(f"  {tavsif:<16} {natija}")


print("\n\n4. Nusxa va sinf atributlari:\n")

k = kitoblar[0]

print(f"  k.__dict__:")
for nom, q in k.__dict__.items():
    print(f"    {nom:<12} {q!r}")

print(f"\n  Sinf atributlari (nusxada YO'Q):")
for nom in ["JAMI", "JANRLAR"]:
    print(f"    k.{nom:<10} = {getattr(k, nom)!r}")
    print(f"      nusxada bormi: {nom in k.__dict__}")

print(f"\n  Qidiruv manbai:")
for atr in ["nom", "JAMI", "ol", "_isbn_tozala", "yoq"]:
    if atr in k.__dict__:
        manba = "nusxa"
    else:
        manba = next((c.__name__ for c in type(k).__mro__
                      if atr in c.__dict__), "❌ topilmadi")
    print(f"    k.{atr:<14} → {manba}")


print("\n\n5. Holat o'zgarishi:\n")

k = kitoblar[2]
print(f"  Boshida:  {k}")
k.ol()
print(f"  ol():     {k}")

try:
    k.ol()
except RuntimeError as e:
    print(f"  ol() yana: ✅ RuntimeError: {e}")

k.qaytar()
print(f"  qaytar(): {k}")

try:
    k.olingan = True
except AttributeError as e:
    print(f"  k.olingan = True: ✅ AttributeError (property setter yo'q)")


print("\n\n6. Katalog bo'yicha ish:\n")

print(f"  Janrlar bo'yicha:")
janrlar: dict[str, list[Kitob]] = {}
for kt in Kitob.KATALOG.values():
    janrlar.setdefault(kt.janr, []).append(kt)

for janr, ro in sorted(janrlar.items()):
    print(f"    {janr:<10} {len(ro)} ta")
    for kt in ro:
        print(f"      • {kt.nom} ({kt.yil})")

eng_eski = min(Kitob.KATALOG.values(), key=lambda k: k.yil)
print(f"\n  Eng eski: {eng_eski}")

mualliflar = {}
for kt in Kitob.KATALOG.values():
    mualliflar[kt.muallif] = mualliflar.get(kt.muallif, 0) + 1
print(f"\n  Mualliflar:")
for m, n in sorted(mualliflar.items(), key=lambda x: -x[1]):
    print(f"    {m:<24} {'█' * n} {n}")


print("\n\n7. Sinf haqida ma'lumot:\n")

import inspect

print(f"  Nomi:      {Kitob.__name__}")
print(f"  Modul:     {Kitob.__module__}")
print(f"  MRO:       {' → '.join(c.__name__ for c in Kitob.__mro__)}")
print(f"  Docstring: {(Kitob.__doc__ or '').splitlines()[0]}")

metodlar = [n for n, v in Kitob.__dict__.items()
            if callable(v) and not n.startswith("__")]
xususiyatlar = [n for n, v in Kitob.__dict__.items()
                if isinstance(v, property)]
sinf_atr = [n for n, v in Kitob.__dict__.items()
            if not callable(v) and not isinstance(v, property)
            and not n.startswith("__")]

print(f"\n  Metodlar:        {metodlar}")
print(f"  Xususiyatlar:    {xususiyatlar}")
print(f"  Sinf atributlari: {sinf_atr}")

print(f"\n  Nusxa atributlari (k.__dict__): {list(kitoblar[0].__dict__)}")

print(f"""

  ⭐ Bu sinfda ishlatilgan:
     • __new__      keshlash uchun
     • __init__     tekshiruv va sozlash
     • __repr__     dasturchi uchun
     • __str__      foydalanuvchi uchun
     • @property    faqat o'qish uchun
     • @staticmethod yordamchi funksiya
     • Sinf atributlari: JAMI, KATALOG, JANRLAR
     • Invariant: ISBN, janr, yil, nom
""")

Natijaning muhim qismi:

text
1. Kitoblar yaratish:

  ✅ «O'tkan kunlar» — Abdulla Qodiriy (1926) [javonda]
  ✅ «Python asoslari» — Guido van Rossum (2024) [javonda]

  Kitob.JAMI = 4

2. ⭐ Keshlash (__new__):

    [kesh] 9789943010011 allaqachon bor
  takror is kitoblar[0]  = True
  takror.nom             = "O'tkan kunlar"   ← eski nom saqlandi
  Kitob.JAMI             = 4   ← oshmadi

3. Invariant himoyasi:

  ISBN qisqa       ✅ ValueError: ISBN 13 raqamdan iborat bo'lsin: '12345'
  Janr noto'g'ri   ✅ ValueError: Janr ['badiiy', 'bolalar', ...] dan biri
  Yil kelajakda    ✅ ValueError: Yil noto'g'ri: 2099

4. Nusxa va sinf atributlari:

  Qidiruv manbai:
    k.nom            → nusxa
    k.JAMI           → Kitob
    k.ol             → Kitob
    k.yoq            → ❌ topilmadi

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


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

Noto'g'ri fikr To'g'risi
"__init__ — konstruktor" Initsializator. Obyektni __new__ yaratadi
"Sinf tanasi faqat e'lon" Oddiy kod — bajariladi, tsikl ham mumkin
"self — kalit so'z" Oddiy parametr nomi (kelishuv)
"Sinf atributi har nusxada nusxalanadi" Bitta nusxa, hammasi bir joyga qaraydi
"obj.x = 1 sinfni o'zgartiradi" Faqat obj.__dict__ ga yozadi
"Metod har nusxada saqlanadi" Sinf lug'atida bitta
"__del__ — destruktor, doim ishlaydi" Kafolat yo'q. with ishlating
"type(x) == A va isinstance bir xil" isinstance merosni hisobga oladi

6. Keng tarqalgan xatolar va yechimlari

1. O'zgaruvchan sinf atributi

python
class A:
    royxat = []                 # ⚠️ hamma nusxaga umumiy

class A:
    def __init__(self):
        self.royxat = []        # ✅

2. self unutish

python
class A:
    def metod():                # ❌ TypeError chaqirilganda
        ...
    def metod(self):            # ✅

3. Sinf hisoblagichini self orqali oshirish

python
self.JAMI += 1                  # ⚠️ nusxa atributi yaratadi
Sinf.JAMI += 1                  # ✅
type(self).JAMI += 1            # ✅ meros bilan ehtiyot

4. __new__ da qaytarishni unutish

python
def __new__(cls):
    super().__new__(cls)        # ❌ None qaytadi → TypeError
    return super().__new__(cls) # ✅

5. Sinf tanasida comprehension

python
class A:
    x = 10
    lst = [x for _ in range(3)] # ❌ NameError
    LST = [x] * 3               # ✅

6. __getattribute__ da rekursiya

python
def __getattribute__(self, n):
    return self.__dict__[n]                 # ❌ cheksiz rekursiya
    return super().__getattribute__(n)      # ✅

7. __init__ da return

python
def __init__(self):
    return self                 # ❌ TypeError: should return None

8. __del__ ga tayanish

python
def __del__(self):
    self.fayl.close()           # ⚠️ chaqirilmasligi mumkin

with ochiq(...) as f: ...       # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 8.3-8.5-darslar: __init__, atributlar, sinf vs nusxa — chuqurroq
  • 8.6-8.8: meros va MRO — qidiruv zanjirining davomi
  • 8.15: @property — data deskriptor, qidiruvda birinchi
  • 8.19: __slots__ — __dict__ siz obyektlar
  • 7.8-dars (o'tilgan): LEGB va sinf qamrovining ajralishi
  • 10-qism: dekoratorlar sinflarni o'zgartirishi
  • CPython: Objects/typeobject.c, Objects/object.c

8. Eng yaxshi amaliyotlar

  1. O'zgaruvchan sukut — __init__ ichida. list, dict, set hech qachon sinf atributi bo'lmasin.

  2. __init__ da invariantni tekshiring. Noto'g'ri obyekt umuman yaratilmasin.

  3. Faqat kerak bo'lsa __new__. O'zgarmas turdan meros, keshlash — boshqa holatda __init__ yetadi.

  4. Sinf holatini sinf orqali o'zgartiring. Sinf.JAMI += 1, self.JAMI += 1 emas.

  5. isinstance, type() is emas. Meros hisobga olinadi.

  6. __repr__ yozing. Nosozlikni tuzatishda katta yordam (8.11-dars).

  7. __del__ o'rniga kontekst menejeri. Resurs aniq vaqtda bo'shatilsin.

  8. Nusxa atributlarini __init__ da e'lon qiling. Boshqa metodda paydo bo'lgan atribut — o'qishni qiyinlashtiradi.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
1.  class A:
        x = 1
    a = A()
    a.x = 2
    print(A.x, a.x)
2.  class A:
        lst = []
    a, b = A(), A()
    a.lst.append(1)
    print(b.lst)
3.  class A:
        def __init__(self):
            self.lst = []
    a, b = A(), A()
    a.lst.append(1)
    print(b.lst)
4.  class A:
        print("tana")
    print("keyin")
5.  class A:
        for i in range(3): pass
    print(A.i)
6.  class A:
        def __new__(cls): return 42
        def __init__(self): print("init")
    print(A())
7.  class A: pass
    a = A()
    print(a.__dict__)
8.  class A:
        x = 1
        def f(self): return self.x
    a = A()
    a.x = 2
    print(a.f())
9.  class A: pass
    print(A.__bases__, len(A.__mro__))
10. class A:
        def __init__(self): return None
    print(type(A()))
11. class A: x = [1]
    a = A()
    a.x += [2]
    print(A.x, a.x)
12. class A:
        def f(self): pass
    a = A()
    print(a.f is a.f, A.f is A.f)
Javoblar
  1. 1 2 — nusxa sinfni to'sadi
  2. [1] — umumiy sinf atributi
  3. [] — har nusxaga alohida
  4. tana keyin keyin — tana darhol bajariladi
  5. 2 — tsikl hisoblagichi sinf atributi bo'ldi
  6. 42 — __init__ chaqirilmaydi, "init" chiqmaydi
  7. {} — bo'sh lug'at
  8. 2 — self.x nusxadan
  9. (<class 'object'>,) 2
  10. <class '__main__.A'> — return None ruxsat
  11. [1, 2] [1, 2] — += ro'yxatda __iadd__ ni chaqiradi va sinf ro'yxatini joyida o'zgartiradi, keyin natijani nusxaga yozadi
  12. False True — bog'langan metod har safar yangi

Vazifa 2: Xatolarni tuzating

python
1.  class A:
        elementlar = []
        def qosh(self, x): self.elementlar.append(x)
2.  class A:
        def metod(): return 1
3.  class A:
        JAMI = 0
        def __init__(self): self.JAMI += 1
4.  class A:
        def __new__(cls): super().__new__(cls)
5.  class A:
        x = 5
        y = [x for _ in range(3)]
6.  class A:
        def __init__(self): return self
7.  class A:
        def __getattribute__(self, n): return self.__dict__[n]
8.  class Fayl:
        def __del__(self): self.f.close()
Javoblar
python
1.  def __init__(self): self.elementlar = []
2.  def metod(self): return 1
3.  A.JAMI += 1        (yoki type(self).JAMI += 1)
4.  return super().__new__(cls)
5.  y = [x] * 3
6.  __init__ hech narsa qaytarmasin (yoki return None)
7.  return super().__getattribute__(n)
8.  __enter__/__exit__ qo'shing, with bilan ishlating

Vazifa 3: Vektor sinfi

Yozing:

  1. __init__(self, x, y) — sonlarni tekshiring
  2. uzunlik() metodi
  3. NORMA_ANIQLIGI sinf konstantasi
  4. YARATILGAN hisoblagich (sinf atributi)
  5. __repr__ va __str__
  6. normalla() — birlik vektor qaytarsin (yangi obyekt)
  7. Nol vektorni normallashtirish ValueError bersin

Vazifa 4: Keshlovchi sinf

__new__ bilan Foydalanuvchi sinfi yozing:

  1. Bir xil email — bir xil obyekt
  2. Email formatini tekshiring
  3. Keshdan kelganda __init__ qayta ishlamasin
  4. Foydalanuvchi.kesh_tozala() sinf metodi
  5. Kesh hajmini cheklang (LRU)

Vazifa 5: Atribut kuzatuvchisi

__getattr__, __setattr__, __getattribute__ bilan sinf yozing:

  1. Har o'qish va yozishni jurnalga qo'shsin
  2. Yozilgan atributni __setattr__ da tekshirsin
  3. Topilmagan atribut uchun taklif bersin (difflib)
  4. jurnal xususiyati statistikani qaytarsin
  5. Rekursiyaga tushmasin

Vazifa 6: __dict__ tekshiruvchisi

Vosita yozing:

  1. Obyekt va sinf lug'atlarini solishtirsin
  2. Sinf atributini to'sayotgan nusxa atributlarini topsin
  3. O'zgaruvchan sinf atributlarini ogohlantirsin
  4. Har atribut qayerdan kelayotganini ko'rsatsin
  5. Xotira hajmini hisoblasin

Vazifa 7: O'ylash

Nega Pythonda self yashirin emas — nega har metodda uni yozish kerak, C++/Java dagi this kabi avtomatik emas?

Javob

Chunki self — oddiy parametr, va Python "Explicit is better than implicit" tamoyiliga amal qiladi.

1. Metod — bu shunchaki funksiya

python
class A:
    def metod(self, x):
        return self.q + x


# metod — oddiy funksiya
type(A.metod)                   # <class 'function'>
A.metod                         # <function A.metod at 0x...>

# Uni sinfdan tashqarida yozib, keyin qo'shish mumkin
def yangi_metod(self, y):
    return self.q * y

A.yangi_metod = yangi_metod     # ✅ ishlaydi

a = A()
a.q = 10
a.yangi_metod(3)                # 30

Agar self yashirin bo'lsa, funksiya va metod turli narsa bo'lardi — bu qo'shimcha murakkablik.

2. Bog'langan metod (bound method)

a.metod yozilganda Python yangi obyekt yaratadi:

python
a.metod                         # <bound method A.metod of <A object>>
a.metod.__self__                # a
a.metod.__func__                # <function A.metod>

# Bular teng:
a.metod(5)
A.metod(a, 5)                   # ⭐ self aynan shu yerda uzatiladi

Ya'ni self — haqiqiy argument. Uni yashirish faqat sintaktik yolg'on bo'lardi.

3. Ravshanlik — qamrov muammosi yo'q

C++ da:

cpp
class A {
    int x;
    void f(int x) {
        x = x;              // ⚠️ qaysi x? Parametr!
        this->x = x;        // ✅ aniqlash uchun this kerak
    }
};

Java da:

java
class A {
    int x;
    void f(int x) {
        this.x = x;         // this majburiy
    }
    void g() {
        x = 5;              // ⚠️ this.x — lekin ko'rinmaydi
    }
}

Pythonda ikkilanish yo'q:

python
class A:
    def f(self, x):
        x = x               # ikkalasi ham lokal
        self.x = x          # ✅ har doim aniq

Kod o'qiyotganda self. prefiksi — darhol ayta oladi: bu atribut, bu lokal.

4. Dekoratorlar tabiiy ishlaydi

python
def jurnal(f):
    def ichki(*args, **kwargs):
        print(f"chaqirildi: {f.__name__}, self={args[0]}")
        return f(*args, **kwargs)
    return ichki


class A:
    @jurnal
    def metod(self, x):
        return x * 2

self — oddiy argument bo'lgani uchun dekorator uni hech qanday maxsus qoidasiz oladi. Yashirin this bo'lsa, har dekorator uni alohida boshqarishi kerak bo'lardi.

5. staticmethod va classmethod mumkin bo'ladi

python
class A:
    def nusxa_metod(self): ...          # self oladi
    @classmethod
    def sinf_metod(cls): ...            # cls oladi
    @staticmethod
    def statik(): ...                   # hech narsa olmaydi

Uch xil metod — birinchi parametrdagi farq orqali ifodalanadi. Yashirin this bo'lsa, bu uchun alohida kalit so'zlar kerak bo'lardi (Java da aynan shunday: static).

6. Guido ning javobi

Guido van Rossum 2008 yilda "Why explicit self has to stay" maqolasida yozdi:

Asosiy dalil — metodni sinfdan tashqarida aniqlash:

python
def f(self, x):
    return self.q + x

class A:
    metod = f                   # ✅ tabiiy ishlaydi

Agar self yashirin bo'lsa, f ni sinf tanasi ichida yozilgan-yozilmaganini bilish kerak bo'lardi.

Ikkinchi dalil — dekoratorlar (yuqorida).

Uchinchisi — sinf atributi va lokal o'zgaruvchi orasidagi farq kod o'qiyotganda ko'rinishi kerak.

7. self — kalit so'z EMAS

python
class A:
    def metod(bu, x):           # ✅ ishlaydi
        return bu.q + x

    def boshqa(ozim, x):        # ✅ ham ishlaydi
        return ozim.q + x

    def xato(o'zim, x):         # ❌ SyntaxError — apostrof satrni ochadi (3.2-dars)
        return o'zim.q + x

Lekin hech qachon shunday yozmang — PEP 8 self ni talab qiladi va butun jamoa shunga o'rgangan.

8. Boshqa tillar bilan solishtirish

Til Uslub Izoh
Python Aniq self Parametr sifatida
Rust Aniq &self Egalik ham ko'rsatiladi
Go Aniq qabul qiluvchi func (r Recv) f()
Lua : bilan yashirin function a:f() → self paydo bo'ladi
Java/C#/C++ Yashirin this Ba'zan majburiy
JavaScript Dinamik this Kontekstga qarab o'zgaradi — mashhur muammo

JavaScript — ogohlantiruvchi misol:

javascript
class A {
    constructor() { this.x = 1; }
    metod() { return this.x; }
}

const a = new A();
const f = a.metod;
f();                            // ⚠️ TypeError — this yo'qoldi!

Pythonda bu mumkin emas:

python
a = A()
f = a.metod                     # bog'langan metod — self ichida
f()                             # ✅ ishlaydi

self aniq bo'lgani uchun bog'lanish ham aniq.

9. Amaliy foyda

python
# Metodni funksiya kabi ishlatish
sonlar = ["3", "1", "2"]
sorted(sonlar, key=int)                     # ✅

# Sinf metodini to'g'ridan-to'g'ri
list(map(str.upper, ["a", "b"]))            # ['A', 'B']
#       ↑ self ni map beradi

# Bog'lanmagan chaqiruv
str.upper("abc")                            # 'ABC'
"abc".upper()                               # aynan shu

str.upper — bu self oladigan oddiy funksiya. Shuning uchun uni map ga uzatish mumkin.

10. Kamchiligi

Rostini aytganda, kamchilik ham bor:

  • Har metodda 6 ta ortiqcha belgi (self, )
  • Yangi boshlovchilar unutadi (TypeError: metod() takes 0 positional arguments)
  • Ba'zan shovqinli ko'rinadi

Lekin Python jamoasi bu narxni ravshanlik uchun to'lashga rozi. PEP 20:

Explicit is better than implicit. (Aniq — yashirindan yaxshi.)

Xulosa: self yashirin emas, chunki u haqiqiy argument. Bu:

  1. Metod va funksiyani bir xil qiladi
  2. Dekoratorlarni tabiiy qiladi
  3. staticmethod/classmethod ni mumkin qiladi
  4. JavaScript dagi this muammosini yo'q qiladi
  5. Kod o'qiyotganda atribut va lokalni ajratadi

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


Xulosa

Bu darsda sinf va obyektning ichki tuzilishini o'rgandik.

Eng muhim uch fikr:

  1. class — bajariladigan kod, e'lon emas. Python yangi nom fazosi yaratadi, tanani unda bajaradi va type(nom, otalar, fazo) chaqiradi. Shuning uchun tsikl hisoblagichi ham sinf atributi bo'ladi va sinfni ish vaqtida yaratish mumkin.

  2. Nusxa yaratish — ikki bosqich. __new__ obyektni yaratadi (cls oladi, obyekt qaytaradi), __init__ uni sozlaydi (self oladi, None qaytaradi). 99% holatda faqat __init__ yoziladi; __new__ o'zgarmas turdan meros va keshlash uchun kerak.

  3. O'qish zanjir bo'ylab, yozish faqat nusxaga. obj.x nusxa lug'atidan boshlab MRO bo'ylab qidiradi; obj.x = 1 esa har doim obj.__dict__ ga yozadi. Shuning uchun o'zgaruvchan sinf atributi (royxat = []) — barcha nusxalar uchun umumiy tuzoq.

Keyingi darsda __init__ va atributlarni chuqurroq ko'ramiz: sukut qiymatlar, tekshiruv, __post_init__ va atributlarni to'g'ri loyihalash.

OOP · 2-dars yakunlandi

8.2-dars: Klass va obyekt

32 daqvaqt
0belgi
Keyingi dars: 8.3-dars: init va atributlar
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0