11.1-dars: Pythonda hamma narsa obyekt
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:
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
-
PyObjectsarlavhasi: 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:
pymallocva 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
narx = 12_000Bu qator ikki narsa qiladi:
- Xotirada (heap'da) butun son obyekti yaratiladi (yoki mavjudi olinadi)
- Joriy nomlar maydonida
narxnomi 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):
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:
ob_type— tur obyektning o'zida. Nomda emas. Shuning uchuntype(x)har doim aniq, maxsus metodlar esa turdan qidiriladi (10.15-dars)ob_refcnt— har havola uni oshiradi. Nomga bog'lash, ro'yxatga qo'shish, argument sifatida uzatish (11.4-dars)- 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
idni oladi id([]) == id([])ko'pinchaTrue: birinchi ro'yxat taqqoslashdan oldin o'ladi, ikkinchisi o'sha joyga tushadi.[] is []esaFalse— ikkalasi bir vaqtda tirik- PyPy va boshqa implementatsiyalarda
idmanzil 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.WeakKeyDictionaryyokiWeakValueDictionary(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 (
-5dan256gacha) - Interpretator ichidagi ko'plab satrlar va tur obyektlari
Ularning havolalar soni oshmaydi va kamaymaydi — maxsus katta qiymatda turadi. Nega:
- Tezlik va keshlar: har
Noneishlatilganda schyotchikka yozish CPU keshini "iflos qiladi" - Iplar va jarayonlar:
forkdan 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
pymallocajratuvchisidan foydalanadi: xotirani katta bloklarda oladi va bir xil o'lchamdagi bo'laklarga bo'ladi — tizimmallociga 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
idlar 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'rinishiSarlavha (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()) == 16id
CPython: id(x) == manzil obyekt ko'chmaydi
noyob — faqat bir vaqtda tirik obyektlar orasida
id([]) == id([]) → ko'pincha True [] is [] → FalseO'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
"""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:
=== 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 baytNima ko'rsatdi: 2.1, 2.4-bo'limlar.
Misol 2 — Sarlavhani ctypes bilan o'qish
"""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:
=== 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
"""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:
=== 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 xavfiNima 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.
"""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:
=== 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
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
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
if javob is "ha": ... # ❌ SyntaxWarning, natija tasodifiy (11.7-dars)
if javob == "ha": ... # ✅4. a = b ni nusxa deb o'ylash
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
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
sys.getrefcount(x) # ⚠️ +1 — argument; o'lmas obyektlar uchun maxsus qiymat7. ctypes bilan xotiraga yozish
ctypes.c_ssize_t.from_address(id(x)).value = 1 # ❌ interpretator yiqiladiFaqat o'qish va faqat o'rganish uchun.
8. locals() orqali lokal o'zgaruvchini o'zgartirishga urinish
def f():
x = 1
locals()["x"] = 2 # ❌ x o'zgarmaydi — locals() nusxa/ko'rinish
return x # 17. 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
Nomni havola deb o'ylang —
a = bdan keyin bitta obyekt, ikkita nom.idni faqat bir vaqtda tirik obyektlar uchun ishlating — tuzatish,isni tushuntirish,deepcopymemokabi.Obyekt bo'yicha kesh —
WeakKeyDictionaryyoki mazmunli kalit.Xotira hisobida sarlavhani unutmang — millionlab kichik obyekt katta joy oladi (11.8–11.9-darslar).
sys.getrefcountni taqqoslash uchun ishlating, mutlaq son sifatida emas.ctypesbilan faqat o'qing va faqat o'rganish maqsadida.Implementatsiyaga bog'liq faktlarni kodga yozmang —
id= manzil, o'lmas obyektlar, sarlavha hajmi CPython va versiyaga bog'liq.Xotira muammosini taxmin bilan emas, o'lchab tekshiring —
tracemalloc,gc,sys.getsizeof.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
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, 2, 3]— bitta ro'yxat, ikki nom[1, 2] False—b + [3]yangi ro'yxat,bqayta bog'landiFalse True— ikki tirik ro'yxat turli; vaqtinchalik ro'yxatning manzili qayta ishlatildiTrue— kichik son o'lmas va yagonatype modulefunction code16[1]—del anomni o'chirdiTrue False3— ro'yxatdagi uch havola1—locals()orqali lokal o'zgaruvchi o'zgarmaydi{'a': 1} mappingproxy
Vazifa 2: Xatolarni tuzating
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
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 modeliVazifa 3: nomlar_xaritasi()
Joriy modulning barcha global nomlarini tahlil qiladigan funksiya yozing:
- Har obyekt uchun unga ishora qiluvchi nomlar ro'yxatini chiqarsin (
avabbir obyektga ishora qilsa — birga) - Obyekt turi,
sys.getsizeofva o'lmasligini ko'rsatsin - Modullar, funksiyalar va klasslarni alohida guruhlasin
- Natijani hajm bo'yicha saralasin
Vazifa 4: id qayta ishlatilishi statistikasi
- 100 000 ta vaqtinchalik
object(),[],{},1.5 + xva o'z klassingiz nusxalari uchun nechta noyobidbo'lishini o'lchang - Natijalarni turlar bo'yicha solishtiring va nega farq qilishini (bo'sh ro'yxatlar,
pymallocbo'laklari) izohlang - Obyektlarni ro'yxatda ushlab turganda qanday o'zgaradi?
Vazifa 5: Sarlavha o'quvchi
Misol 2 dan foydalanib sarlavha(obj) funksiyasini yozing:
ob_refcnt,ob_typemanzili va (bor bo'lsa)ob_sizeni qaytarsin- Qaysi turlar
PyVarObjectekaninitype.__itemsize__ != 0bilan aniqlang intuchun kattalik va belgi qanday saqlanishini turli sonlar (0, 1, -1, 230, 260, -2**90) bilan tekshirib, kuzatuvingizni yozing- 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:
gc.get_referrers(obj)— kim bu obyektga ishora qiladi (freym va o'zingizning ro'yxatlaringizni chiqarib tashlang)- Rekursiv "chuqur hajm" —
gc.get_referentsbo'ylab, har obyektni bir marta hisoblab --jsonrejimi: natijani JSON ga chiqarish- 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:
intavtomatik o'sadi —2**1000oddiy son, toshib ketish yo'q - Yagona konteynerlar:
lististalgan narsani saqlaydi, generik o'rash kerak emas - Introspeksiya va dinamiklik: har narsaning turi,
idsi, havolalari bor — debugger,pickle,copybir 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+intkabi 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
- Python'da primitiv va obyekt farqi yo'q — har qiymat sarlavhali heap obyekti
- Bu izchillik, ixtiyoriy aniqlik va sodda konteynerlar beradi
- Narxi — xotira, kesh lokalligi va har amaldagi qo'shimcha ish
- Keshlar, o'lmas obyektlar, adaptiv interpretator va zich konteynerlar narxni kamaytiradi
- 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:
Nomlar — havolalar, obyektlar — heap'da. Tayinlash nomni obyektga bog'laydi,
a = bikkinchi havola yaratadi,delesa 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.Har obyekt sarlavha bilan boshlanadi. CPython'da (64-bit, GIL li yig'ma)
ob_refcntvaob_type— 16 bayt, o'zgaruvchan uzunlikdagi obyektlarda yanaob_size. Tur obyektning o'zida, havolalar soni har yangi havola bilan oshadi. 3.12 danNone,True, kichik sonlar kabi obyektlar o'lmas — ularning schyotchigi o'zgarmaydi.id— CPython'da manzil, noyobligi esa faqat obyekt yashagan paytda. Obyekt o'lgach manzil qayta ishlatiladi:id([]) == id([])ko'pinchaTrue,idasosidagi kesh esa boshqa obyekt natijasini qaytaradi. Obyektlar bo'yicha kesh uchunWeakKeyDictionaryyoki 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.
Izohlar · 0
Izoh yozish uchun kiring.