11.8-dars: sys.getsizeof va haqiqiy hajm

>>> sys.getsizeof(kesh)
8_388_696          # ~8 MB — hech gap emas

sys.getsizeof(obj)            # baytlarda
sys.getsizeof(obj, standart)  # hajmni aniqlab bo'lmasa — standart qiymat

getsizeof(obj) = type(obj).__sizeof__(obj) + GC sarlavhasi (agar obyekt GC kuzatadigan turda bo'lsa)

list  = 56 + 8 × sig'im        (sig'im ≥ uzunlik)
tuple = 48 + 8 × uzunlik       (() → 48, (1,) → 56, (1, 2) → 64) — zaxirasiz
dict  = 64 (bo'sh), 1 elementdan 184, keyin sakrab o'sadi
set   = 216 (bo'sh), keyin sakrab o'sadi

def chuqur_hajm(obj, korilgan):
    if id(obj) in korilgan:
        return 0
    korilgan.add(id(obj))
    hajm = sys.getsizeof(obj)
    ... ichidagi obyektlar uchun rekursiya

tracemalloc.start()
malumot = yukla()
joriy, eng_yuqori = tracemalloc.get_traced_memory()
tracemalloc.stop()

sys.getsizeof(obj)        → sayoz: obyektning o'zi (+ GC sarlavhasi)
obj.__sizeof__()          → GC sarlavhasisiz
chuqur_hajm(obj)          → graf bo'yicha taxmin (ko'rilganlar, o'lmaslarsiz)
tracemalloc               → haqiqiy ajratilgan xotira

int 28 (+4 har 30 bit)   float 24   bytes 33+n
str: ASCII 41+n, latin-1 57+n, UCS-2 58+2n, UCS-4 60+4n
list 56 + 8×sig'im   tuple 48 + 8×n   dict 64 / 184+   set 216+
range 48   generator ~200

konteyner getsizeof → faqat ko'rsatkichlar
bitta emoji → butun satr 4 bayt/belgi
obyekt nusxalari → tracemalloc bilan

"""int raqamlari, satrning to'rt ko'rinishi, konteynerlar va zaxira joy, range/generator, GC sarlavhasi."""

import sys

g = sys.getsizeof

print("=== 1. int: har 30 bitga 4 bayt ===")
for n in [0, 1, 2**30 - 1, 2**30, 2**60 - 1, 2**60, 10**100]:
    print(f"  {n.bit_length():>3} bit  → {g(n)} bayt")

print("\n=== 2. str: eng katta belgi hamma belgi hajmini belgilaydi ===")
namunalar = {
    "ASCII": "Toshkent",
    "latin-1": "Montréal",
    "UCS-2": "Qarşı ş",
    "UCS-4": "Salom 🙂",
}
for tur, s in namunalar.items():
    print(f"  {tur:8} {s!r:12} uzunlik {len(s)}, hajm {g(s)}, bo'sh satrga nisbatan +{g(s) - g('')}")
matn = "a" * 1000
print(f"  1000 ta 'a': {g(matn)}   + bitta emoji: {g(matn + '🙂')}   ({g(matn + '🙂') / g(matn):.1f} barobar)")

print("\n=== 3. Konteynerlar: sig'im va zaxira ===")
royxat = []
oldingi = g(royxat)
qadamlar = [f"0→{oldingi}"]
for i in range(1, 33):
    royxat.append(i)
    if g(royxat) != oldingi:
        oldingi = g(royxat)
        qadamlar.append(f"{i}→{oldingi}")
print(f"  append bilan o'sish (uzunlik→bayt): {', '.join(qadamlar)}")
oniga = []
for i in range(10):
    oniga.append(i)
print(f"  [0] * 10: {g([0] * 10)},  list(range(10)): {g(list(range(10)))},  10 marta append: {g(oniga)}")
print(f"  tuple: () {g(())}, (1,) {g((1,))}, (1, 2) {g((1, 2))}")
print(f"  dict: {{}} {g({})}, 1 ta {g({'a': 1})}, 5 ta {g(dict.fromkeys(range(5)))}, 6 ta {g(dict.fromkeys(range(6)))}")
print(f"  set: set() {g(set())}, 4 ta {g(set(range(4)))}, 5 ta {g(set(range(5)))}")

print("\n=== 4. Elementlar hisobga kirmaydi ===")
kichik = [1, 2, 3]
katta = ["x" * 1_000_000, "y" * 1_000_000, "z" * 1_000_000]
print(f"  [1, 2, 3]: {g(kichik)},  3 ta millionlik satr ro'yxati: {g(katta)}")
print(f"  range(10): {g(range(10))},  range(10**12): {g(range(10**12))}")
print(f"  generator 10 ta: {g(x for x in range(10))},  10**9 ta: {g(x for x in range(10**9))}")

print("\n=== 5. GC sarlavhasi va __sizeof__ ===")
for obj in [[], {}, (1, 2), 12345, "salom"]:
    print(f"  {type(obj).__name__:6} getsizeof {g(obj):>3}, __sizeof__ {obj.__sizeof__():>3}, farq {g(obj) - obj.__sizeof__()}")


class Tasvir:
    """C kengaytma kabi: ma'lumotni o'zi boshqaradi va hajmini o'zi aytadi."""

    def __init__(self, en, boy):
        self._piksellar = bytearray(en * boy * 4)

    def __sizeof__(self):
        return object.__sizeof__(self) + sys.getsizeof(self._piksellar)


print(f"  o'z __sizeof__: Tasvir(100, 100) → {g(Tasvir(100, 100))} bayt")

=== 1. int: har 30 bitga 4 bayt ===
    0 bit  → 28 bayt
    1 bit  → 28 bayt
   30 bit  → 28 bayt
   31 bit  → 32 bayt
   60 bit  → 32 bayt
   61 bit  → 36 bayt
  333 bit  → 72 bayt

=== 2. str: eng katta belgi hamma belgi hajmini belgilaydi ===
  ASCII    'Toshkent'   uzunlik 8, hajm 49, bo'sh satrga nisbatan +8
  latin-1  'Montréal'   uzunlik 8, hajm 65, bo'sh satrga nisbatan +24
  UCS-2    'Qarşı ş'    uzunlik 7, hajm 72, bo'sh satrga nisbatan +31
  UCS-4    'Salom 🙂'    uzunlik 7, hajm 88, bo'sh satrga nisbatan +47
  1000 ta 'a': 1041   + bitta emoji: 4064   (3.9 barobar)

=== 3. Konteynerlar: sig'im va zaxira ===
  append bilan o'sish (uzunlik→bayt): 0→56, 1→88, 5→120, 9→184, 17→248, 25→312
  [0] * 10: 136,  list(range(10)): 136,  10 marta append: 184
  tuple: () 48, (1,) 56, (1, 2) 64
  dict: {} 64, 1 ta 184, 5 ta 224, 6 ta 352
  set: set() 216, 4 ta 216, 5 ta 728

=== 4. Elementlar hisobga kirmaydi ===
  [1, 2, 3]: 88,  3 ta millionlik satr ro'yxati: 80
  range(10): 48,  range(10**12): 48
  generator 10 ta: 200,  10**9 ta: 200

=== 5. GC sarlavhasi va __sizeof__ ===
  list   getsizeof  56, __sizeof__  40, farq 16
  dict   getsizeof  64, __sizeof__  48, farq 16
  tuple  getsizeof  64, __sizeof__  48, farq 16
  int    getsizeof  28, __sizeof__  28, farq 0
  str    getsizeof  46, __sizeof__  46, farq 0
  o'z __sizeof__: Tasvir(100, 100) → 40105 bayt

"""Rekursiv chuqur hajm: ulashilgan obyektlar, sikllar, o'lmas obyektlar; natijani tracemalloc bilan solishtirish."""

import sys
import tracemalloc
import types

O_TKAZIB_YUBORISH = (type, types.ModuleType, types.FunctionType, types.BuiltinFunctionType)


def chuqur_hajm(obj, korilgan=None):
    if korilgan is None:
        korilgan = set()
    if id(obj) in korilgan or isinstance(obj, O_TKAZIB_YUBORISH) or sys._is_immortal(obj):
        return 0
    korilgan.add(id(obj))
    hajm = sys.getsizeof(obj)
    if isinstance(obj, (str, bytes, bytearray, int, float, complex)):
        return hajm
    if isinstance(obj, dict):
        hajm += sum(chuqur_hajm(k, korilgan) + chuqur_hajm(v, korilgan) for k, v in obj.items())
    elif isinstance(obj, (list, tuple, set, frozenset)):
        hajm += sum(chuqur_hajm(el, korilgan) for el in obj)
    for nom in getattr(type(obj), "__slots__", ()):
        if hasattr(obj, nom):
            hajm += chuqur_hajm(getattr(obj, nom), korilgan)
    if hasattr(obj, "__dict__"):
        hajm += chuqur_hajm(vars(obj), korilgan)
    return hajm


print("=== 1. Sayoz va chuqur ===")
satr = "".join(["a"] * 1000)
bir_xil = [satr] * 1000
turli = ["".join(["a"] * 1000) for _ in range(1000)]
print(f"  getsizeof:   bir xil satrlar {sys.getsizeof(bir_xil):>9,}   turli satrlar {sys.getsizeof(turli):>9,}")
print(f"  chuqur hajm: bir xil satrlar {chuqur_hajm(bir_xil):>9,}   turli satrlar {chuqur_hajm(turli):>9,}")

print("\n=== 2. Sikl va o'lmas obyektlar ===")
tugun = {"nom": "".join(["ild", "iz"]), "bolalar": []}
tugun["bolalar"].append(tugun)
print(f"  o'ziga havola qilgan lug'at: {chuqur_hajm(tugun)} bayt (cheksiz rekursiya yo'q)")
sonlar = list(range(200))
print(f"  0..199 ro'yxati: getsizeof {sys.getsizeof(sonlar)}, chuqur {chuqur_hajm(sonlar)} — kichik sonlar umumiy, hisoblanmadi")
katta_sonlar = [10**6 + i for i in range(200)]
print(f"  10**6.. ro'yxati: getsizeof {sys.getsizeof(katta_sonlar)}, chuqur {chuqur_hajm(katta_sonlar)} = {sys.getsizeof(katta_sonlar)} + 200 × {sys.getsizeof(10**6)}")

print("\n=== 3. Chuqur hajm va tracemalloc ===")


def sessiyalar_yarat(n):
    return {
        f"sess-{i:06d}": {
            "foydalanuvchi": f"user{i}@wisar.uz",
            "rollar": ["o'quvchi", "".join(["muallif", str(i % 3)])],
            "savat": [{"id": 10_000 + j, "narx": 49_900.0 + j} for j in range(i % 4)],
        }
        for i in range(n)
    }


tracemalloc.start()
kesh = sessiyalar_yarat(20_000)
haqiqiy, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
taxmin = chuqur_hajm(kesh)
print(f"  getsizeof(kesh): {sys.getsizeof(kesh) / 1e6:6.2f} MB")
print(f"  chuqur hajm:     {taxmin / 1e6:6.2f} MB")
print(f"  tracemalloc:     {haqiqiy / 1e6:6.2f} MB")
print(f"  getsizeof haqiqiyning {sys.getsizeof(kesh) / haqiqiy:.0%} ini ko'rsatdi; chuqur hajm {taxmin / haqiqiy:.0%} ini")

=== 1. Sayoz va chuqur ===
  getsizeof:   bir xil satrlar     8,056   turli satrlar     8,856
  chuqur hajm: bir xil satrlar     9,097   turli satrlar 1,049,856

=== 2. Sikl va o'lmas obyektlar ===
  o'ziga havola qilgan lug'at: 366 bayt (cheksiz rekursiya yo'q)
  0..199 ro'yxati: getsizeof 1656, chuqur 1656 — kichik sonlar umumiy, hisoblanmadi
  10**6.. ro'yxati: getsizeof 1656, chuqur 7256 = 1656 + 200 × 28

=== 3. Chuqur hajm va tracemalloc ===
  getsizeof(kesh):   0.42 MB
  chuqur hajm:      17.40 MB
  tracemalloc:      17.52 MB
  getsizeof haqiqiyning 2% ini ko'rsatdi; chuqur hajm 99% ini

"""100 000 nusxa: oddiy klass, dataclass, slots, namedtuple, tuple, dict; float ro'yxati va array.array."""

import array
import gc
import sys
import tracemalloc
from collections import namedtuple
from dataclasses import dataclass


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


@dataclass
class NuqtaDC:
    x: float
    y: float


class NuqtaSlots:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y


NuqtaNT = namedtuple("NuqtaNT", "x y")
N = 100_000
X, Y = 1.5, 2.5


def bir_nusxa(yasovchi):
    gc.collect()
    tracemalloc.start()
    nusxalar = [yasovchi() for _ in range(N)]
    jami, _ = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return sys.getsizeof(nusxalar[0]), (jami - sys.getsizeof(nusxalar)) / N


print("=== 1. Bitta nusxa: getsizeof va haqiqiy ===")
print(f"  {'tur':12} {'getsizeof':>9} {'tracemalloc':>12}")
for nom, yasovchi in [("klass", lambda: Nuqta(X, Y)), ("dataclass", lambda: NuqtaDC(X, Y)),
                      ("__slots__", lambda: NuqtaSlots(X, Y)), ("namedtuple", lambda: NuqtaNT(X, Y)),
                      ("tuple", lambda: tuple([X, Y])), ("dict", lambda: {"x": X, "y": Y})]:
    sayoz, haqiqiy = bir_nusxa(yasovchi)
    print(f"  {nom:12} {sayoz:>9} {haqiqiy:>12.0f}")

print("\n=== 2. __dict__ so'ralganda nima bo'ladi ===")
nuqtalar = [Nuqta(X, Y) for _ in range(N)]
gc.collect()
tracemalloc.start()
for n in nuqtalar:
    n.__dict__
qoshimcha, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"  {N:,} nusxada __dict__ ga murojaat: +{qoshimcha / N:.0f} bayt har biriga, getsizeof(nusxa) esa hamon {sys.getsizeof(nuqtalar[0])}")
del nuqtalar

print("\n=== 3. float ro'yxati va array.array ===")
gc.collect()
tracemalloc.start()
royxat = [float(i) for i in range(N)]
royxat_haqiqiy, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
tracemalloc.start()
massiv = array.array("d", (float(i) for i in range(N)))
massiv_haqiqiy, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"  list[float]:      getsizeof {sys.getsizeof(royxat) / 1e6:.2f} MB, haqiqiy {royxat_haqiqiy / 1e6:.2f} MB")
print(f"  array('d'):       getsizeof {sys.getsizeof(massiv) / 1e6:.2f} MB, haqiqiy {massiv_haqiqiy / 1e6:.2f} MB")
print(f"  getsizeof bo'yicha ular deyarli teng, haqiqatda ro'yxat {royxat_haqiqiy / massiv_haqiqiy:.1f} barobar katta")
print(f"  sabab: ro'yxatda 8 baytli ko'rsatkich + har biri {sys.getsizeof(1.5)} baytli float obyekti; massivda 8 baytli raw qiymat")

=== 1. Bitta nusxa: getsizeof va haqiqiy ===
  tur          getsizeof  tracemalloc
  klass               48           88
  dataclass           48           88
  __slots__           48           48
  namedtuple          64           72
  tuple               64           64
  dict               184          184

=== 2. __dict__ so'ralganda nima bo'ladi ===
  100,000 nusxada __dict__ ga murojaat: +64 bayt har biriga, getsizeof(nusxa) esa hamon 48

=== 3. float ro'yxati va array.array ===
  list[float]:      getsizeof 0.80 MB, haqiqiy 3.20 MB
  array('d'):       getsizeof 0.82 MB, haqiqiy 0.82 MB
  getsizeof bo'yicha ular deyarli teng, haqiqatda ro'yxat 3.9 barobar katta
  sabab: ro'yxatda 8 baytli ko'rsatkich + har biri 24 baytli float obyekti; massivda 8 baytli raw qiymat

"""OrderedDict asosidagi LRU kesh: byudjet baytlarda, har yozuv chuqur hajm bilan; taxmin va tracemalloc solishtiriladi."""

import sys
import tracemalloc
from collections import OrderedDict


def chuqur_hajm(obj, korilgan=None, internlarni_sana=True):
    if korilgan is None:
        korilgan = set()
    if id(obj) in korilgan or sys._is_immortal(obj):
        return 0
    if not internlarni_sana and isinstance(obj, str) and sys._is_interned(obj):
        return 0
    korilgan.add(id(obj))
    hajm = sys.getsizeof(obj)
    ichki = lambda x: chuqur_hajm(x, korilgan, internlarni_sana)
    if isinstance(obj, dict):
        hajm += sum(ichki(k) + ichki(v) for k, v in obj.items())
    elif isinstance(obj, (list, tuple, set)):
        hajm += sum(ichki(el) for el in obj)
    return hajm


class HajmliKesh:
    def __init__(self, byudjet_bayt):
        self.byudjet = byudjet_bayt
        self._malumot = OrderedDict()
        self._hajmlar = {}
        self.jami = 0
        self.chiqarilgan = 0

    def qoy(self, kalit, qiymat):
        if kalit in self._malumot:
            self._olib_tashla(kalit)
        hajm = chuqur_hajm(kalit) + chuqur_hajm(qiymat)
        if hajm > self.byudjet:
            raise ValueError(f"{kalit!r}: bitta yozuv ({hajm} bayt) byudjetdan katta")
        self._malumot[kalit] = qiymat
        self._hajmlar[kalit] = hajm
        self.jami += hajm
        while self.jami > self.byudjet:
            eski = next(iter(self._malumot))
            self._olib_tashla(eski)
            self.chiqarilgan += 1

    def ol(self, kalit):
        self._malumot.move_to_end(kalit)
        return self._malumot[kalit]

    def _olib_tashla(self, kalit):
        del self._malumot[kalit]
        self.jami -= self._hajmlar.pop(kalit)

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


def sessiya(i):
    return {
        "foydalanuvchi": f"user{i}@wisar.uz",
        "tarix": [f"/kurs/python/{j}" for j in range(i % 20)],
        "sozlamalar": {"til": "".join(["u", "z"]), "tema": "".join(["qorong'", "i"])},
    }


print("=== 1. Byudjet 2 MB, 10 000 sessiya ===")
tracemalloc.start()
kesh = HajmliKesh(byudjet_bayt=2_000_000)
for i in range(10_000):
    kesh.qoy(f"sess-{i:06d}", sessiya(i))
haqiqiy, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"  keshda: {len(kesh):,} yozuv, chiqarilgan: {kesh.chiqarilgan:,}")
print(f"  taxminiy jami: {kesh.jami / 1e6:.2f} MB (byudjet {kesh.byudjet / 1e6:.2f} MB)")
print(f"  tracemalloc (kesh + ichki jadvallar): {haqiqiy / 1e6:.2f} MB")
print(f"  taxmin haqiqiyning {kesh.jami / haqiqiy:.0%} i — taxmin haqiqiydan KATTA chiqdi")

print("\n=== 2. Nega katta: ulashilgan satrlar har yozuvda qayta sanaldi ===")
kalit_nomlari = ["foydalanuvchi", "tarix", "sozlamalar", "til", "tema"]
print(f"  lug'at kalitlari kod konstantalari — interned: {all(sys._is_interned(k) for k in kalit_nomlari)}")
bir_yozuvda = sum(sys.getsizeof(k) for k in kalit_nomlari)
print(f"  ular har yozuvda {bir_yozuvda} bayt deb sanalgan, aslida hamma yozuv uchun bitta nusxa: "
      f"{bir_yozuvda * len(kesh) / 1e6:.2f} MB ortiqcha")
tuzatilgan = sum(chuqur_hajm(k, internlarni_sana=False) + chuqur_hajm(v, internlarni_sana=False)
                 for k, v in kesh._malumot.items())
jadvallar = sys.getsizeof(kesh._malumot) + sys.getsizeof(kesh._hajmlar)
print(f"  internlarsiz taxmin: {tuzatilgan / 1e6:.2f} MB + OrderedDict va _hajmlar jadvallari {jadvallar / 1e6:.2f} MB"
      f" = {(tuzatilgan + jadvallar) / 1e6:.2f} MB, haqiqiyning {(tuzatilgan + jadvallar) / haqiqiy:.0%} i")

print("\n=== 3. Haddan katta yozuv ===")
bir_xil = {"tarix": ["x" * 1000 for _ in range(3000)]}
turli = {"tarix": ["x" * 1000 + str(i) for i in range(3000)]}
print(f"  'x' * 1000 — oldindan hisoblangan bitta konstanta, 3000 havola: {chuqur_hajm(bir_xil) / 1e6:.2f} MB")
try:
    kesh.qoy("ulkan", turli)
except ValueError as xato:
    print(f"  ValueError: {xato}")

=== 1. Byudjet 2 MB, 10 000 sessiya ===
  keshda: 1,341 yozuv, chiqarilgan: 8,659
  taxminiy jami: 2.00 MB (byudjet 2.00 MB)
  tracemalloc (kesh + ichki jadvallar): 1.90 MB
  taxmin haqiqiyning 105% i — taxmin haqiqiydan KATTA chiqdi

=== 2. Nega katta: ulashilgan satrlar har yozuvda qayta sanaldi ===
  lug'at kalitlari kod konstantalari — interned: True
  ular har yozuvda 240 bayt deb sanalgan, aslida hamma yozuv uchun bitta nusxa: 0.32 MB ortiqcha
  internlarsiz taxmin: 1.68 MB + OrderedDict va _hajmlar jadvallari 0.18 MB = 1.86 MB, haqiqiyning 98% i

=== 3. Haddan katta yozuv ===
  'x' * 1000 — oldindan hisoblangan bitta konstanta, 3000 havola: 0.03 MB
  ValueError: 'ulkan': bitta yozuv (3160206 bayt) byudjetdan katta

if sys.getsizeof(kesh) > LIMIT: tozala()     # ❌ elementlar hisoblanmaydi

def hajm(o):
    return sys.getsizeof(o) + sum(hajm(x) for x in o)   # ❌ sikl — RecursionError, ulashilganlar ikki marta

hajm += chuqur_hajm(type(obj))     # ❌ butun tur tizimi, modullar hisobga kiradi

sys.getsizeof(Nuqta(1, 2)) == sys.getsizeof(NuqtaSlots(1, 2))   # 48 == 48 — "farqi yo'q" ❌

qiymatlar = [float(x) for x in oqim]          # ⚠️ har element ~32 bayt
qiymatlar = array.array("d", map(float, oqim)) # ✅ 8 bayt; yoki NumPy (24-qism)

hisobot = "\n".join(qatorlar) + " ✅"   # ⚠️ butun hisobot 4 bayt/belgi bo'ldi

tracemalloc.start()        # ❌ butun servis sekinlashadi va qo'shimcha xotira oladi

def __sizeof__(self):
    return 16 + object.__sizeof__(self) + ...  # ❌ getsizeof uni o'zi qo'shadi

import sys
g = sys.getsizeof
1.  print(g([1, 2, 3]) == g(["x" * 1000, "y", "z"]))
2.  print(g(range(10)) == g(range(10**9)))
3.  print(g("abc") - g("ab"))
4.  print(g("şşş") - g("şş"))
5.  print(g(2**30) - g(2**30 - 1))
6.  royxat = []
    royxat.append(1)
    print(g(royxat) - g([]))
7.  print(g((1, 2, 3)) < g([1, 2, 3]))
8.  d = {}
    bosh = g(d)
    d["a"] = 1
    print(g(d) > bosh)
9.  class K:
        def __sizeof__(self):
            return 100
    print(g(K()) > 100)
10. print(g(x for x in range(10)) == g(x for x in range(10**6)))
11. print(g(True) == g(1))
12. a = [0] * 100
    b = a[:50]
    print(g(b) < g(a))

1.  def kesh_hajmi(kesh):
        return sys.getsizeof(kesh)

2.  def chuqur(o):
        jami = sys.getsizeof(o)
        if isinstance(o, (list, dict)):
            for x in (o.values() if isinstance(o, dict) else o):
                jami += chuqur(x)
        return jami

3.  def eng_yengil(yasovchilar):
        return min(yasovchilar, key=lambda f: sys.getsizeof(f()))

4.  class Rasm:
        def __init__(self, data): self.data = data
        def __sizeof__(self): return sys.getsizeof(self) + len(self.data)

5.  tracemalloc.start()
    malumot = yukla()
    print(tracemalloc.get_traced_memory())