Python kursi11.1-dars: Pythonda hamma narsa obyekt
Python kursi · Obyekt modeli va xotira

11.1-dars: Pythonda hamma narsa obyekt

26 daqiqa1/10-dars

11-QISM — OBYEKT MODELI VA XOTIRA · 1-dars


1. Kirish va motivatsiya

Kursning uchinchi bosqichi — "Python ichidan". Birinchi ikki bosqichda tilni ishlatishni o'rgandik. Endi interpretator ichiga kiramiz: obyektlar xotirada qanday yashaydi, qachon o'ladi, qancha joy egallaydi.

10.15-darsda ma'lumot modelini ko'rdik: har obyektning identifikatsiyasi, turi va qiymati bor. Endi shu obyektlarning xotiradagi ko'rinishini ko'ramiz. Mana real xato — tahlil xizmatidan:

python
kesh = {}

def ishlov(sorov):
    kalit = id(sorov)                   # "har so'rov noyob obyekt — id ham noyob"
    if kalit in kesh:
        return kesh[kalit]
    natija = ogir_hisob(sorov)
    kesh[kalit] = natija
    return natija

for qator in fayl:
    javob = ishlov(Sorov.parse(qator))

Bir necha minglab qatordan keyin mijozlar boshqa odamlarning hisobotlarini ola boshladi. Sababi: har Sorov obyekti ishlovdan keyin o'ladi, xotira bo'shaydi va keyingi Sorov aynan o'sha manzilga joylashadi. CPython'da id() — xotira manzili. Yangi obyekt eski obyektning id sini "meros" oladi va keshdan birovning natijasi qaytadi.

Python'dagi har narsa — son, satr, funksiya, klass, modul, kod, freym — xotiradagi obyekt, nomlar esa ularga havolalar. Obyektning tuzilishi, id nima ekanligi va obyekt qachon yo'q bo'lishini bilmasangiz, bunday xatolar sirli ko'rinadi.

Bu darsda:

  • Nom va obyekt: nomlar qayerda yashaydi, obyektlar qayerda
  • PyObject sarlavhasi: havolalar soni va tur ko'rsatkichi
  • id() — CPython'da manzil, noyobligi faqat obyekt yashagan paytda
  • Obyekt turlari: funksiya, kod, freym, modul, hujayra — hammasi obyekt
  • O'lmas (immortal) obyektlar — Python 3.12+
  • Xotira ajratish: pymalloc va bo'sh ro'yxatlar haqida qisqacha

11-qismning qolgan darslari: id/is/== 11.2-bob, havola semantikasi 11.3-bob, havolalar hisobi 11.4-bob, axlat yig'uvchi 11.5-bob, o'zgaruvchan standart argument 11.6-bob, interning 11.7-bob, haqiqiy hajm 11.8-bob, __slots__ 11.9-bob, weakref 11.10-bob.


2. Nazariya — chuqur tushuntirish

2.1. Nom va obyekt

python
narx = 12_000

Bu qator ikki narsa qiladi:

  1. Xotirada (heap'da) butun son obyekti yaratiladi (yoki mavjudi olinadi)
  2. Joriy nomlar maydonida narx nomi shu obyektga bog'lanadi
Tushuncha Qayerda Tabiati
Obyekt Heap Tur, qiymat, havolalar soni bor
Nom Nomlar maydoni Obyektga havola; o'zi obyekt emas

Nomlar maydonlari:

Maydon Tuzilma
Modul (global) dict — globals(), modul.__dict__
Klass dict ga o'xshash mappingproxy — vars(Klass)
Nusxa dict — obj.__dict__ (yoki __slots__)
Funksiya lokal o'zgaruvchilari Freymdagi tez massiv (LOAD_FAST), lug'at emas; locals()/frame.f_locals — ko'rinish (3.13+ da FrameLocalsProxy, PEP 667)

Oqibatlari:

  • a = b — nusxa emas, ikkinchi havola (11.3-dars)
  • del a — nomni o'chiradi; obyekt boshqa havola qolmaganda o'ladi (11.4-dars)
  • Turni o'zgaruvchi emas, obyekt saqlaydi: x = 5; x = "salom" — nom boshqa obyektga bog'landi

2.2. PyObject sarlavhasi

CPython'da har obyekt C tuzilmasi bilan boshlanadi (64-bitli, GIL li oddiy yig'ma):

c
typedef struct {
    Py_ssize_t    ob_refcnt;     // 8 bayt: havolalar soni
    PyTypeObject *ob_type;       // 8 bayt: turga ko'rsatkich
} PyObject;                      // jami 16 bayt

typedef struct {
    PyObject      ob_base;
    Py_ssize_t    ob_size;       // 8 bayt: elementlar soni
} PyVarObject;                   // o'zgaruvchan uzunlikdagi obyektlar: tuple, bytes, ...
Obyekt Sarlavhadan keyin
object() Hech narsa — sys.getsizeof(object()) → 16
float 8 baytlik double → 24
tuple ob_size, xesh keshi 3.14-bob, elementlarga ko'rsatkichlar — ichida
list ob_size, alohida massivga ko'rsatkich va sig'im — o'sishi uchun
int Kattalik belgisi va 30 bitli "raqamlar" massivi — ixtiyoriy aniqlik
str Uzunlik, xesh, belgi turi (1/2/4 bayt), keyin belgilar

Uch muhim xulosa:

  1. ob_type — tur obyektning o'zida. Nomda emas. Shuning uchun type(x) har doim aniq, maxsus metodlar esa turdan qidiriladi (10.15-dars)
  2. ob_refcnt — har havola uni oshiradi. Nomga bog'lash, ro'yxatga qo'shish, argument sifatida uzatish (11.4-dars)
  3. Eng kichik obyekt ham 16 bayt. Million object() — kamida 16 MB, ro'yxatdagi ko'rsatkichlarsiz

Erkin ipli yig'mada (python3.14t, GIL siz) sarlavha kattaroq: iplar orasida xavfsiz sanash uchun qo'shimcha maydonlar bor.

2.3. id() — manzil va uning noyobligi

CPython'da id(x) — obyektning xotira manzili. CPython obyektlarni ko'chirmaydi, shuning uchun id obyekt yashagan paytda o'zgarmaydi.

Lekin:

  • Noyoblik faqat bir vaqtda yashayotgan obyektlar orasida. Obyekt o'lgach, uning manzili qayta ishlatiladi — yangi obyekt xuddi shu id ni oladi
  • id([]) == id([]) ko'pincha True: birinchi ro'yxat taqqoslashdan oldin o'ladi, ikkinchisi o'sha joyga tushadi. [] is [] esa False — ikkalasi bir vaqtda tirik
  • PyPy va boshqa implementatsiyalarda id manzil emas (ular obyektlarni ko'chiradi) — til faqat "noyob butun son" deb va'da qiladi

Obyektni kalit sifatida saqlash kerak bo'lsa:

  • obyektning o'zini (xeshlanadigan bo'lsa)
  • id + obyektni tirik ushlab turish ({id(o): o})
  • weakref.WeakKeyDictionary yoki WeakValueDictionary (11.10-dars)

2.4. Hamma narsa obyekt

Narsa Tur Ichida nima
5, "a", None int, str, NoneType Qiymat
Funksiya function __code__, __globals__, __defaults__, __closure__
Kod code Bytecode, konstantalar, nomlar (12-qism)
Freym frame Bajarilayotgan kod, lokal o'zgaruvchilar, oldingi freym
Modul module __dict__ — global nomlar maydoni
Klass type __dict__, __mro__, __bases__
Bog'langan metod method __func__, __self__
Hujayra cell cell_contents (10.12-dars)
Traceback traceback Freym, qator, keyingisi
..., NotImplemented ellipsis, NotImplementedType Yagona nusxalar

Obyekt bo'lgani uchun ularning barchasi:

  • nomga bog'lanadi, argument sifatida uzatiladi, ro'yxatga solinadi
  • type(), id(), sys.getsizeof() ga ega
  • havolalar soniga ega va o'lishi mumkin

2.5. O'lmas obyektlar (Python 3.12+)

PEP 683 bilan ba'zi obyektlar o'lmas qilindi:

  • None, True, False, ..., NotImplemented
  • Kichik butun sonlar (-5 dan 256 gacha)
  • Interpretator ichidagi ko'plab satrlar va tur obyektlari

Ularning havolalar soni oshmaydi va kamaymaydi — maxsus katta qiymatda turadi. Nega:

  • Tezlik va keshlar: har None ishlatilganda schyotchikka yozish CPU keshini "iflos qiladi"
  • Iplar va jarayonlar: fork dan keyin xotira sahifalarini nusxalash (copy-on-write) o'lmas obyektlarga tegmaydi
  • Erkin ipli yig'ma uchun asos

sys.getrefcount(None) endi haqiqiy son emas, sys._is_immortal(x) (3.14, ichki funksiya) esa tekshiradi.

2.6. Xotira ajratish qisqacha

  • 512 baytgacha kichik obyektlar uchun CPython o'zining pymalloc ajratuvchisidan foydalanadi: xotirani katta bloklarda oladi va bir xil o'lchamdagi bo'laklarga bo'ladi — tizim malloc iga qaraganda tez va kam parchalanadi
  • Kattaroq obyektlar — tizim ajratuvchisi
  • Ba'zi turlar uchun bo'sh ro'yxatlar (freelist) bor: o'lgan obyektning xotirasi darhol qayta ishlatiladi — shuning uchun id lar tez-tez takrorlanadi
  • Bo'shatilgan xotira har doim ham operatsion tizimga qaytmaydi — jarayon hajmi ko'pincha kamaymaydi (29-qism, xotira optimizatsiyasi)

3. Tez ma'lumotnoma

Nom va obyekt

narx = 12_000   → obyekt heap'da, "narx" nomlar maydonida
a = b           → ikkinchi havola, nusxa emas
del a           → nom o'chadi; obyekt — havola qolmasa
globals()       → modul lug'ati      locals()/f_locals → freym ko'rinishi

Sarlavha (64-bit, GIL li yig'ma)

ob_refcnt  8 bayt   havolalar soni
ob_type    8 bayt   tur ko'rsatkichi
ob_size    8 bayt   (o'zgaruvchan uzunlikli obyektlarda)
sys.getsizeof(object()) == 16

id

CPython: id(x) == manzil        obyekt ko'chmaydi
noyob — faqat bir vaqtda tirik obyektlar orasida
id([]) == id([]) → ko'pincha True     [] is [] → False

O'lmas obyektlar (3.12+)

None, True, False, ..., NotImplemented, -5..256
havolalar soni o'zgarmaydi      sys._is_immortal(x)  (3.14)

4. Batafsil misollar

Misol 1 — Nomlar maydonlari va havolalar

python
"""Nom — havola; modul, klass, nusxa va funksiya nomlar maydonlari; del nomni o'chiradi."""

import inspect
import sys


class Mahsulot:
    soliq = 12

    def __init__(self, nom, narx):
        self.nom, self.narx = nom, narx


print("=== 1. Bitta obyekt — bir nechta nom ===")
savat = ["non", "sut"]
buyurtma = savat
print(f"  savat is buyurtma: {savat is buyurtma}, id bir xil: {id(savat) == id(buyurtma)}")
buyurtma.append("tuxum")
print(f"  buyurtma ga qo'shildi → savat: {savat}")

print("\n=== 2. Nomlar maydonlari ===")
m = Mahsulot("olma", 12_000)
print(f"  modul:  'savat' in globals(): {'savat' in globals()}, turi {type(globals()).__name__}")
print(f"  klass:  vars(Mahsulot) turi {type(vars(Mahsulot)).__name__}, 'soliq' bor: {'soliq' in vars(Mahsulot)}")
print(f"  nusxa:  vars(m) = {vars(m)}")


def hisobla(a, b):
    yigindi = a + b
    freym = inspect.currentframe()
    return type(freym.f_locals).__name__, sorted(freym.f_locals), freym.f_code.co_varnames


turi, nomlar, varnames = hisobla(2, 3)
print(f"  funksiya: f_locals turi {turi}, nomlar {nomlar}")
print(f"            kod obyektidagi lokal nomlar: {varnames}")

print("\n=== 3. Nom tur saqlamaydi — obyekt saqlaydi ===")
x = 42
print(f"  x = 42      → type {type(x).__name__}, id {id(x) == id(42)} (42 o'lmas kichik son)")
x = "salom"
print(f"  x = 'salom' → type {type(x).__name__}")
x = Mahsulot
print(f"  x = Mahsulot → type {type(x).__name__}, x('nok', 9).nom = {x('nok', 9).nom!r}")

print("\n=== 4. del nomni o'chiradi, obyektni emas ===")
royxat = [1, 2, 3]
ikkinchi = royxat
del royxat
print(f"  del royxat → 'royxat' in globals(): {'royxat' in globals()}, ikkinchi hali tirik: {ikkinchi}")
try:
    print(royxat)
except NameError as e:
    print(f"  NameError: {e}")

print("\n=== 5. Hamma narsa obyekt ===")


def salom(ism="dunyo"):
    return f"salom, {ism}"


namunalar = [
    ("salom (funksiya)", salom), ("salom.__code__", salom.__code__), ("sys (modul)", sys),
    ("Mahsulot (klass)", Mahsulot), ("m.__init__", m.__init__), ("inspect.currentframe()", inspect.currentframe()),
    ("None", None), ("...", ...), ("NotImplemented", NotImplemented), ("type", type),
]
for nom, obj in namunalar:
    print(f"  {nom:24} turi: {type(obj).__name__:18} getsizeof: {sys.getsizeof(obj):>5} bayt")

Natijaning muhim qismi:

text
=== 1. Bitta obyekt — bir nechta nom ===
  savat is buyurtma: True, id bir xil: True
  buyurtma ga qo'shildi → savat: ['non', 'sut', 'tuxum']

=== 2. Nomlar maydonlari ===
  modul:  'savat' in globals(): True, turi dict
  klass:  vars(Mahsulot) turi mappingproxy, 'soliq' bor: True
  nusxa:  vars(m) = {'nom': 'olma', 'narx': 12000}
  funksiya: f_locals turi FrameLocalsProxy, nomlar ['a', 'b', 'freym', 'yigindi']
            kod obyektidagi lokal nomlar: ('a', 'b', 'yigindi', 'freym')

=== 3. Nom tur saqlamaydi — obyekt saqlaydi ===
  x = 42      → type int, id True (42 o'lmas kichik son)
  x = 'salom' → type str
  x = Mahsulot → type type, x('nok', 9).nom = 'nok'

=== 4. del nomni o'chiradi, obyektni emas ===
  del royxat → 'royxat' in globals(): False, ikkinchi hali tirik: [1, 2, 3]
  NameError: name 'royxat' is not defined

=== 5. Hamma narsa obyekt ===
  salom (funksiya)         turi: function           getsizeof:   168 bayt
  salom.__code__           turi: code               getsizeof:   224 bayt
  sys (modul)              turi: module             getsizeof:    72 bayt
  Mahsulot (klass)         turi: type               getsizeof:  1720 bayt
  m.__init__               turi: method             getsizeof:    64 bayt
  inspect.currentframe()   turi: frame              getsizeof:   256 bayt
  None                     turi: NoneType           getsizeof:    16 bayt
  ...                      turi: ellipsis           getsizeof:    16 bayt
  NotImplemented           turi: NotImplementedType getsizeof:    16 bayt
  type                     turi: type               getsizeof:   416 bayt

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

Misol 2 — Sarlavhani ctypes bilan o'qish

python
"""ob_refcnt, ob_type va ob_size ni xotiradan o'qish (faqat o'qish!); o'lmas obyektlar."""

import ctypes
import sys

SOZ = ctypes.sizeof(ctypes.c_ssize_t)          # 64-bitli tizimda 8


def refcnt(obj_id):
    return ctypes.c_ssize_t.from_address(obj_id).value


def tur_manzili(obj):
    return ctypes.c_void_p.from_address(id(obj) + SOZ).value


def ob_size(obj):
    return ctypes.c_ssize_t.from_address(id(obj) + 2 * SOZ).value


print("=== 1. ob_type — turga ko'rsatkich ===")
for obj in [[1, 2], (1, 2), "matn", 3.14, {"a": 1}, object()]:
    print(f"  {type(obj).__name__:6} sarlavhadagi tur manzili == id(type(obj)): {tur_manzili(obj) == id(type(obj))}")

print("\n=== 2. ob_refcnt — havolalar soni ===")
royxat = [10, 20, 30]
rid = id(royxat)
print(f"  yaratildi:                   {refcnt(rid)}")
b = royxat
print(f"  b = royxat:                  {refcnt(rid)}")
konteyner = [royxat, royxat]
print(f"  ikki marta ro'yxatga solindi: {refcnt(rid)}")
lugat = {"kalit": royxat}
print(f"  lug'at qiymati:              {refcnt(rid)}")
del b, konteyner, lugat
print(f"  del b, konteyner, lugat:     {refcnt(rid)}")
print(f"  sys.getrefcount(royxat):     {sys.getrefcount(royxat)}   (+1 — argument sifatida vaqtinchalik havola)")

print("\n=== 3. ob_size — o'zgaruvchan uzunlikdagi obyektlar ===")
t = tuple(range(7))
l = list(range(7))
l.append(7)
print(f"  tuple(range(7)): ob_size={ob_size(t)}, len={len(t)}")
print(f"  list (8 element): ob_size={ob_size(l)}, len={len(l)}")
print(f"  bytes b'salom':  ob_size={ob_size(b'salom')}")

print("\n=== 4. O'lmas obyektlar (3.12+) ===")
for nom, obj in [("None", None), ("True", True), ("5", 5), ("256", 256), ("257", 10**2 + 157),
                 ("()", ()), ("'a'", "a")]:
    oldin = sys.getrefcount(obj)
    havolalar = [obj] * 1000
    keyin = sys.getrefcount(obj)
    olmas = sys._is_immortal(obj) if hasattr(sys, "_is_immortal") else "?"
    print(f"  {nom:6} o'lmas: {str(olmas):5}  1000 havoladan keyin schyotchik o'zgardimi: {keyin != oldin}")
    del havolalar

print("\n=== 5. Eng kichik obyektlar ===")
for nom, obj in [("object()", object()), ("float", 1.5), ("int 0", 0), ("int 2**30", 2**30),
                 ("int 2**60", 2**60), ("tuple()", ()), ("list []", []), ("str ''", "")]:
    print(f"  {nom:10} {sys.getsizeof(obj):>3} bayt")
print(f"  (64-bitli tizim: sarlavha {2 * SOZ} bayt)")

Natijaning muhim qismi:

text
=== 1. ob_type — turga ko'rsatkich ===
  list   sarlavhadagi tur manzili == id(type(obj)): True
  tuple  sarlavhadagi tur manzili == id(type(obj)): True
  str    sarlavhadagi tur manzili == id(type(obj)): True
  float  sarlavhadagi tur manzili == id(type(obj)): True
  dict   sarlavhadagi tur manzili == id(type(obj)): True
  object sarlavhadagi tur manzili == id(type(obj)): True

=== 2. ob_refcnt — havolalar soni ===
  yaratildi:                   1
  b = royxat:                  2
  ikki marta ro'yxatga solindi: 4
  lug'at qiymati:              5
  del b, konteyner, lugat:     1
  sys.getrefcount(royxat):     2   (+1 — argument sifatida vaqtinchalik havola)

=== 3. ob_size — o'zgaruvchan uzunlikdagi obyektlar ===
  tuple(range(7)): ob_size=7, len=7
  list (8 element): ob_size=8, len=8
  bytes b'salom':  ob_size=5

=== 4. O'lmas obyektlar (3.12+) ===
  None   o'lmas: True   1000 havoladan keyin schyotchik o'zgardimi: False
  True   o'lmas: True   1000 havoladan keyin schyotchik o'zgardimi: False
  5      o'lmas: True   1000 havoladan keyin schyotchik o'zgardimi: False
  256    o'lmas: True   1000 havoladan keyin schyotchik o'zgardimi: False
  257    o'lmas: False  1000 havoladan keyin schyotchik o'zgardimi: True
  ()     o'lmas: True   1000 havoladan keyin schyotchik o'zgardimi: False
  'a'    o'lmas: True   1000 havoladan keyin schyotchik o'zgardimi: False

=== 5. Eng kichik obyektlar ===
  object()    16 bayt
  float       24 bayt
  int 0       28 bayt
  int 2**30   32 bayt
  int 2**60   36 bayt
  tuple()     48 bayt
  list []     56 bayt
  str ''      41 bayt
  (64-bitli tizim: sarlavha 16 bayt)

Nima ko'rsatdi: 2.2, 2.5-bo'limlar. ctypes bilan xotirani faqat o'qish mumkin — u yerga yozish interpretatorni buzadi va jarayonni yiqitadi.

Misol 3 — id qayta ishlatilishi tuzog'i

python
"""Vaqtinchalik obyektlarning id si takrorlanadi; id asosidagi kesh boshqa obyekt natijasini qaytaradi; yechimlar."""

import weakref


class Sorov:
    def __init__(self, mijoz, summa):
        self.mijoz, self.summa = mijoz, summa


print("=== 1. id([]) == id([]), lekin [] is [] emas ===")
print(f"  id([]) == id([]): {id([]) == id([])}")
print(f"  [] is []:         {[] is []}")
a, b = [], []
print(f"  ikkalasi tirik bo'lsa id teng: {id(a) == id(b)}")

print("\n=== 2. Tsiklda vaqtinchalik obyektlar ===")
idlar = [id(Sorov(f"mijoz{i}", i)) for i in range(1000)]
print(f"  1000 ta vaqtinchalik Sorov → noyob id lar: {len(set(idlar))}")
tirik = [Sorov(f"mijoz{i}", i) for i in range(1000)]
print(f"  1000 ta tirik Sorov        → noyob id lar: {len({id(s) for s in tirik})}")

print("\n=== 3. ❌ id asosidagi kesh ===")
kesh = {}


def hisobot_yomon(sorov):
    kalit = id(sorov)
    if kalit not in kesh:
        kesh[kalit] = f"{sorov.mijoz}: {sorov.summa * 12:,} so'm"
    return kesh[kalit]


natijalar = []
for mijoz, summa in [("Aziz", 1000), ("Dilnoza", 2500), ("Bobur", 700)]:
    natijalar.append((mijoz, hisobot_yomon(Sorov(mijoz, summa))))
for mijoz, natija in natijalar:
    belgi = "✅" if natija.startswith(mijoz) else "❌ birovning hisoboti"
    print(f"  {mijoz:8} oldi: {natija:24} {belgi}")

print("\n=== 4. ✅ Yechimlar ===")


class Sorov2(Sorov):
    pass


zaif_kesh = weakref.WeakKeyDictionary()


def hisobot_zaif(sorov):
    if sorov not in zaif_kesh:
        zaif_kesh[sorov] = f"{sorov.mijoz}: {sorov.summa * 12:,} so'm"
    return zaif_kesh[sorov]


for mijoz, summa in [("Aziz", 1000), ("Dilnoza", 2500), ("Bobur", 700)]:
    natija = hisobot_zaif(Sorov2(mijoz, summa))
    print(f"  WeakKeyDictionary: {mijoz:8} → {natija:24} {'✅' if natija.startswith(mijoz) else '❌'}")
print(f"  keshda qolgan yozuvlar (obyektlar o'lgach): {len(zaif_kesh)}")

tirik_kesh = {}


def hisobot_tirik(sorov):
    kalit = id(sorov)
    if kalit not in tirik_kesh:
        tirik_kesh[kalit] = (sorov, f"{sorov.mijoz}: {sorov.summa * 12:,} so'm")
    return tirik_kesh[kalit][1]


for mijoz, summa in [("Aziz", 1000), ("Dilnoza", 2500), ("Bobur", 700)]:
    natija = hisobot_tirik(Sorov(mijoz, summa))
    print(f"  id + obyektni ushlash: {mijoz:8} → {natija:24} {'✅' if natija.startswith(mijoz) else '❌'}")
print(f"  lekin keshda {len(tirik_kesh)} ta obyekt abadiy qoladi — xotira sizishi xavfi")

Natijaning muhim qismi:

text
=== 1. id([]) == id([]), lekin [] is [] emas ===
  id([]) == id([]): True
  [] is []:         False
  ikkalasi tirik bo'lsa id teng: False

=== 2. Tsiklda vaqtinchalik obyektlar ===
  1000 ta vaqtinchalik Sorov → noyob id lar: 16
  1000 ta tirik Sorov        → noyob id lar: 1000

=== 3. ❌ id asosidagi kesh ===
  Aziz     oldi: Aziz: 12,000 so'm        ✅
  Dilnoza  oldi: Aziz: 12,000 so'm        ❌ birovning hisoboti
  Bobur    oldi: Aziz: 12,000 so'm        ❌ birovning hisoboti

=== 4. ✅ Yechimlar ===
  WeakKeyDictionary: Aziz     → Aziz: 12,000 so'm        ✅
  WeakKeyDictionary: Dilnoza  → Dilnoza: 30,000 so'm     ✅
  WeakKeyDictionary: Bobur    → Bobur: 8,400 so'm        ✅
  keshda qolgan yozuvlar (obyektlar o'lgach): 0
  id + obyektni ushlash: Aziz     → Aziz: 12,000 so'm        ✅
  id + obyektni ushlash: Dilnoza  → Dilnoza: 30,000 so'm     ✅
  id + obyektni ushlash: Bobur    → Bobur: 8,400 so'm        ✅
  lekin keshda 3 ta obyekt abadiy qoladi — xotira sizishi xavfi

Nima ko'rsatdi: 2.3-bo'lim. 2-bo'limda 1000 ta vaqtinchalik obyekt bir-ikki manzilni navbatma-navbat ishlatdi; 3-bo'limda kesh keyingi mijozlarga birinchi mijozning hisobotini berdi.

Misol 4 — Amaliy: obyekt inspektori

Istalgan obyekt haqida "xotira kartochkasi" chiqaradigan vosita: tur, o'lmaslik, havolalar soni, hajm, axlat yig'uvchi kuzatadimi, u qaysi obyektlarga ishora qiladi. Keyingi darslarda shu vositani kengaytiramiz.

python
"""kartochka(obj): tur, o'lmas, havolalar, getsizeof, gc kuzatuvi, ichidagi havolalar — turli obyektlar uchun."""

import gc
import sys
from dataclasses import dataclass


def kartochka(nom, obj):
    olmas = sys._is_immortal(obj) if hasattr(sys, "_is_immortal") else None
    havolalar = "o'lmas" if olmas else sys.getrefcount(obj) - 2       # o'zimiz yaratgan 2 ta vaqtinchalik havola
    ichida = gc.get_referents(obj)
    ichki_turlar = sorted({type(x).__name__ for x in ichida})[:4]
    return (f"  {nom:22} {type(obj).__name__:12} {str(havolalar):>7} {sys.getsizeof(obj):>6} "
            f"{'ha' if gc.is_tracked(obj) else 'yo' + chr(39) + 'q':>6}   {len(ichida):>3} → {ichki_turlar}")


@dataclass
class Talaba:
    ism: str
    kurs: int


def hisobla(x):
    return x * 2


print("=== Obyekt kartochkalari ===")
print(f"  {'nom':22} {'tur':12} {'havola':>7} {'bayt':>6} {'gc':>6}   ichidagi havolalar")
talaba = Talaba("Dilnoza", 3)
katta_son = 10**30
matn = "Python ichidan: obyektlar va xotira"
royxat = [talaba, katta_son, matn]
lugat = {"ism": "Aziz", "yosh": 30}
aralash = {"talaba": talaba}
kortej = (1, 2, 3)
namunalar = [
    ("None", None), ("True", True), ("7 (kichik son)", 7), ("10**30", katta_son), ("matn", matn),
    ("talaba (dataclass)", talaba), ("royxat", royxat), ("lugat (oddiy)", lugat),
    ("aralash (obyektli)", aralash), ("kortej (sonlar)", kortej), ("hisobla (funksiya)", hisobla),
    ("hisobla.__code__", hisobla.__code__), ("Talaba (klass)", Talaba), ("sys (modul)", sys),
]
for nom, obj in namunalar:
    print(kartochka(nom, obj))

print("\n=== Havolalar grafi: royxat nimaga ishora qiladi ===")
for x in gc.get_referents(royxat):
    print(f"  royxat → {type(x).__name__:8} {repr(x)[:40]}")
print(f"  talaba → {[type(x).__name__ for x in gc.get_referents(talaba)]}")
print(f"  talaba.__dict__ → {sorted(repr(x) for x in gc.get_referents(talaba.__dict__))}")

Natijaning muhim qismi:

text
=== Obyekt kartochkalari ===
  nom                    tur           havola   bayt     gc   ichidagi havolalar
  None                   NoneType      o'lmas     16   yo'q     0 → []
  True                   bool          o'lmas     28   yo'q     0 → []
  7 (kichik son)         int           o'lmas     28   yo'q     0 → []
  10**30                 int                4     40   yo'q     0 → []
  matn                   str                5     76   yo'q     0 → []
  talaba (dataclass)     Talaba             4     48     ha     3 → ['int', 'str', 'type']
  royxat                 list               2     80     ha     3 → ['Talaba', 'int', 'str']
  lugat (oddiy)          dict               2    184     ha     2 → ['int', 'str']
  aralash (obyektli)     dict               2    184     ha     1 → ['Talaba']
  kortej (sonlar)        tuple              3     72   yo'q     3 → ['int']
  hisobla (funksiya)     function           2    168     ha     7 → ['NoneType', 'code', 'dict', 'str']
  hisobla.__code__       code               3    232   yo'q     0 → []
  Talaba (klass)         type               7   1720     ha     4 → ['dict', 'tuple', 'type']
  sys (modul)            module            79     72     ha     1 → ['dict']

=== Havolalar grafi: royxat nimaga ishora qiladi ===
  royxat → str      'Python ichidan: obyektlar va xotira'
  royxat → int      1000000000000000000000000000000
  royxat → Talaba   Talaba(ism='Dilnoza', kurs=3)
  talaba → ['str', 'int', 'type']
  talaba.__dict__ → ["'Dilnoza'", '3']

Nima ko'rsatdi: 2.2, 2.4, 2.5-bo'limlar. "gc" ustuni: axlat yig'uvchi boshqa obyektlarga havola saqlay oladigan konteynerlarni kuzatadi. Sonlar, satrlar va kod obyekti kuzatilmaydi, faqat atomar qiymatli kortej esa kuzatuvdan chiqariladi; lug'atlar esa bu versiyada — ichidagi qiymatlardan qat'i nazar — kuzatiladi (11.5-dars).


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

Noto'g'ri fikr To'g'risi
"O'zgaruvchi — qiymat saqlanadigan quti" Nom — obyektga havola; qiymat va tur obyektda
"a = b nusxa oladi" Ikkinchi havola
"del x obyektni o'chiradi" Nomni o'chiradi; obyekt havola qolmasa o'ladi
"id — obyektning abadiy noyob raqami" Faqat obyekt yashagan paytda noyob; keyin qayta ishlatiladi
"id har doim xotira manzili" CPython'da — ha; PyPy va boshqalarda — yo'q
"Kichik obyekt deyarli joy olmaydi" Eng kichigi ham 16 bayt, int — 28 bayt
"Funksiya va klass — kod, obyekt emas" Ular ham tur, havolalar soni va atributlarga ega obyektlar
"sys.getrefcount(None) — haqiqiy havolalar soni" 3.12+ da o'lmas obyekt uchun maxsus qiymat

6. Keng tarqalgan xatolar va yechimlari

1. id ni obyektsiz kalit sifatida saqlash

python
kesh[id(sorov)] = natija           # ❌ sorov o'lgach, boshqa obyekt shu id ni oladi

zaif = weakref.WeakKeyDictionary()
zaif[sorov] = natija               # ✅

2. id bo'yicha "ko'rilganlar" to'plami vaqtinchalik obyektlar bilan

python
korildi = set()
for qator in fayl:
    obj = parse(qator)
    if id(obj) in korildi: continue    # ❌ keyingi obyekt o'sha id bilan "ko'rilgan" deb o'tkaziladi
    korildi.add(id(obj))

Mazmun bo'yicha kalit (obj.kalit()) yoki obyektlarni tirik ro'yxatda ushlab turing.

3. is ni qiymat taqqoslash uchun ishlatish

python
if javob is "ha": ...              # ❌ SyntaxWarning, natija tasodifiy (11.7-dars)
if javob == "ha": ...              # ✅

4. a = b ni nusxa deb o'ylash

python
asl = [1, 2]
nusxa = asl
nusxa.append(3)                    # ❌ asl ham o'zgardi

nusxa = asl.copy()                 # ✅ (ichma-ich bo'lsa — copy.deepcopy)

5. del bilan xotirani bo'shatishni kutish

python
katta = yukla()
kesh = katta
del katta                          # ❌ kesh hali ushlab turibdi — xotira bo'shamaydi

Barcha havolalarni olib tashlang yoki weakref ishlating; tekshirish — sys.getrefcount, gc.get_referrers (11.4-dars).

6. sys.getrefcount natijasini to'g'ridan-to'g'ri talqin qilish

python
sys.getrefcount(x)                 # ⚠️ +1 — argument; o'lmas obyektlar uchun maxsus qiymat

7. ctypes bilan xotiraga yozish

python
ctypes.c_ssize_t.from_address(id(x)).value = 1   # ❌ interpretator yiqiladi

Faqat o'qish va faqat o'rganish uchun.

8. locals() orqali lokal o'zgaruvchini o'zgartirishga urinish

python
def f():
    x = 1
    locals()["x"] = 2              # ❌ x o'zgarmaydi — locals() nusxa/ko'rinish
    return x                       # 1

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 3.1-dars (o'tilgan): o'zgaruvchi — nom va havola
  • 6.4, 6.18-darslar (o'tilgan): ro'yxat xotirasi, copy/deepcopy
  • 10.15-dars (o'tilgan): identifikatsiya, tur, qiymat — ma'lumot modeli
  • 11.2–11.10-darslar: is, havolalar, schyotchik, GC, interning, hajm, __slots__, weakref
  • 12-qism: PyObject, kod va freym obyektlari, bytecode
  • 14-qism: iplar va o'lmas obyektlar, erkin ipli yig'ma
  • 29-qism: xotira optimizatsiyasi — nega jarayon hajmi kamaymaydi
  • 30-qism: C kengaytmalarda Py_INCREF/Py_DECREF — sarlavha bilan ishlash

8. Eng yaxshi amaliyotlar

  1. Nomni havola deb o'ylang — a = b dan keyin bitta obyekt, ikkita nom.

  2. id ni faqat bir vaqtda tirik obyektlar uchun ishlating — tuzatish, is ni tushuntirish, deepcopy memo kabi.

  3. Obyekt bo'yicha kesh — WeakKeyDictionary yoki mazmunli kalit.

  4. Xotira hisobida sarlavhani unutmang — millionlab kichik obyekt katta joy oladi (11.8–11.9-darslar).

  5. sys.getrefcount ni taqqoslash uchun ishlating, mutlaq son sifatida emas.

  6. ctypes bilan faqat o'qing va faqat o'rganish maqsadida.

  7. Implementatsiyaga bog'liq faktlarni kodga yozmang — id = manzil, o'lmas obyektlar, sarlavha hajmi CPython va versiyaga bog'liq.

  8. Xotira muammosini taxmin bilan emas, o'lchab tekshiring — tracemalloc, gc, sys.getsizeof.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
import sys
1.  a = [1, 2]
    b = a
    b.append(3)
    print(a)
2.  a = [1, 2]
    b = a
    b = b + [3]
    print(a, a is b)
3.  print([] is [], id([]) == id([]))
4.  x = 5
    y = 5
    print(x is y)
5.  print(type(type(5)).__name__, type(sys).__name__)
6.  def f():
        pass
    print(type(f).__name__, type(f.__code__).__name__)
7.  print(sys.getsizeof(object()))
8.  a = [1]
    b = a
    del a
    print(b)
9.  print(sys._is_immortal(None), sys._is_immortal([]))
10. x = [1, 2]
    oldin = sys.getrefcount(x)
    y = [x, x, x]
    print(sys.getrefcount(x) - oldin)
11. def f():
        x = 1
        locals()["x"] = 2
        return x
    print(f())
12. class K:
        pass
    k = K()
    k.a = 1
    print(vars(k), type(vars(K)).__name__)
Javoblar
  1. [1, 2, 3] — bitta ro'yxat, ikki nom
  2. [1, 2] False — b + [3] yangi ro'yxat, b qayta bog'landi
  3. False True — ikki tirik ro'yxat turli; vaqtinchalik ro'yxatning manzili qayta ishlatildi
  4. True — kichik son o'lmas va yagona
  5. type module
  6. function code
  7. 16
  8. [1] — del a nomni o'chirdi
  9. True False
  10. 3 — ro'yxatdagi uch havola
  11. 1 — locals() orqali lokal o'zgaruvchi o'zgarmaydi
  12. {'a': 1} mappingproxy

Vazifa 2: Xatolarni tuzating

python
1.  def unikallar(obyektlar_oqimi):
        korildi = set()
        for obj in obyektlar_oqimi:          # obyektlar parse qilinib, keyin tashlab yuboriladi
            if id(obj) not in korildi:
                korildi.add(id(obj))
                yield obj

2.  sessiyalar = {}
    def sessiya_ol(foydalanuvchi):
        return sessiyalar.setdefault(id(foydalanuvchi), Sessiya())

3.  def tozala(katta_malumot):
        nusxa = katta_malumot
        del katta_malumot
        return nusxa                         # "xotira bo'shadi" deb kutilgan

4.  def almashtir(royxat):
        royxat = [x * 2 for x in royxat]     # chaqiruvchining ro'yxati o'zgarishi kutilgan

5.  if sys.getrefcount(sozlama) == 2:
        print("sozlama boshqa hech qayerda ishlatilmayapti")
Javoblar
python
1.  def unikallar(obyektlar_oqimi, kalit=lambda o: o):
        korildi = set()
        for obj in obyektlar_oqimi:
            k = kalit(obj)                     # mazmun bo'yicha: id qayta ishlatiladi
            if k not in korildi:
                korildi.add(k)
                yield obj

2.  sessiyalar = weakref.WeakKeyDictionary()   # foydalanuvchi o'lsa, sessiya ham tushadi
    def sessiya_ol(foydalanuvchi):
        if foydalanuvchi not in sessiyalar:
            sessiyalar[foydalanuvchi] = Sessiya()
        return sessiyalar[foydalanuvchi]
    # yoki mazmunli kalit: sessiyalar[foydalanuvchi.id]

3.  # del faqat nomni o'chiradi; obyekt nusxa orqali tirik — bu funksiya hech narsani bo'shatmaydi.
    # Chaqiruvchi o'z havolalarini olib tashlashi kerak: malumot = None yoki del malumot

4.  def almashtir(royxat):
        royxat[:] = [x * 2 for x in royxat]  # joyida o'zgartirish (yoki yangi ro'yxatni qaytarish)

5.  # getrefcount +1 argument havolasini qo'shadi, o'lmas obyektlarda ma'nosiz, iplar va keshlar
    # ham havola saqlaydi. "Ishlatilmayapti" tekshiruvi uchun weakref.finalize yoki aniq egalik modeli

Vazifa 3: nomlar_xaritasi()

Joriy modulning barcha global nomlarini tahlil qiladigan funksiya yozing:

  1. Har obyekt uchun unga ishora qiluvchi nomlar ro'yxatini chiqarsin (a va b bir obyektga ishora qilsa — birga)
  2. Obyekt turi, sys.getsizeof va o'lmasligini ko'rsatsin
  3. Modullar, funksiyalar va klasslarni alohida guruhlasin
  4. Natijani hajm bo'yicha saralasin

Vazifa 4: id qayta ishlatilishi statistikasi

  1. 100 000 ta vaqtinchalik object(), [], {}, 1.5 + x va o'z klassingiz nusxalari uchun nechta noyob id bo'lishini o'lchang
  2. Natijalarni turlar bo'yicha solishtiring va nega farq qilishini (bo'sh ro'yxatlar, pymalloc bo'laklari) izohlang
  3. Obyektlarni ro'yxatda ushlab turganda qanday o'zgaradi?

Vazifa 5: Sarlavha o'quvchi

Misol 2 dan foydalanib sarlavha(obj) funksiyasini yozing:

  1. ob_refcnt, ob_type manzili va (bor bo'lsa) ob_size ni qaytarsin
  2. Qaysi turlar PyVarObject ekanini type.__itemsize__ != 0 bilan aniqlang
  3. int uchun kattalik va belgi qanday saqlanishini turli sonlar (0, 1, -1, 230, 260, -2**90) bilan tekshirib, kuzatuvingizni yozing
  4. Funksiya faqat o'qishini va CPython bo'lmagan interpretatorda ishlamasligini tekshiruv bilan ta'minlang (sys.implementation.name)

Vazifa 6: Obyekt inspektorini kengaytiring

Misol 4 dagi kartochka ga qo'shing:

  1. gc.get_referrers(obj) — kim bu obyektga ishora qiladi (freym va o'zingizning ro'yxatlaringizni chiqarib tashlang)
  2. Rekursiv "chuqur hajm" — gc.get_referents bo'ylab, har obyektni bir marta hisoblab
  3. --json rejimi: natijani JSON ga chiqarish
  4. Uni 11.8-darsdagi haqiqiy hajm bilan keyinroq solishtiring

Vazifa 7: O'ylash

Python'da "hamma narsa obyekt" — hatto butun sonlar ham 28 baytlik heap obyektlari. Java va C# esa int kabi primitiv (qiymat) turlarni obyektlardan ajratadi. Bu tanlov qanday afzallik va kamchiliklar beradi va Python ekotizimi kamchiliklarni qanday yengib o'tadi?

Javob

Qisqa javob: yagona obyekt modeli tilni sodda va izchil qiladi: har qiymatning turi, metodlari va identifikatsiyasi bor, int ni istalgan konteynerga solish, argument sifatida uzatish yoki unga metod chaqirish maxsus qoidalarsiz ishlaydi. Narxi — xotira va tezlik: har son ko'rsatkich orqali ishlatiladigan alohida heap obyekti. Python bu narxni to'g'ridan-to'g'ri hisoblashlarni C da yozilgan kutubxonalarga (NumPy, array, struct) topshirish orqali to'laydi.

1. Java va C# qanday qiladi

Java: int, double, boolean — primitivlar, obyekt emas. Ular stekda yoki massivda to'g'ridan-to'g'ri saqlanadi (int[] — 4 baytlik yacheykalar). Kolleksiyalarga solish uchun Integer obyektiga o'rash (boxing) kerak — avtomatik, lekin qimmat va == tuzoqlari bilan (Integer lar uchun == havolani taqqoslaydi, kichik qiymatlar esa keshlangan).

C#: struct — qiymat turlari, int ham shular jumlasidan; List<int> generiklar tufayli o'ramsiz saqlanadi. object ga tayinlashda boxing bo'ladi.

2. Python yondashuvining afzalliklari

  • Izchillik: (5).bit_length(), isinstance(5, int), type(5) — qiymat va obyekt farqi yo'q
  • Ixtiyoriy aniqlik: int avtomatik o'sadi — 2**1000 oddiy son, toshib ketish yo'q
  • Yagona konteynerlar: list istalgan narsani saqlaydi, generik o'rash kerak emas
  • Introspeksiya va dinamiklik: har narsaning turi, id si, havolalari bor — debugger, pickle, copy bir xil ishlaydi
  • Soddalik: o'quvchi "bu primitivmi yoki obyektmi" deb o'ylamaydi

3. Kamchiliklari

Kamchilik Oqibat
Xotira list dagi har int — 8 baytlik ko'rsatkich + 28 baytlik obyekt (kichik sonlar o'lmas va umumiy bo'lsa ham)
Kesh lokalligi Sonlar xotirada tarqoq — CPU keshi yomon ishlaydi
Tezlik a + b — tur tekshiruvi, maxsus metod, yangi obyekt ajratish, havolalar soni
Havolalar soni Har tayinlash va o'chirishda schyotchik yoziladi — iplar uchun muammo (GIL, 12, 14-qismlar)

4. Python ekotizimi bu narxni qanday to'laydi

  • Keshlar va o'lmas obyektlar: kichik butun sonlar va ko'p ishlatiladigan satrlar bitta nusxa (11.7-dars); 3.12 dan ular o'lmas — schyotchikka yozuv yo'q
  • Bo'sh ro'yxatlar va pymalloc: ajratish narxini kamaytiradi
  • Adaptiv interpretator (3.11+, PEP 659): int + int kabi amallar uchun ixtisoslashgan bytecode (12-qism)
  • Zich konteynerlar: array.array("i"), bytes, memoryview, struct — qiymatlar ketma-ket, obyektlarsiz
  • NumPy: million son — bitta obyekt va 8 MB zich massiv; amallar C sikllarida (24-qism)
  • C/Rust kengaytmalar: issiq kodni obyekt modelidan tashqariga chiqarish (30-qism)

5. Dizayn nuqtai nazaridan

Python "dasturchi vaqti — kompyuter vaqtidan qimmatroq" degan falsafaga tayanadi. Yagona obyekt modeli ko'p holatda yetarlicha tez, noqulay joyda esa maxsus zich tuzilmalar mavjud. Java va C# aksincha, tezlikni sukut qilib olib, soddalik narxini (boxing, ikki xil tur tizimi) to'laydi.

6. Xulosa

  1. Python'da primitiv va obyekt farqi yo'q — har qiymat sarlavhali heap obyekti
  2. Bu izchillik, ixtiyoriy aniqlik va sodda konteynerlar beradi
  3. Narxi — xotira, kesh lokalligi va har amaldagi qo'shimcha ish
  4. Keshlar, o'lmas obyektlar, adaptiv interpretator va zich konteynerlar narxni kamaytiradi
  5. Hisob-kitobga og'ir kod NumPy va kengaytmalar orqali obyekt modelidan tashqarida bajariladi

Nimani mustahkamlaydi: 2.1–2.6-bo'limlar.


Xulosa

Bu darsda Python obyektlarining xotiradagi ko'rinishini o'rgandik.

Eng muhim uch fikr:

  1. Nomlar — havolalar, obyektlar — heap'da. Tayinlash nomni obyektga bog'laydi, a = b ikkinchi havola yaratadi, del esa faqat nomni o'chiradi. Modul, klass va nusxa nomlari lug'atlarda, funksiya lokal o'zgaruvchilari freymdagi tez massivda yashaydi. Son, satr, funksiya, kod, freym, modul va klass — hammasi tur va havolalar soniga ega obyekt.

  2. Har obyekt sarlavha bilan boshlanadi. CPython'da (64-bit, GIL li yig'ma) ob_refcnt va ob_type — 16 bayt, o'zgaruvchan uzunlikdagi obyektlarda yana ob_size. Tur obyektning o'zida, havolalar soni har yangi havola bilan oshadi. 3.12 dan None, True, kichik sonlar kabi obyektlar o'lmas — ularning schyotchigi o'zgarmaydi.

  3. id — CPython'da manzil, noyobligi esa faqat obyekt yashagan paytda. Obyekt o'lgach manzil qayta ishlatiladi: id([]) == id([]) ko'pincha True, id asosidagi kesh esa boshqa obyekt natijasini qaytaradi. Obyektlar bo'yicha kesh uchun WeakKeyDictionary yoki mazmunli kalit ishlating.

Keyingi darsda id, is va == ni chuqur solishtiramiz: identifikatsiya va tenglik qachon farq qiladi, is qachon to'g'ri va qachon xato, __eq__ va NaN tuzoqlari.

Obyekt modeli va xotira · 1-dars yakunlandi

11.1-dars: Pythonda hamma narsa obyekt

26 daqvaqt
0belgi
Keyingi dars: 11.2-dars: id, is va ==
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0