Python kursi11.9-dars: slots xotirani qanday tejaydi
Python kursi · Obyekt modeli va xotira

11.9-dars: __slots__ xotirani qanday tejaydi

26 daqiqa9/10-dars

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_descriptor qanday 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'rsatkich

Klass 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):

python
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 NULL bo'lsa (hali berilmagan yoki del) — 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

python
class A:  __slots__ = ("a",)      # __basicsize__ 24: a → +16
class B(A): __slots__ = ("b",)    # __basicsize__ 32: a → +16, b → +24

Avlod ota tuzilishini kengaytiradi — ota slotlari o'z joyida qoladi, shuning uchun ota metodlari avlod nusxasida ham ishlaydi.

"Lay-out conflict" sababi:

python
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__"    → +16

Tur 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_DICT

Mexanizm

slot = member_descriptor → id(obj) + ofset dagi ko'rsatkich
merosda ofsetlar kengayadi; ikki bo'sh bo'lmagan ota → lay-out conflict

4. Batafsil misollar

Misol 1 — Obyekt tuzilishini ko'rish

python
"""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:

text
=== 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 24

Nima 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

python
"""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:

text
=== 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 True

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

Misol 3 — Slotni Python'da takrorlab ko'rish

python
"""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:

text
=== 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 mumkin

Nima 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.

python
"""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:

text
=== 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

python
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)

python
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

python
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

python
class Nuqta(Koordinata, Rang): ...          # ❌ lay-out conflict

Aralashmalarda __slots__ = (), maydonlarni bitta otada yoki kompozitsiya bilan.

5. Slotlar yetmay qolganda obyektlarni ko'paytirishda davom etish

python
olchovlar = [SlotOlchov(...) for ...]       # ⚠️ 10 mln — baribir GB lab

Ustunli saqlash: array, NumPy, pandas (24-qism).

6. Slotli klassda __dict__ qo'shib, tejashni yo'qotish

python
__slots__ = ("x", "y", "__dict__")          # ⚠️ oddiy klassdek ~88 bayt

7. Ichki bayroq va ofsetlarga production kodda tayanish

python
if cls.__flags__ & (1 << 4): ...            # ❌ versiyaga bog'liq ichki tafsilot
ctypes.c_void_p.from_address(id(obj) + 16)  # ❌ xavfli, faqat o'rganish uchun

8. Avlodda __slots__ ni unutish

python
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_descriptor data deskriptor
  • 11.5-dars (o'tilgan): GC sarlavhasi
  • 11.8-dars (o'tilgan): tracemalloc bilan o'lchash
  • 11.10-dars: weakref va __weakref__ sloti
  • 12.4-dars: PyObject va tur tuzilmasi C darajasida
  • 24.1-dars: NumPy — ustunli, obyektsiz saqlash
  • 29.9-dars: xotira optimizatsiyasi

8. Eng yaxshi amaliyotlar

  1. Ko'p nusxali, maydonlari qat'iy klasslarda __slots__ (yoki dataclass(slots=True)).

  2. Obyektlarga ma'lumotdan kelgan ixtiyoriy nomlarni setattr qilmang — qo'shimcha maydonlar uchun bitta lug'at maydoni.

  3. vars(obj) / obj.__dict__ ni issiq yo'lda chaqirmang.

  4. Aralashmalarda __slots__ = ().

  5. Har avlodda __slots__ yozing.

  6. Tejashni tracemalloc bilan o'lchang — getsizeof farqni ko'rsatmaydi.

  7. Qiymat obyektlari xotirada ustunlik qilsa — ustunli saqlashga o'ting.

  8. Ichki bayroqlar, ofsetlar va ctypes — faqat o'rganish va tashxis uchun.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
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
  1. 32 — sarlavha 16 + 2 slot
  2. 16 — inline qiymatlar __basicsize__ ga kirmaydi
  3. 16
  4. member_descriptor
  5. False — slot bor, qiymat berilmagan
  6. {'z': 1} — avlodda __slots__ yo'q, __dict__ qaytdi
  7. 40 — ota slotlari + z
  8. 0 -1 — slotlida lug'at yo'q, oddiyda boshqariladigan
  9. False
  10. ValueError
  11. True — getsizeof inline qiymatlarni ko'rmaydi
  12. ab False True — satr bitta slot nomi sifatida olinadi

Vazifa 2: Xatolarni tuzating

python
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
python
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:

  1. __basicsize__, __dictoffset__, __weakrefoffset__ va bayroqlarni o'qib, 2.1-bo'limdagi kabi ASCII sxema chizsin
  2. MRO bo'ylab har slot qaysi klassdan kelganini va ofsetini ko'rsatsin (ofsetni ctypes yordamida nusxa yaratib aniqlang)
  3. Takrorlangan slot nomlarini (8.19-dars, meros qoidasi B) topib ogohlantirsin
  4. int, tuple, Exception, dataclass(slots=True) va o'z klasslaringizda sinab ko'ring

Vazifa 4: Ulashilgan kalitlar chegarasi

  1. Nusxalari 1, 2, ... 60 xil nomdan bittadan atribut oladigan klass uchun har nusxaning tracemalloc hajmini chizing
  2. Qaysi nusxadan boshlab hajm sakrashini aniqlang
  3. Klassga oldindan barcha nomlarni __init__ da None bilan berib, farqni ko'rsating
  4. Natijani CPython manba kodidagi SHARED_KEYS_MAX_SIZE bilan solishtiring

Vazifa 5: Avtomatik slotlar

@avto_slots klass dekoratorini yozing (10.10-dars):

  1. __init__ manba kodini ast bilan tahlil qilib, self.nom = ... ko'rinishidagi barcha nomlarni topsin (yoki 3.13+ dagi __static_attributes__ dan foydalansin)
  2. Shu nomlar bilan yangi slotli klass yaratsin (dataclass(slots=True) qanday qilishini eslang — 10.10-dars)
  3. property, klass atributlari va ota slotlari bilan to'qnashuvlarni hal qilsin
  4. Misol 4 dagi OddiyOlchov ga qo'llab, xotirani o'lchang

Vazifa 6: Obyektdan ustunlarga

UstunliJadval klassini yozing:

  1. Maydon turlarini (int, float, str, bool) qabul qilib, har biri uchun mos array yoki satrlar uchun lug'at kodlash (kategoriya) ishlatsin
  2. qosh(**maydonlar), jadval[i] (yengil ko'rinish obyekti qaytarsin), filtr(shart), len
  3. Ko'rinish obyekti slotli bo'lib, faqat jadval va indeksni saqlasin
  4. Misol 4 dagi 200 000 o'lchov bilan xotira va harorat > 30 filtri 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

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
  • double qiymatlar 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

javascript
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.x joyi 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

  1. Semantika o'zgaradi: slot yangi atribut qo'shishni taqiqlaydi, __dict__ va weakref ni olib tashlaydi, meros qoidalarini o'zgartiradi. Bu xulq o'zgarishi — optimallashtirish emas; uni interpretator o'z-o'zidan qila olmaydi
  2. 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
  3. 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
  4. C API: CPython obyekt tuzilishi C kengaytmalari uchun ochiq — tuzilishni erkin o'zgartirib bo'lmaydi

5. Amaliy xulosa

  1. Qaysi tilda bo'lmasin: obyektlarni bir xil maydonlar to'plami bilan, konstruktorda yarating — ulashilgan tuzilishdan foydalaning
  2. Ixtiyoriy kalitlar kerak bo'lsa — alohida lug'at/Map maydoni, obyektning o'zini lug'atga aylantirmang
  3. Python'da millionlab obyektlar uchun __slots__, yanada ko'p bo'lsa — Java'dagi raw maydonlar kabi ustunli massivlar

6. Xulosa

  1. Java, V8 va Python bir g'oyani ishlatadi: nomlar tuzilishini ulashish, qiymatlarni ofset bo'yicha saqlash
  2. Java — qat'iy va kompilyatsiyada; V8 — avtomatik shape lar, ko'payib ketsa lug'at rejimi; Python — cheklangan ulashilgan kalitlar va ixtiyoriy __slots__
  3. __slots__ qo'lda, chunki u xulqni o'zgartiradi — V8 shape lari va Python inline qiymatlari esa o'zgartirmaydi
  4. 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:

  1. Slot — obyektning o'z baytlaridagi ko'rsatkich. __slots__ = ("x", "y") klassning __basicsize__ ini 32 ga oshiradi va x, y qiymatlariga ko'rsatkichlarni id(obj)+16, +24 da saqlaydi; ularni member_descriptor (data deskriptor) o'qiydi va yozadi. Bir nusxa — 32 + 8k bayt. Merosda ofsetlar kengayadi, ikki ota bir xil ofsetni band qilsa — "lay-out conflict". Python deskriptori xulqni takrorlay oladi, lekin tejashni emas.

  2. 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. obj.__dict__ / vars(obj) ga murojaat har nusxada lug'at yaratadi (+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.

  3. Slotlar faqat ko'rsatkichlarni tejaydi. Qiymatlar — float, katta int, str — baribir alohida obyektlar va ko'pincha obyektning o'zidan ko'p joy oladi. Millionlab yozuvda keyingi qadam — sys.intern va ustunli saqlash (array, NumPy). Har qadamni tracemalloc bilan o'lchang.

Keyingi darsda weakref ni o'rganamiz: obyektni tirik ushlab turmaydigan havolalar, WeakValueDictionary keshlari, finalize va __weakref__ sloti.

Obyekt modeli va xotira · 9-dars yakunlandi

11.9-dars: slots xotirani qanday tejaydi

26 daqvaqt
0belgi
Keyingi dars: 11.10-dars: weakref
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0