8.2-dars: Klass va obyekt
8-QISM — OBYEKTGA YO'NALTIRILGAN DASTURLASH · 2-dars
1. Kirish va motivatsiya
Eng oddiy sinf:
class Bosh:
passUch qator emas — ikki qator. Lekin bu ikki qator ortida ancha narsa turadi:
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.nimadirqidiruvi qayerlarga qaraydi?- Nega
Boshham obyekt?
Bu darsda:
classsintaksisi 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
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 * 2Nomlash 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:
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:
- Python
class A:ni ko'radi - Yangi nom fazosi (lug'at) yaratadi
- Tana kodini shu fazoda bajaradi
type("A", bases, nom_fazosi)chaqiradi- Natijani
Anomiga bog'laydi
# 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 qaytaradiclass 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:
class A:
def __new__(cls):
return 42 # A nusxasi emas
def __init__(self):
print("chaqirilmaydi")
A() # 42, "chaqirilmaydi" chiqmaydiQachon __new__ kerak:
# 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:
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":
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 sinfdan2.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. AttributeErrorSodda holat (deskriptorsiz):
obj.__dict__ → sinf → ota-sinflar → __getattr__ → AttributeErrorclass 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 # AttributeErrorYozish har doim nusxaga boradi:
x.a = "yangi" # Ota.a EMAS, x.__dict__ ga
Ota.a # 'ota-a' — o'zgarmadi2.6. Sinf tanasidagi qamrov tuzog'i
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).
class A:
x = 10
lst = [x for _ in range(3)] # ⚠️ Python 3 da NameErrorComprehension o'z qamrovini yaratadi va sinf qamrovini ko'rmaydi.
Yechim:
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
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) # TrueQaysi birini ishlatish:
# ✅ 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 ==:
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 etadi2.8. Obyekt hayoti
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):
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
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.xNusxa yaratish
Nom(args)
↓
__new__(cls, ...) obyektni yaratadi → qaytaradi
↓
__init__(self, ...) sozlaydi → NoneAtribut 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__ gaTekshirish
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__
obj.__dict__ {'x': 3}
Sinf.__dict__ mappingproxy(...) — o'zgarmas ko'rinish
vars(obj) obj.__dict__ bilan bir xil4. Batafsil misollar
Misol 1 — Sinf qanday yaratiladi
"""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:
=== 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'zgarmadiNima ko'rsatdi: 2.1, 2.2, 2.6-bo'limlar.
Misol 2 — __new__ va __init__
"""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:
=== 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__
"""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:
=== 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
"""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:
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 → ❌ topilmadiNima 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
class A:
royxat = [] # ⚠️ hamma nusxaga umumiy
class A:
def __init__(self):
self.royxat = [] # ✅2. self unutish
class A:
def metod(): # ❌ TypeError chaqirilganda
...
def metod(self): # ✅3. Sinf hisoblagichini self orqali oshirish
self.JAMI += 1 # ⚠️ nusxa atributi yaratadi
Sinf.JAMI += 1 # ✅
type(self).JAMI += 1 # ✅ meros bilan ehtiyot4. __new__ da qaytarishni unutish
def __new__(cls):
super().__new__(cls) # ❌ None qaytadi → TypeError
return super().__new__(cls) # ✅5. Sinf tanasida comprehension
class A:
x = 10
lst = [x for _ in range(3)] # ❌ NameError
LST = [x] * 3 # ✅6. __getattribute__ da rekursiya
def __getattribute__(self, n):
return self.__dict__[n] # ❌ cheksiz rekursiya
return super().__getattribute__(n) # ✅7. __init__ da return
def __init__(self):
return self # ❌ TypeError: should return None8. __del__ ga tayanish
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
O'zgaruvchan sukut —
__init__ichida.list,dict,sethech qachon sinf atributi bo'lmasin.__init__da invariantni tekshiring. Noto'g'ri obyekt umuman yaratilmasin.Faqat kerak bo'lsa
__new__. O'zgarmas turdan meros, keshlash — boshqa holatda__init__yetadi.Sinf holatini sinf orqali o'zgartiring.
Sinf.JAMI += 1,self.JAMI += 1emas.isinstance,type() isemas. Meros hisobga olinadi.__repr__yozing. Nosozlikni tuzatishda katta yordam (8.11-dars).__del__o'rniga kontekst menejeri. Resurs aniq vaqtda bo'shatilsin.Nusxa atributlarini
__init__da e'lon qiling. Boshqa metodda paydo bo'lgan atribut — o'qishni qiyinlashtiradi.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
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 2— nusxa sinfni to'sadi[1]— umumiy sinf atributi[]— har nusxaga alohidatanakeyinkeyin— tana darhol bajariladi2— tsikl hisoblagichi sinf atributi bo'ldi42—__init__chaqirilmaydi, "init" chiqmaydi{}— bo'sh lug'at2—self.xnusxadan(<class 'object'>,) 2<class '__main__.A'>—return Noneruxsat[1, 2] [1, 2]—+=ro'yxatda__iadd__ni chaqiradi va sinf ro'yxatini joyida o'zgartiradi, keyin natijani nusxaga yozadiFalse True— bog'langan metod har safar yangi
Vazifa 2: Xatolarni tuzating
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
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 ishlatingVazifa 3: Vektor sinfi
Yozing:
__init__(self, x, y)— sonlarni tekshiringuzunlik()metodiNORMA_ANIQLIGIsinf konstantasiYARATILGANhisoblagich (sinf atributi)__repr__va__str__normalla()— birlik vektor qaytarsin (yangi obyekt)- Nol vektorni normallashtirish
ValueErrorbersin
Vazifa 4: Keshlovchi sinf
__new__ bilan Foydalanuvchi sinfi yozing:
- Bir xil
email— bir xil obyekt - Email formatini tekshiring
- Keshdan kelganda
__init__qayta ishlamasin Foydalanuvchi.kesh_tozala()sinf metodi- Kesh hajmini cheklang (LRU)
Vazifa 5: Atribut kuzatuvchisi
__getattr__, __setattr__, __getattribute__ bilan sinf yozing:
- Har o'qish va yozishni jurnalga qo'shsin
- Yozilgan atributni
__setattr__da tekshirsin - Topilmagan atribut uchun taklif bersin (
difflib) jurnalxususiyati statistikani qaytarsin- Rekursiyaga tushmasin
Vazifa 6: __dict__ tekshiruvchisi
Vosita yozing:
- Obyekt va sinf lug'atlarini solishtirsin
- Sinf atributini to'sayotgan nusxa atributlarini topsin
- O'zgaruvchan sinf atributlarini ogohlantirsin
- Har atribut qayerdan kelayotganini ko'rsatsin
- 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
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:
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 uzatiladiYa'ni self — haqiqiy argument. Uni yashirish faqat sintaktik yolg'on bo'lardi.
3. Ravshanlik — qamrov muammosi yo'q
C++ da:
class A {
int x;
void f(int x) {
x = x; // ⚠️ qaysi x? Parametr!
this->x = x; // ✅ aniqlash uchun this kerak
}
};Java da:
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:
class A:
def f(self, x):
x = x # ikkalasi ham lokal
self.x = x # ✅ har doim aniqKod o'qiyotganda self. prefiksi — darhol ayta oladi: bu atribut, bu lokal.
4. Dekoratorlar tabiiy ishlaydi
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 * 2self — 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
class A:
def nusxa_metod(self): ... # self oladi
@classmethod
def sinf_metod(cls): ... # cls oladi
@staticmethod
def statik(): ... # hech narsa olmaydiUch 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:
def f(self, x):
return self.q + x
class A:
metod = f # ✅ tabiiy ishlaydiAgar 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
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:
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:
a = A()
f = a.metod # bog'langan metod — self ichida
f() # ✅ ishlaydiself aniq bo'lgani uchun bog'lanish ham aniq.
9. Amaliy foyda
# 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:
- Metod va funksiyani bir xil qiladi
- Dekoratorlarni tabiiy qiladi
staticmethod/classmethodni mumkin qiladi- JavaScript dagi
thismuammosini yo'q qiladi - 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:
class— bajariladigan kod, e'lon emas. Python yangi nom fazosi yaratadi, tanani unda bajaradi vatype(nom, otalar, fazo)chaqiradi. Shuning uchun tsikl hisoblagichi ham sinf atributi bo'ladi va sinfni ish vaqtida yaratish mumkin.Nusxa yaratish — ikki bosqich.
__new__obyektni yaratadi (clsoladi, obyekt qaytaradi),__init__uni sozlaydi (selfoladi,Noneqaytaradi). 99% holatda faqat__init__yoziladi;__new__o'zgarmas turdan meros va keshlash uchun kerak.O'qish zanjir bo'ylab, yozish faqat nusxaga.
obj.xnusxa lug'atidan boshlab MRO bo'ylab qidiradi;obj.x = 1esa har doimobj.__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.
Izohlar · 0
Izoh yozish uchun kiring.