11.9-dars: __slots__ xotirani qanday tejaydi
11-QISM — OBYEKT MODELI VA XOTIRA · 9-dars
1. Kirish va motivatsiya
8.19-darsda __slots__ ni amaliy tomondan o'rgandik: sintaksis, beshta cheklov, meros qoidalari, dataclass(slots=True). 11.8-darsda esa oddiy klass nusxasi getsizeof bo'yicha 48, haqiqatda ~88 bayt olishini ko'rdik. Endi savol: xotirada aynan nima sodir bo'ladi?
Real vaziyat. IoT platformasi har bir sensor o'lchovini obyekt sifatida saqlaydi. Jamoa oddiy klassga har xil qurilmalardan kelgan qo'shimcha maydonlarni setattr bilan qo'shib borgan. Obyektlar soni 2 million bo'lganda xotira kutilgan 400 MB o'rniga 1 GB ni ko'rsatdi. __slots__ qo'shildi — xotira 420 MB ga tushdi. Lekin nega farq ikki barobardan ko'p, 8.19-darsdagi jadvalda esa atigi 40–50%?
Javob Python 3.13+ obyekt tuzilishida: oddiy klass atributlari sukut bo'yicha ixcham "inline" massivda saqlanadi va kalitlar klass nusxalari orasida ulashiladi — lekin ma'lum sharoitda bu optimallashtirish buziladi va har bir obyekt o'z to'liq lug'atini oladi. Qaysi sharoitda — shuni bilish muhim.
Bu darsda:
- Obyektning xotiradagi tuzilishi: sarlavha, GC sarlavhasi, slotlar
__basicsize__,__dictoffset__,__weakrefoffset__,__flags__- Oddiy klass 3.13+: inline qiymatlar va ulashilgan kalitlar
- Inline qiymatlar qachon yo'qoladi:
__dict__ga murojaat, juda ko'p yoki turlicha nomlar member_descriptorqanday ishlaydi va nega Python'da uni takrorlab bo'lmaydi- Merosda tuzilish va "lay-out conflict" ning haqiqiy sababi
- Slotlar nimani tejamaydi: qiymat obyektlari
2. Nazariya — chuqur tushuntirish
2.1. Obyekt xotirada
Har bir Python obyekti (64 bit, erkin ipsiz yig'ma) boshlanishida sarlavha bor:
┌──────────────────────────┐
-16 │ GC sarlavhasi (16 bayt) │ ← faqat GC kuzatadigan turlar (11.5-dars)
├──────────────────────────┤
id(obj)→ │ ob_refcnt (8 bayt) │ ← havolalar sanog'i (11.4-dars)
+8 │ ob_type (8 bayt) │ ← type(obj)
+16 │ ... turga xos ma'lumot │
└──────────────────────────┘__slots__ = ("x", "y") bo'lsa, turga xos qism — ikkita ko'rsatkich:
id(obj)+16 → x qiymatiga ko'rsatkich
id(obj)+24 → y qiymatiga ko'rsatkichKlass bu hajmni __basicsize__ da saqlaydi: 16 + 8 × slotlar_soni. Bitta nusxa xotirasi: GC sarlavhasi 16 + __basicsize__ — ya'ni 32 + 8k bayt.
2.2. Tur atributlari
| Atribut | Ma'nosi | Oddiy klass | __slots__ = ("x", "y") |
|---|---|---|---|
__basicsize__ |
Obyektning asosiy hajmi | 16 | 32 |
__itemsize__ |
O'zgaruvchan qism element hajmi (int, tuple) |
0 | 0 |
__dictoffset__ |
__dict__ joyi: 0 — yo'q, -1 — boshqariladigan |
-1 | 0 |
__weakrefoffset__ |
__weakref__ joyi: 0 — yo'q |
-32 | 0 |
__flags__ |
Bayroqlar | MANAGED_DICT, MANAGED_WEAKREF, INLINE_VALUES |
yo'q |
Bayroqlar (3.13+):
| Bayroq | Bit | Ma'nosi |
|---|---|---|
Py_TPFLAGS_INLINE_VALUES |
1 << 2 |
Atribut qiymatlari obyekt bilan birga ajratiladi |
Py_TPFLAGS_MANAGED_WEAKREF |
1 << 3 |
__weakref__ ko'rsatkichi obyekt oldidagi maxsus joyda |
Py_TPFLAGS_MANAGED_DICT |
1 << 4 |
__dict__ ko'rsatkichi obyekt oldidagi maxsus joyda |
Bular — CPython ichki tafsilotlari; tekshiruv va o'rganish uchun, kodda tayanish uchun emas.
2.3. Oddiy klass: inline qiymatlar va ulashilgan kalitlar
Python 3.13+ da __slots__ siz klass nusxasi:
┌──────────────────────────────┐
-32 │ __dict__ ko'rsatkichi (NULL) │ ← "pre-header": boshqariladigan dict va weakref
-24 │ __weakref__ ko'rsatkichi │
-16 │ GC sarlavhasi │
id(obj)→ │ ob_refcnt, ob_type │
+16 │ inline qiymatlar sarlavhasi │
+24 │ x qiymatiga ko'rsatkich │
+32 │ y qiymatiga ko'rsatkich │
│ ... zaxira joylar │
└──────────────────────────────┘
Klassda (bitta nusxa): ulashilgan kalitlar jadvali ["x", "y", ...]- Kalitlar (atribut nomlari) — klassda bitta, hamma nusxalar uchun umumiy
- Qiymatlar — har nusxada, obyekt bilan birga ajratilgan massivda
__dict__— hali yaratilmagan; kimdir so'rasa, shu qiymatlar ustida lug'at yasaladi
Natijada oddiy klass nusxasi ham ancha ixcham: 2 atribut — ~88 bayt, 16 atribut — ~216 bayt. __slots__ bilan: 48 va 160 bayt. Farq — asosan pre-header (16 bayt), inline qiymatlar sarlavhasi va zaxira joylar.
2.4. Inline qiymatlar qachon yo'qoladi
| Holat | Nima bo'ladi | 3.14 da o'lchov (bir nusxa) |
|---|---|---|
obj.__dict__ yoki vars(obj) ga murojaat |
Har nusxada haqiqiy dict obyekti yaratiladi |
88 → ~152 bayt |
| Hamma nusxada bir xil, lekin 30 va undan ortiq atribut | Inline qiymatlar ishlatilmaydi — har nusxada to'liq lug'at | 29 atribut ~320, 30 atribut ~1900 bayt |
Nusxalar turli nomlar olib keladi (JSON dan setattr) |
Ulashilgan kalitlar jadvali to'ladi; keyingi yangi nomli nusxalar lug'atga o'tadi | 3.14 o'lchovida ~17-nomdan boshlab |
| Atributlar turli tartibda qo'shiladi | 3.14 da zarar bermadi | 88 → 88 |
del obj.attr |
Qiymat joyi bo'shaydi, tuzilish saqlanadi | Kichik farq |
Kirishdagi IoT vaziyati — ikkinchi va uchinchi qatorlar: turli qurilmalar o'nlab turli maydon nomi olib keldi, ulashilgan jadval to'ldi va millionlab obyekt har biri to'liq lug'at bilan yashay boshladi.
__slots__ bu xavfdan to'liq ozod: tuzilish klass yaratilganda qat'iy belgilanadi.
2.5. member_descriptor
Har slot uchun klassga member_descriptor qo'yiladi — data deskriptor (10.17-dars):
Nuqta.x # <member 'x' of 'Nuqta' objects>
Nuqta.x.__get__(n) # id(n)+16 dagi ko'rsatkichni o'qiydi
Nuqta.x.__set__(n, 5) # id(n)+16 ga yozadi- Ko'rsatkich
NULLbo'lsa (hali berilmagan yokidel) —AttributeError - Data deskriptor bo'lgani uchun
__getattribute__uni nusxa lug'atidan oldin topadi — va lug'at yo'q - Qiymat berilganda ko'rsatkich oddiy havola: havolalar sanog'i oshadi
Python'da xuddi shunday deskriptor yozish mumkin, lekin qiymatlarni qayerdadir saqlash kerak bo'ladi — ro'yxat yoki lug'at, ya'ni yana alohida obyekt. Slotlarning tejami aynan C darajasida, obyektning o'z baytlarida saqlashdan keladi.
2.6. Merosda tuzilish
class A: __slots__ = ("a",) # __basicsize__ 24: a → +16
class B(A): __slots__ = ("b",) # __basicsize__ 32: a → +16, b → +24Avlod ota tuzilishini kengaytiradi — ota slotlari o'z joyida qoladi, shuning uchun ota metodlari avlod nusxasida ham ishlaydi.
"Lay-out conflict" sababi:
class A: __slots__ = ("a",) # a → +16
class X: __slots__ = ("c",) # c → +16
class C(A, X): ... # ❌ +16 da a turadimi yoki c?Ikkala ota ham +16 baytni o'ziga band qilgan — bitta obyekt ikkalasiga mos bo'la olmaydi. Bo'sh __slots__ = () joy band qilmaydi, shuning uchun aralashmalar (mixin) uchun ishlaydi.
Avlodda __slots__ yozilmasa, u oddiy klass bayroqlarini oladi (MANAGED_DICT, INLINE_VALUES) — ota slotlari saqlanadi, lekin yangi atributlar lug'atga ketadi.
2.7. Slotlar nimani tejamaydi
__slots__ faqat ko'rsatkichlar konteynerini ixchamlashtiradi. Qiymatlar baribir alohida obyekt:
O'lchov(vaqt: float, harorat: float, namlik: float) — __slots__ bilan:
obyekt 56 bayt
3 ta float obyekt 72 bayt ← obyektdan katta!Million o'lchovli ma'lumotda keyingi qadam — ustunli saqlash (array, NumPy — 24-qism): qiymatlar raw baytlar sifatida, obyektsiz.
3. Tez ma'lumotnoma
Hajm (3.14, 64 bit, bir nusxa)
__slots__, k atribut → 32 + 8k (GC 16 + sarlavha 16 + slotlar)
oddiy klass, k ≤ ~29 nom → inline: 2 → ~88, 16 → ~216
oddiy klass, 30+ atribut → har nusxada to'liq dict: ~1900+
turli nomli nusxalar → ~17 nomdan keyin yangi nusxalar lug'atli
__dict__ ga murojaat → +~64
__slots__ + "__weakref__" → +16Tur atributlari
T.__basicsize__ obyekt asosiy hajmi
T.__dictoffset__ 0 — dict yo'q, -1 — boshqariladigan
T.__weakrefoffset__ 0 — weakref yo'q
T.__flags__ & (1<<2) INLINE_VALUES
T.__flags__ & (1<<4) MANAGED_DICTMexanizm
slot = member_descriptor → id(obj) + ofset dagi ko'rsatkich
merosda ofsetlar kengayadi; ikki bo'sh bo'lmagan ota → lay-out conflict4. Batafsil misollar
Misol 1 — Obyekt tuzilishini ko'rish
"""Tur atributlari va bayroqlar; ctypes bilan slot va inline qiymat ko'rsatkichlarini xotiradan o'qish; meros ofsetlari."""
import ctypes
INLINE_VALUES, MANAGED_WEAKREF, MANAGED_DICT = 1 << 2, 1 << 3, 1 << 4
class Oddiy:
def __init__(self):
self.x = 1001.5
self.y = "".join(["qiy", "mat"])
class Slotli:
__slots__ = ("x", "y")
def __init__(self):
self.x = 1001.5
self.y = "".join(["qiy", "mat"])
class SlotliWeakref:
__slots__ = ("x", "y", "__weakref__")
class SlotliDict:
__slots__ = ("x", "y", "__dict__")
class BoshSlot:
__slots__ = ()
class Ota:
__slots__ = ("a",)
class Bola(Ota):
__slots__ = ("b",)
class Nabira(Bola):
pass
def bayroqlar(t):
nomlar = [nom for nom, bit in [("INLINE", INLINE_VALUES), ("M_WEAKREF", MANAGED_WEAKREF), ("M_DICT", MANAGED_DICT)] if t.__flags__ & bit]
return ", ".join(nomlar) or "—"
print("=== 1. Tur atributlari ===")
print(f" {'klass':14} {'basicsize':>9} {'dictoffset':>10} {'weakrefoff':>10} bayroqlar")
for t in [object, Oddiy, Slotli, SlotliWeakref, SlotliDict, BoshSlot, Ota, Bola, Nabira]:
print(f" {t.__name__:14} {t.__basicsize__:>9} {t.__dictoffset__:>10} {t.__weakrefoffset__:>10} {bayroqlar(t)}")
print("\n=== 2. Xotiradan o'qish (faqat o'rganish uchun!) ===")
def korsatkich(obyekt, ofset):
return ctypes.c_void_p.from_address(id(obyekt) + ofset).value
def xarita(obyekt, ofsetlar):
nomlar = {id(type(obyekt)): "type(obj)", id(obyekt.x): "x qiymati", id(obyekt.y): "y qiymati"}
return " ".join(f"+{o}:{nomlar.get(korsatkich(obyekt, o), '·')}" for o in ofsetlar)
s, o = Slotli(), Oddiy()
print(f" Slotli: {xarita(s, [8, 16, 24])}")
print(f" Oddiy: {xarita(o, [8, 16, 24, 32])}")
print(f" Slotli.x: {Slotli.x!r}, turi {type(Slotli.x).__name__}, data deskriptor: {hasattr(type(Slotli.x), '__set__')}")
del s.x
print(f" del s.x dan keyin +16 dagi ko'rsatkich: {korsatkich(s, 16)}, hasattr(s, 'x'): {hasattr(s, 'x')}")
print("\n=== 3. Merosda ofsetlar kengayadi ===")
n = Bola()
n.a, n.b = "".join(["A", "!"]), "".join(["B", "!"])
print(f" Bola: +16 → a: {korsatkich(n, 16) == id(n.a)}, +24 → b: {korsatkich(n, 24) == id(n.b)}")
class Boshqa:
__slots__ = ("c",)
try:
type("Aralash", (Ota, Boshqa), {})
except TypeError as xato:
print(f" Ota(a → +16) + Boshqa(c → +16): TypeError: {xato}")
Aralash = type("Aralash", (Ota, BoshSlot), {"__slots__": ()})
print(f" Ota + bo'sh slotli aralashma: ishlaydi, basicsize {Aralash.__basicsize__}")Natijaning muhim qismi:
=== 1. Tur atributlari ===
klass basicsize dictoffset weakrefoff bayroqlar
object 16 0 0 —
Oddiy 16 -1 -32 INLINE, M_WEAKREF, M_DICT
Slotli 32 0 0 —
SlotliWeakref 32 0 -32 M_WEAKREF
SlotliDict 32 -1 0 INLINE, M_DICT
BoshSlot 16 0 0 —
Ota 24 0 0 —
Bola 32 0 0 —
Nabira 32 -1 -32 INLINE, M_WEAKREF, M_DICT
=== 2. Xotiradan o'qish (faqat o'rganish uchun!) ===
Slotli: +8:type(obj) +16:x qiymati +24:y qiymati
Oddiy: +8:type(obj) +16:· +24:x qiymati +32:y qiymati
Slotli.x: <member 'x' of 'Slotli' objects>, turi member_descriptor, data deskriptor: True
del s.x dan keyin +16 dagi ko'rsatkich: None, hasattr(s, 'x'): False
=== 3. Merosda ofsetlar kengayadi ===
Bola: +16 → a: True, +24 → b: True
Ota(a → +16) + Boshqa(c → +16): TypeError: multiple bases have instance lay-out conflict
Ota + bo'sh slotli aralashma: ishlaydi, basicsize 24Nima ko'rsatdi: 2.1, 2.2, 2.5, 2.6-bo'limlar. Slot qiymatlari aynan id(obj)+16 va +24 da; oddiy klassda esa inline qiymatlar sarlavhasidan keyin, +24 va +32 da.
Misol 2 — Atributlar soni va inline qiymatlarning yo'qolishi
"""tracemalloc bilan bir nusxa: atributlar soni 1..64; __dict__ ga murojaat; turli nomlar; turli tartib; del."""
import gc
import sys
import tracemalloc
N = 20_000
def bir_nusxa(yasovchi):
gc.collect()
tracemalloc.start()
nusxalar = [yasovchi(i) for i in range(N)]
jami, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
return round((jami - sys.getsizeof(nusxalar)) / N)
def klass_yasa(k, slotli):
nomlar = [f"maydon{i}" for i in range(k)]
def __init__(self, i):
for nom in nomlar:
setattr(self, nom, None)
ichki = {"__init__": __init__}
if slotli:
ichki["__slots__"] = tuple(nomlar)
return type(f"K{k}", (), ichki)
print("=== 1. Atributlar soni ===")
print(f" {'k':>3} {'oddiy':>7} {'slotli':>7} {'32 + 8k':>8}")
for k in [1, 2, 4, 8, 16, 28, 29, 30, 40, 64]:
oddiy, slotli = bir_nusxa(klass_yasa(k, False)), bir_nusxa(klass_yasa(k, True))
belgi = " ← har nusxada to'liq dict" if oddiy > 1000 else ""
print(f" {k:>3} {oddiy:>7} {slotli:>7} {32 + 8 * k:>8}{belgi}")
class Nuqta:
def __init__(self, i):
self.x = None
self.y = None
def dict_bilan(i):
n = Nuqta(i)
n.__dict__
return n
class TartibNuqta:
def __init__(self, i):
if i % 2:
self.x, self.y = None, None
else:
self.y, self.x = None, None
class Ochirish:
def __init__(self, i):
self.x, self.y, self.z = None, None, None
del self.y
class Qurilma:
"""Har qurilma o'z qo'shimcha maydonini olib keladi (JSON dan setattr)."""
def __init__(self, i):
self.id = None
setattr(self, f"sensor_{i % 60}", None)
print("\n=== 2. Inline qiymatlar qachon yo'qoladi ===")
for tavsif, yasovchi in [("oddiy Nuqta (x, y)", Nuqta), ("har biriga __dict__ murojaati", dict_bilan),
("turli tartibda x, y", TartibNuqta), ("del bilan (x, y, z → x, z)", Ochirish),
("60 xil sensor nomi (id + 1 maydon)", Qurilma)]:
print(f" {tavsif:36} {bir_nusxa(yasovchi):>6} bayt")
print("\n=== 3. Qaysi nusxadan lug'atga o'tiladi ===")
def lugatlimi(obyekt):
"""Inline obyektning referentlari — qiymatlarning o'zi; lug'atga o'tganda — dict. vars() chaqirilmaydi."""
return any(type(r) is dict for r in gc.get_referents(obyekt))
class YangiQurilma:
def __init__(self, i):
self.id = None
setattr(self, f"sensor_{i}", None)
class BirXilMaydonlar:
def __init__(self, i):
for j in range(29):
setattr(self, f"maydon{j}", None)
qurilmalar = [YangiQurilma(i) for i in range(40)]
birinchi = next(i for i, q in enumerate(qurilmalar) if lugatlimi(q))
print(f" har nusxa yangi nom (id + sensor_i): #{birinchi} dan boshlab lug'at — "
f"shu nusxa bilan klassda {birinchi + 2} xil nom; 40 dan {sum(map(lugatlimi, qurilmalar))} tasi lug'atli")
bir_xil = [BirXilMaydonlar(i) for i in range(40)]
print(f" hamma nusxada bir xil 29 nom: lug'atli nusxalar {sum(map(lugatlimi, bir_xil))} ta")
n = Nuqta(0)
oldin = lugatlimi(n)
n.__dict__
print(f" Nuqta: __dict__ murojaatidan oldin lug'atli {oldin}, keyin {lugatlimi(n)}")Natijaning muhim qismi:
=== 1. Atributlar soni ===
k oddiy slotli 32 + 8k
1 80 40 40
2 88 48 48
4 104 64 64
8 144 96 96
16 216 160 160
28 320 256 256
29 320 264 264
30 1904 272 272 ← har nusxada to'liq dict
40 1904 352 352 ← har nusxada to'liq dict
64 1904 544 544 ← har nusxada to'liq dict
=== 2. Inline qiymatlar qachon yo'qoladi ===
oddiy Nuqta (x, y) 88 bayt
har biriga __dict__ murojaati 152 bayt
turli tartibda x, y 88 bayt
del bilan (x, y, z → x, z) 96 bayt
60 xil sensor nomi (id + 1 maydon) 338 bayt
=== 3. Qaysi nusxadan lug'atga o'tiladi ===
har nusxa yangi nom (id + sensor_i): #15 dan boshlab lug'at — shu nusxa bilan klassda 17 xil nom; 40 dan 25 tasi lug'atli
hamma nusxada bir xil 29 nom: lug'atli nusxalar 0 ta
Nuqta: __dict__ murojaatidan oldin lug'atli False, keyin TrueNima ko'rsatdi: 2.3, 2.4-bo'limlar.
Misol 3 — Slotni Python'da takrorlab ko'rish
"""member_descriptor ni Python deskriptori bilan taqlid qilish: xulq bir xil, lekin xotira tejalmaydi — nega."""
import gc
import sys
import tracemalloc
_BOSH = object()
class Orin:
"""Slot taqlidi: qiymat nusxadagi yagona ro'yxatning indeks-joyida."""
def __init__(self, indeks):
self.indeks = indeks
def __set_name__(self, egasi, nom):
self.nom = nom
def __get__(self, obj, egasi=None):
if obj is None:
return self
qiymat = obj._joylar[self.indeks]
if qiymat is _BOSH:
raise AttributeError(f"{egasi.__name__!r} obyektida {self.nom!r} yo'q")
return qiymat
def __set__(self, obj, qiymat):
obj._joylar[self.indeks] = qiymat
def __delete__(self, obj):
if obj._joylar[self.indeks] is _BOSH:
raise AttributeError(self.nom)
obj._joylar[self.indeks] = _BOSH
def taqlid_slotlar(*nomlar):
def bezak(klass):
for i, nom in enumerate(nomlar):
deskriptor = Orin(i)
setattr(klass, nom, deskriptor)
deskriptor.__set_name__(klass, nom)
eski_new = klass.__new__
def __new__(cls, *args, **kwargs):
obj = eski_new(cls) if eski_new is object.__new__ else eski_new(cls, *args, **kwargs)
object.__setattr__(obj, "_joylar", [_BOSH] * len(nomlar))
return obj
klass.__new__ = __new__
return klass
return bezak
@taqlid_slotlar("x", "y")
class TaqlidNuqta:
__slots__ = ("_joylar",)
def __init__(self, x, y):
self.x, self.y = x, y
class HaqiqiyNuqta:
__slots__ = ("x", "y")
def __init__(self, x, y):
self.x, self.y = x, y
print("=== 1. Xulq bir xil ===")
for klass in [TaqlidNuqta, HaqiqiyNuqta]:
n = klass(3, 4)
del n.y
try:
n.y
except AttributeError:
holat = "AttributeError"
try:
n.z = 1
qoshimcha = "qo'shildi"
except AttributeError:
qoshimcha = "AttributeError"
print(f" {klass.__name__:13} x={n.x}, del y → o'qish: {holat}, yangi atribut: {qoshimcha}, deskriptor: {type(klass.__dict__['x']).__name__}")
def bir_nusxa(yasovchi, n=50_000):
gc.collect()
tracemalloc.start()
nusxalar = [yasovchi() for _ in range(n)]
jami, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
return round((jami - sys.getsizeof(nusxalar)) / n)
print("\n=== 2. Xotira ===")
taqlid = bir_nusxa(lambda: TaqlidNuqta(None, None))
haqiqiy = bir_nusxa(lambda: HaqiqiyNuqta(None, None))
print(f" taqlid: {taqlid} bayt = obyekt {TaqlidNuqta.__basicsize__ + 16} + ro'yxat {taqlid - TaqlidNuqta.__basicsize__ - 16}")
print(f" haqiqiy __slots__: {haqiqiy} bayt")
print(" taqlidda qiymatlar baribir alohida obyektda (ro'yxat) — tejash faqat C darajasida, obyekt baytlarida mumkin")Natijaning muhim qismi:
=== 1. Xulq bir xil ===
TaqlidNuqta x=3, del y → o'qish: AttributeError, yangi atribut: AttributeError, deskriptor: Orin
HaqiqiyNuqta x=3, del y → o'qish: AttributeError, yangi atribut: AttributeError, deskriptor: member_descriptor
=== 2. Xotira ===
taqlid: 112 bayt = obyekt 40 + ro'yxat 72
haqiqiy __slots__: 48 bayt
taqlidda qiymatlar baribir alohida obyektda (ro'yxat) — tejash faqat C darajasida, obyekt baytlarida mumkinNima ko'rsatdi: 2.5-bo'lim.
Misol 4 — Amaliy: 200 000 sensor o'lchovi
IoT servisidagi o'lchov yozuvini to'rt usulda saqlaymiz va har qadam qancha tejashini ko'ramiz. Oxirgi usul — slotlar ham yetmay qolganda nima qilish.
"""O'lchov: oddiy klass + dinamik maydonlar, oddiy klass, __slots__, __slots__ + intern, ustunli array — tracemalloc bilan."""
import array
import gc
import random
import sys
import tracemalloc
N = 200_000
rng = random.Random(20260914)
QURILMA_TURLARI = [f"model-{i}" for i in range(12)]
XOM = [(1_760_000_000 + i, rng.choice(QURILMA_TURLARI), round(rng.uniform(-20, 45), 2),
round(rng.uniform(10, 95), 1), rng.randrange(40)) for i in range(N)]
class DinamikOlchov:
def __init__(self, vaqt, qurilma, harorat, namlik, qoshimcha):
self.vaqt, self.qurilma, self.harorat, self.namlik = vaqt, qurilma, harorat, namlik
setattr(self, f"qurilma_maydoni_{qoshimcha}", True)
class OddiyOlchov:
def __init__(self, vaqt, qurilma, harorat, namlik, qoshimcha):
self.vaqt, self.qurilma, self.harorat, self.namlik = vaqt, qurilma, harorat, namlik
self.qoshimcha = qoshimcha
class SlotOlchov:
__slots__ = ("vaqt", "qurilma", "harorat", "namlik", "qoshimcha")
def __init__(self, vaqt, qurilma, harorat, namlik, qoshimcha):
self.vaqt, self.qurilma, self.harorat, self.namlik = vaqt, qurilma, harorat, namlik
self.qoshimcha = qoshimcha
def satr_nusxa(s):
return "".join(list(s))
def obyektli(klass, intern=False):
def yukla():
return [klass(int(str(v)), sys.intern(satr_nusxa(q)) if intern else satr_nusxa(q), float(str(h)), float(str(nm)), k)
for v, q, h, nm, k in XOM]
return yukla
def ustunli():
vaqtlar = array.array("q", (v for v, *_ in XOM))
qurilmalar = array.array("B", (QURILMA_TURLARI.index(q) for _, q, *_ in XOM))
haroratlar = array.array("f", (h for _, _, h, _, _ in XOM))
namliklar = array.array("f", (nm for *_, nm, _ in XOM))
qoshimchalar = array.array("B", (k for *_, k in XOM))
return vaqtlar, qurilmalar, haroratlar, namliklar, qoshimchalar
def olchov(yukla):
gc.collect()
tracemalloc.start()
malumot = yukla()
jami, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
return jami, malumot
print(f"=== 1. {N:,} o'lchov ===")
natijalar = []
for tavsif, yukla in [("oddiy + 40 xil dinamik maydon", obyektli(DinamikOlchov)),
("oddiy klass, qat'iy maydonlar", obyektli(OddiyOlchov)),
("__slots__", obyektli(SlotOlchov)),
("__slots__ + sys.intern", obyektli(SlotOlchov, intern=True)),
("ustunli array", ustunli)]:
jami, malumot = olchov(yukla)
natijalar.append((tavsif, jami))
del malumot
eng_katta = natijalar[0][1]
for tavsif, jami in natijalar:
print(f" {tavsif:30} {jami / 1e6:6.1f} MB {jami / N:5.0f} bayt/o'lchov {eng_katta / jami:5.1f}x kichik")
print("\n=== 2. Slotli o'lchovning tarkibi ===")
namuna = SlotOlchov(*XOM[0][:1], satr_nusxa(XOM[0][1]), float(str(XOM[0][2])), float(str(XOM[0][3])), XOM[0][4])
qismlar = {
"obyekt (GC + __basicsize__)": 16 + SlotOlchov.__basicsize__,
"vaqt (katta int)": sys.getsizeof(namuna.vaqt),
"qurilma satri": sys.getsizeof(namuna.qurilma),
"harorat + namlik (2 float)": 2 * sys.getsizeof(namuna.harorat),
"qoshimcha (kichik int, umumiy)": 0,
}
for nom, bayt in qismlar.items():
print(f" {nom:32} {bayt:>4} bayt")
print(f" jami ≈ {sum(qismlar.values())} bayt; obyektning o'zi atigi {qismlar['obyekt (GC + __basicsize__)'] / sum(qismlar.values()):.0%}")Natijaning muhim qismi:
=== 1. 200,000 o'lchov ===
oddiy + 40 xil dinamik maydon 105.3 MB 526 bayt/o'lchov 1.0x kichik
oddiy klass, qat'iy maydonlar 49.7 MB 248 bayt/o'lchov 2.1x kichik
__slots__ 41.7 MB 208 bayt/o'lchov 2.5x kichik
__slots__ + sys.intern 32.0 MB 160 bayt/o'lchov 3.3x kichik
ustunli array 3.8 MB 19 bayt/o'lchov 27.7x kichik
=== 2. Slotli o'lchovning tarkibi ===
obyekt (GC + __basicsize__) 72 bayt
vaqt (katta int) 32 bayt
qurilma satri 48 bayt
harorat + namlik (2 float) 48 bayt
qoshimcha (kichik int, umumiy) 0 bayt
jami ≈ 200 bayt; obyektning o'zi atigi 36%Nima ko'rsatdi: 2.4, 2.7-bo'limlar.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
| "Oddiy klassda har nusxaning o'z lug'ati bor" | 3.13+ da inline qiymatlar va ulashilgan kalitlar; lug'at so'ralganda yaratiladi |
"__slots__ 3.13+ da foydasiz" |
Oddiy holatda ~40 bayt tejaydi; 30+ atribut, turli nomlar yoki __dict__ murojaatida o'n barobargacha |
| "Atributlar tartibi kalitlar ulashishini buzadi" | 3.14 da buzmadi |
"__slots__ qiymatlarni ham ixcham saqlaydi" |
Faqat ko'rsatkichlarni; float, int, str obyektlari alohida |
"getsizeof(obj) slot va oddiy klass farqini ko'rsatadi" |
Ikkalasi ham 48 — tracemalloc kerak |
| "Slotni Python deskriptori bilan xuddi shunday yozish mumkin" | Xulqni ha, xotira tejashni yo'q |
| "Lay-out conflict — Python'ning ixtiyoriy cheklovi" | Ikki ota bir xil bayt ofsetini band qilgan |
"__weakref__ slot bepul" |
3.14 da boshqariladigan joy, +16 bayt |
6. Keng tarqalgan xatolar va yechimlari
1. Ma'lumotdan kelgan nomlarni setattr bilan obyektga yozish
for kalit, qiymat in json_yozuv.items():
setattr(olchov, kalit, qiymat) # ❌ nomlar ko'p — ulashilgan kalitlar to'ladi Qat'iy maydonlar + qoshimcha: dict maydoni, yoki qat'iy slotlar.
2. Loglash yoki serializatsiyada har obyektda vars(obj)
log.debug("holat: %s", vars(obj)) # ❌ har chaqiruv __dict__ ni yaratib qo'yadi __repr__ yoki dataclasses.asdict, faqat kerak paytda.
3. Tuzilmani getsizeof bilan tanlash
sys.getsizeof(Oddiy()) == sys.getsizeof(Slotli()) # True — "farq yo'q" ❌ tracemalloc bilan ko'p nusxa (11.8-dars).
4. Ikki bo'sh bo'lmagan slotli otadan meros
class Nuqta(Koordinata, Rang): ... # ❌ lay-out conflict Aralashmalarda __slots__ = (), maydonlarni bitta otada yoki kompozitsiya bilan.
5. Slotlar yetmay qolganda obyektlarni ko'paytirishda davom etish
olchovlar = [SlotOlchov(...) for ...] # ⚠️ 10 mln — baribir GB lab Ustunli saqlash: array, NumPy, pandas (24-qism).
6. Slotli klassda __dict__ qo'shib, tejashni yo'qotish
__slots__ = ("x", "y", "__dict__") # ⚠️ oddiy klassdek ~88 bayt7. Ichki bayroq va ofsetlarga production kodda tayanish
if cls.__flags__ & (1 << 4): ... # ❌ versiyaga bog'liq ichki tafsilot
ctypes.c_void_p.from_address(id(obj) + 16) # ❌ xavfli, faqat o'rganish uchun8. Avlodda __slots__ ni unutish
class Maxsus(SlotOlchov):
pass # ⚠️ MANAGED_DICT qaytadi, har nusxa qimmatlashadi __slots__ = () yoki yangi maydonlar.
7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 8.19-dars (o'tilgan):
__slots__amaliyoti — cheklovlar, meros,dataclass(slots=True) - 10.17-dars (o'tilgan): deskriptor protokoli —
member_descriptordata deskriptor - 11.5-dars (o'tilgan): GC sarlavhasi
- 11.8-dars (o'tilgan):
tracemallocbilan o'lchash - 11.10-dars:
weakrefva__weakref__sloti - 12.4-dars:
PyObjectva tur tuzilmasi C darajasida - 24.1-dars: NumPy — ustunli, obyektsiz saqlash
- 29.9-dars: xotira optimizatsiyasi
8. Eng yaxshi amaliyotlar
Ko'p nusxali, maydonlari qat'iy klasslarda
__slots__(yokidataclass(slots=True)).Obyektlarga ma'lumotdan kelgan ixtiyoriy nomlarni
setattrqilmang — qo'shimcha maydonlar uchun bitta lug'at maydoni.vars(obj)/obj.__dict__ni issiq yo'lda chaqirmang.Aralashmalarda
__slots__ = ().Har avlodda
__slots__yozing.Tejashni
tracemallocbilan o'lchang —getsizeoffarqni ko'rsatmaydi.Qiymat obyektlari xotirada ustunlik qilsa — ustunli saqlashga o'ting.
Ichki bayroqlar, ofsetlar va
ctypes— faqat o'rganish va tashxis uchun.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
import sys
class Oddiy:
pass
class Slotli:
__slots__ = ("x", "y")
1. print(Slotli.__basicsize__)
2. print(Oddiy.__basicsize__)
3. class Bosh:
__slots__ = ()
print(Bosh.__basicsize__)
4. print(type(Slotli.x).__name__)
5. s = Slotli()
print(hasattr(s, "x"))
6. class Bola(Slotli):
pass
b = Bola()
b.z = 1
print(b.__dict__)
7. class Uch(Slotli):
__slots__ = ("z",)
print(Uch.__basicsize__)
8. print(Slotli.__dictoffset__, Oddiy.__dictoffset__)
9. s = Slotli()
s.x = 1
del s.x
print(hasattr(s, "x"))
10. try:
class K:
__slots__ = ("x",)
x = 5
except ValueError as e:
print(type(e).__name__)
11. print(sys.getsizeof(Slotli()) == sys.getsizeof(Oddiy()))
12. class T:
__slots__ = "ab"
print(T.__slots__, hasattr(T, "a"), hasattr(T, "ab"))Javoblar
32— sarlavha 16 + 2 slot16— inline qiymatlar__basicsize__ga kirmaydi16member_descriptorFalse— slot bor, qiymat berilmagan{'z': 1}— avlodda__slots__yo'q,__dict__qaytdi40— ota slotlari +z0 -1— slotlida lug'at yo'q, oddiyda boshqariladiganFalseValueErrorTrue—getsizeofinline qiymatlarni ko'rmaydiab False True— satr bitta slot nomi sifatida olinadi
Vazifa 2: Xatolarni tuzating
1. class Olchov:
def __init__(self, yozuv: dict):
for k, v in yozuv.items():
setattr(self, k, v)
2. class Koordinata:
__slots__ = ("x", "y")
class Rang:
__slots__ = ("r", "g", "b")
class RangliNuqta(Koordinata, Rang):
pass
3. def xotira_farqi(a, b):
return sys.getsizeof(a) - sys.getsizeof(b)
4. class Hodisa:
__slots__ = ("nom", "vaqt")
class Kirish(Hodisa):
def __init__(self, nom, vaqt, ip):
self.nom, self.vaqt, self.ip = nom, vaqt, ip
5. def debug_hammasi(obyektlar):
return [vars(o) for o in obyektlar]Javoblar
1. class Olchov:
__slots__ = ("vaqt", "qurilma", "qiymat", "qoshimcha")
def __init__(self, yozuv: dict):
self.vaqt = yozuv.pop("vaqt")
self.qurilma = yozuv.pop("qurilma")
self.qiymat = yozuv.pop("qiymat")
self.qoshimcha = yozuv # ixtiyoriy nomlar bitta lug'atda
2. class Koordinata:
__slots__ = ("x", "y")
class Rang:
__slots__ = () # aralashma — joy band qilmaydi
class RangliNuqta(Koordinata, Rang):
__slots__ = ("r", "g", "b")
3. def xotira_farqi(yasovchi_a, yasovchi_b, n=10_000):
def olch(f):
tracemalloc.start()
nusxalar = [f() for _ in range(n)]
jami = tracemalloc.get_traced_memory()[0]
tracemalloc.stop()
return jami / n
return olch(yasovchi_a) - olch(yasovchi_b) # getsizeof inline qiymatlarni ko'rmaydi
4. class Kirish(Hodisa):
__slots__ = ("ip",) # aks holda __dict__ qaytadi
def __init__(self, nom, vaqt, ip):
self.nom, self.vaqt, self.ip = nom, vaqt, ip
5. def debug_hammasi(obyektlar):
return [repr(o) for o in obyektlar] # vars har obyektda lug'at yaratadi (slotlida esa TypeError)Vazifa 3: Tuzilma ko'ruvchi
tuzilma(klass) funksiyasini yozing:
__basicsize__,__dictoffset__,__weakrefoffset__va bayroqlarni o'qib, 2.1-bo'limdagi kabi ASCII sxema chizsin- MRO bo'ylab har slot qaysi klassdan kelganini va ofsetini ko'rsatsin (ofsetni
ctypesyordamida nusxa yaratib aniqlang) - Takrorlangan slot nomlarini (8.19-dars, meros qoidasi B) topib ogohlantirsin
int,tuple,Exception,dataclass(slots=True)va o'z klasslaringizda sinab ko'ring
Vazifa 4: Ulashilgan kalitlar chegarasi
- Nusxalari 1, 2, ... 60 xil nomdan bittadan atribut oladigan klass uchun har nusxaning
tracemallochajmini chizing - Qaysi nusxadan boshlab hajm sakrashini aniqlang
- Klassga oldindan barcha nomlarni
__init__daNonebilan berib, farqni ko'rsating - Natijani CPython manba kodidagi
SHARED_KEYS_MAX_SIZEbilan solishtiring
Vazifa 5: Avtomatik slotlar
@avto_slots klass dekoratorini yozing (10.10-dars):
__init__manba kodiniastbilan tahlil qilib,self.nom = ...ko'rinishidagi barcha nomlarni topsin (yoki 3.13+ dagi__static_attributes__dan foydalansin)- Shu nomlar bilan yangi slotli klass yaratsin (
dataclass(slots=True)qanday qilishini eslang — 10.10-dars) property, klass atributlari va ota slotlari bilan to'qnashuvlarni hal qilsin- Misol 4 dagi
OddiyOlchovga qo'llab, xotirani o'lchang
Vazifa 6: Obyektdan ustunlarga
UstunliJadval klassini yozing:
- Maydon turlarini (
int,float,str,bool) qabul qilib, har biri uchun mosarrayyoki satrlar uchun lug'at kodlash (kategoriya) ishlatsin qosh(**maydonlar),jadval[i](yengil ko'rinish obyekti qaytarsin),filtr(shart),len- Ko'rinish obyekti slotli bo'lib, faqat jadval va indeksni saqlasin
- Misol 4 dagi 200 000 o'lchov bilan xotira va
harorat > 30filtri tezligini obyektli variant bilan solishtiring
Vazifa 7: O'ylash
JavaScript dvigatellari (V8) obyektlar uchun "yashirin klasslar" (hidden classes, shapes) va inline keshlardan foydalanadi, Java obyekt maydonlarini kompilyatsiyada qat'iy belgilaydi, Python 3.13+ esa oddiy klasslar uchun ulashilgan kalitlar va inline qiymatlarni, __slots__ uchun esa qat'iy ofsetlarni ishlatadi. Bu yondashuvlar qanday o'xshash va farqli, va nega Python'da dasturchi __slots__ ni qo'lda yozishi kerak, V8 da esa bunday kalit so'z yo'q?
Javob
Qisqa javob: uchala tizim ham bitta muammoni hal qiladi — "atribut nomi → qiymat" xaritasini har obyektda saqlamaslik. Nomlar tuzilishini (shape) ko'p obyekt orasida ulashish, qiymatlarni esa obyektda ofset bo'yicha saqlash. Farq — bu tuzilish qachon va kim tomonidan aniqlanishida: Java'da kompilyatorda, V8 da ish vaqtida avtomatik va JIT bilan, Python'da oddiy klasslar uchun ish vaqtida (cheklangan), __slots__ bilan esa dasturchi tomonidan.
1. Java
class Nuqta { double x; double y; } // maydonlar va ofsetlar kompilyatsiya/yuklashda qat'iy- Yangi maydon qo'shib bo'lmaydi — Python'dagi
__slots__ga o'xshash, lekin majburiy doubleqiymatlar obyekt ichida raw holda — Python slotlaridan ham ixcham (ko'rsatkich + float obyekt emas)- Moslashuvchanlik kerak bo'lsa —
Map<String, Object>
2. JavaScript (V8): yashirin klasslar
const a = {}; a.x = 1; a.y = 2; // shape: {} → {x} → {x, y}
const b = {}; b.x = 5; b.y = 6; // xuddi shu shape zanjiri — ulashiladi
const c = {}; c.y = 1; c.x = 2; // ⚠️ boshqa tartib → boshqa shape- Har bir yangi atribut qo'shilishi shape o'tishini yaratadi; bir xil tartibdagi obyektlar bitta shape ni ulashadi
- Inline keshlar:
obj.xjoyi shape bo'yicha ofset sifatida keshlanadi — JIT bilan juda tez - Shape lar juda ko'payib ketsa (turli tartib,
delete, dinamik kalitlar) obyekt "lug'at rejimi" ga o'tadi — Python'dagi ko'p/turli nomlar holatining aynan o'xshashi - Dasturchiga maslahat: konstruktorda barcha maydonlarni bir xil tartibda bering — ya'ni qo'lda yozilmagan, lekin intizom bilan saqlanadigan "slotlar"
3. Python
| Oddiy klass (3.13+) | __slots__ |
|
|---|---|---|
| Tuzilish kim belgilaydi | Ish vaqti, klass bo'yicha ulashilgan kalitlar | Dasturchi, klass yaratilganda |
| Chegara | ~30 atribut, ko'p turli nomlar, __dict__ murojaati |
Yo'q, lekin yangi atribut qo'shib bo'lmaydi |
| Tartib | 3.14 da ahamiyatsiz | Ahamiyatsiz |
| Qiymatlar | Ko'rsatkichlar (obyektlar alohida) | Ko'rsatkichlar |
| Tezlashtirish | Ixtisoslashgan bayt-kod (3.11+) inline keshlari | Xuddi shu |
4. Nega Python'da __slots__ qo'lda
- Semantika o'zgaradi: slot yangi atribut qo'shishni taqiqlaydi,
__dict__vaweakrefni olib tashlaydi, meros qoidalarini o'zgartiradi. Bu xulq o'zgarishi — optimallashtirish emas; uni interpretator o'z-o'zidan qila olmaydi - V8 semantikani o'zgartirmaydi: JS obyektiga istalgan paytda maydon qo'shish mumkin — shape faqat ichki tafsilot. Python 3.13+ ning inline qiymatlari ham aynan shu yo'ldan borgan — shuning uchun oddiy klasslar tejamkorroq bo'ldi va
__slots__ning foydasi kamaydi - JIT yo'qligi: V8 shape larni JIT va deoptimizatsiya bilan agressiv boshqaradi; CPython'da bunday mexanizm yangi va cheklangan (3.13+ tajribaviy JIT), shuning uchun konservativ chegaralar
- C API: CPython obyekt tuzilishi C kengaytmalari uchun ochiq — tuzilishni erkin o'zgartirib bo'lmaydi
5. Amaliy xulosa
- Qaysi tilda bo'lmasin: obyektlarni bir xil maydonlar to'plami bilan, konstruktorda yarating — ulashilgan tuzilishdan foydalaning
- Ixtiyoriy kalitlar kerak bo'lsa — alohida lug'at/Map maydoni, obyektning o'zini lug'atga aylantirmang
- Python'da millionlab obyektlar uchun
__slots__, yanada ko'p bo'lsa — Java'dagi raw maydonlar kabi ustunli massivlar
6. Xulosa
- Java, V8 va Python bir g'oyani ishlatadi: nomlar tuzilishini ulashish, qiymatlarni ofset bo'yicha saqlash
- Java — qat'iy va kompilyatsiyada; V8 — avtomatik shape lar, ko'payib ketsa lug'at rejimi; Python — cheklangan ulashilgan kalitlar va ixtiyoriy
__slots__ __slots__qo'lda, chunki u xulqni o'zgartiradi — V8 shape lari va Python inline qiymatlari esa o'zgartirmaydi- Umumiy intizom: bir xil maydonlar, konstruktorda, ixtiyoriy kalitlar alohida lug'atda
Nimani mustahkamlaydi: 2.1–2.7-bo'limlar.
Xulosa
Bu darsda __slots__ va oddiy klass nusxalarining xotiradagi tuzilishini o'rgandik.
Eng muhim uch fikr:
Slot — obyektning o'z baytlaridagi ko'rsatkich.
__slots__ = ("x", "y")klassning__basicsize__ini 32 ga oshiradi vax,yqiymatlariga ko'rsatkichlarniid(obj)+16,+24da saqlaydi; ularnimember_descriptor(data deskriptor) o'qiydi va yozadi. Bir nusxa —32 + 8kbayt. Merosda ofsetlar kengayadi, ikki ota bir xil ofsetni band qilsa — "lay-out conflict". Python deskriptori xulqni takrorlay oladi, lekin tejashni emas.Python 3.13+ oddiy klasslari ham ixcham — lekin shartli. Atribut qiymatlari obyekt bilan birga inline massivda, nomlari klassda ulashilgan kalitlar jadvalida saqlanadi: 2 atribut
88 bayt.64 bayt), 30 va undan ortiq atribut bo'lsa yoki nusxalar turli nomlar olib kelsa (3.14 da ~17 nomdan keyin) esa nusxalar har biri to'liq lug'at oladi — hajm o'n barobargacha oshadi. Atributlar tartibi 3.14 da zarar bermadi.obj.__dict__/vars(obj)ga murojaat har nusxada lug'at yaratadi (+Slotlar faqat ko'rsatkichlarni tejaydi. Qiymatlar —
float, kattaint,str— baribir alohida obyektlar va ko'pincha obyektning o'zidan ko'p joy oladi. Millionlab yozuvda keyingi qadam —sys.internva ustunli saqlash (array, NumPy). Har qadamnitracemallocbilan o'lchang.
Keyingi darsda weakref ni o'rganamiz: obyektni tirik ushlab turmaydigan havolalar, WeakValueDictionary keshlari, finalize va __weakref__ sloti.
Izohlar · 0
Izoh yozish uchun kiring.