3.1-dars: O'zgaruvchi nima

3-QISM — ASOSLAR · 1-dars

1. Kirish va motivatsiya

Nihoyat tilning o'ziga kirishamiz.

O'zgaruvchi — dasturlashning eng birinchi va eng asosiy tushunchasi. Usiz hech narsa yozib bo'lmaydi. Va aynan shuning uchun uni to'g'ri tushunish muhim.

Ko'p kursda o'zgaruvchi shunday tushuntiriladi: "o'zgaruvchi — qiymat saqlanadigan quti." Bu — sodda, tushunarli va noto'g'ri. Hech bo'lmaganda Python uchun.

Bu noto'g'ri model keyinroq quyidagi savollarni tug'diradi:

a = [1, 2, 3]
b = a
b.append(4)
print(a)        # nega [1, 2, 3, 4]?! men a ni o'zgartirmadim-ku

x = 5
y = 5
print(x is y)   # True — nega?

x = 1000
y = 1000
print(x is y)   # False — nega endi?!

Bu darsda to'g'ri modelni o'rganamiz: Pythonda o'zgaruvchi — quti emas, yorliq. Va bu farqni bilish sizni kelajakdagi o'nlab chalkashlikdan qutqaradi.

Shuningdek 1.1-darsdagi xotira tushunchasi bilan bog'lab, o'zgaruvchi aslida RAM'da qanday ko'rinishini ko'ramiz.

2. Nazariya — chuqur tushuntirish

2.1. O'zgaruvchi — nima uchun kerak

Eng oddiy dastur ham ma'lumotni eslab qolishi kerak:

narx = 15000
soni = 3
jami = narx * soni
print(jami)

45000

O'zgaruvchisiz:

print(15000 * 3)

Ishlaydi, lekin:

• narx o'zgarsa, hamma joyda qidirib almashtirish kerak
• 15000 nima ekani noma'lum — narxmi, masofami, yilmi?
• murakkab hisobni bo'laklarga bo'lib bo'lmaydi

O'zgaruvchi uch narsa beradi:

1. Xotira — qiymatni saqlash
2. Nom — qiymatga ma'no berish
3. Qayta ishlatish — bir joyda o'zgartirib, hamma joyda ta'sir qilish

2.2. Quti emas, yorliq

Boshqa tillarda (C, Java) o'zgaruvchi haqiqatan ham qutiga o'xshaydi:

C tilida:  int x = 5;

     Xotira
   ┌─────────┐
x  │    5    │      ← x — bu xotira joyining nomi
   └─────────┘

Pythonda esa boshqacha:

Pythonda:  x = 5

   x ──────┐
           ↓
       ┌───────┐
       │   5   │   ← obyekt xotirada
       └───────┘

x — obyektga yopishtirilgan yorliq. Obyektning o'zi alohida yashaydi.

Farqni ko'rish:

a = [1, 2, 3]
b = a               # YANGI ro'yxat yaratilmadi!

   a ──────┐
           ↓
       ┌─────────────┐
       │ [1, 2, 3]   │
       └─────────────┘
           ↑
   b ──────┘

Ikkala yorliq bitta ro'yxatga ishora qilyapti:

b.append(4)
print(a)            # [1, 2, 3, 4]
print(b)            # [1, 2, 3, 4]

a ni o'zgartirmadingiz — lekin a ishora qilayotgan obyekt o'zgardi.

Bu — Pythondagi eng ko'p chalkashlik manbai. Bu darsda uni birinchi kundan to'g'ri tushunasiz. 6-qismda (ro'yxatlar) va 11-qismda (obyekt modeli) bunga qaytamiz.

2.3. O'zlashtirish nima qiladi

x = 5

Bu qator uch ish qiladi:

1. O'ng tomonni hisoblaydi     →  5 obyekti yaratiladi (yoki topiladi)
2. Nomni yaratadi (yoki topadi) →  x
3. Nomni obyektga bog'laydi     →  x → 5

Muhim: o'ng tomon doim birinchi hisoblanadi. Bu quyidagini tushuntiradi:

x = 5
x = x + 1

1. x + 1 hisoblanadi  →  5 + 1  →  6
2. x endi 6 ga bog'lanadi

Eski 5 obyekti hech kimga kerak bo'lmay qoladi va Python uni tozalaydi (axlat yig'ish — 11-qismda).

Qayta o'zlashtirish obyektni o'zgartirmaydi:

a = [1, 2, 3]
b = a
b = [9, 9]          # b endi BOSHQA obyektga ishora qilyapti
print(a)            # [1, 2, 3] — o'zgarmadi

Solishtiring 2.2-bo'limdagi b.append(4) bilan:

• b.append(4) — obyektni o'zgartiradi → a ham ko'radi
• b = [9, 9] — yorliqni ko'chiradi → a ta'sirlanmaydi

Bu farqni tushunish — 6-qismning yarmini oldindan o'zlashtirish demak.

2.4. id() — obyekt shaxsi

Har bir obyektning noyob identifikatori bor. CPython'da bu — xotiradagi manzil (1.1-dars).

x = 5
print(id(x))            # 4304829384 (sizda boshqa son bo'ladi)

Ikki yorliq bitta obyektgami?

a = [1, 2, 3]
b = a
print(id(a) == id(b))   # True — bitta obyekt
print(a is b)           # True — bir xil narsa

c = [1, 2, 3]           # yangi ro'yxat
print(id(a) == id(c))   # False — boshqa obyekt
print(a is c)           # False
print(a == c)           # True — lekin MAZMUNI bir xil

is va == farqi — muhim:

Hayotdan misol: siz va do'stingizda bir xil telefon bor.

• telefon1 == telefon2 → True (bir xil model)
• telefon1 is telefon2 → False (ikkita alohida telefon)

Qoida: is ni faqat None, True, False bilan ishlating. Qolgan hamma joyda ==. Sababini 3.6-darsda ko'ramiz.

2.5. Kichik sonlar tuzog'i

Endi kirishdagi ikkinchi jumboqni yechamiz:

x = 5
y = 5
print(x is y)       # True

x = 1000
y = 1000
print(x is y)       # False

Nega?

CPython tezlik uchun kichik butun sonlarni oldindan yaratib qo'yadi: -5 dan 256 gacha. Bu sonlar tez-tez ishlatiladi, har safar yangi obyekt yaratish behuda bo'lardi.

Python ishga tushganda:

  -5  -4  -3 ... 0  1  2  3 ... 255  256      ← tayyor obyektlar

Shuning uchun x = 5 va y = 5 bitta obyektga ishora qiladi.

1000 esa oraliqdan tashqarida — har safar yangi obyekt yaratiladi.

Bu — CPython'ning ichki optimizatsiyasi, tilning qoidasi emas. Boshqa amalga oshiruvda (PyPy) boshqacha bo'lishi mumkin.

Amaliy xulosa:

if x is 5:          # ❌ HECH QACHON
if x == 5:          # ✅ DOIM

Python 3.8+ birinchisi uchun ogohlantirish beradi:

SyntaxWarning: "is" with a literal. Did you mean "=="?

2.6. Bir vaqtda bir nechta o'zlashtirish

Zanjirli:

a = b = c = 0
print(a, b, c)      # 0 0 0

Uchala yorliq bitta obyektga. Sonlar uchun xavfsiz (ular o'zgarmas). Lekin:

a = b = []          # ❌ XAVFLI
a.append(1)
print(b)            # [1] — kutilmagan!

Ko'p qiymatli:

ism, yosh, shahar = "Ali", 25, "Toshkent"
print(ism)          # Ali
print(yosh)         # 25

Bu — juda qulay va Pythonda keng ishlatiladi.

Almashtirish — Pythonning chiroyli jihati:

a = 1
b = 2
a, b = b, a         # almashtirish
print(a, b)         # 2 1

Boshqa tillarda vaqtinchalik o'zgaruvchi kerak:

temp = a
a = b
b = temp

Pythonda bir qator. Nega ishlaydi? O'ng tomon avval to'liq hisoblanadi (2.3-bo'lim) — (2, 1) juftligi yaratiladi, keyin taqsimlanadi.

Yulduzcha bilan:

birinchi, *qolgani = [1, 2, 3, 4, 5]
print(birinchi)     # 1
print(qolgani)      # [2, 3, 4, 5]

6-qismda batafsil.

2.7. O'zgaruvchi o'chirish

x = 5
del x
print(x)            # NameError: name 'x' is not defined

del obyektni o'chirmaydi — u yorliqni olib tashlaydi:

a = [1, 2, 3]
b = a
del a
print(b)            # [1, 2, 3] — obyekt tirik, chunki b hali ishora qilyapti

Obyekt hech kimga kerak bo'lmaganda Python uni o'zi tozalaydi.

del kam ishlatiladi. Odatda kerak emas — Python xotirani o'zi boshqaradi.

2.8. Dinamik turlash — takrorlash va chuqurlashtirish

1.3-darsda aytgandik: Pythonda tur o'zgaruvchida emas, obyektda.

x = 5               # x → int obyekt
x = "salom"         # x → str obyekt
x = [1, 2]          # x → list obyekt
x = None            # x → NoneType obyekt

Hech qanday xato yo'q. x — shunchaki yorliq, u istalgan narsaga yopishishi mumkin.

Solishtiring C bilan:

int x = 5;
x = "salom";        // Xato: int ga satr o'zlashtirib bo'lmaydi

Bu — kuch, lekin xavf ham:

def hisobla(narx, soni):
    return narx * soni

hisobla(1000, 3)        # 3000 — to'g'ri
hisobla("1000", 3)      # '100010001000' — XATO EMAS, lekin noto'g'ri!

Ikkinchisi xato bermadi, chunki "1000" * 3 Pythonda haqiqiy amal (satrni takrorlash). Natija esa mantiqan noto'g'ri.

Aynan shuning uchun tur ishoralari paydo bo'lgan (2.7-darsda ko'rgan, 13-qismda o'rganamiz):

def hisobla(narx: int, soni: int) -> int:
    return narx * soni

Endi Pylance ogohlantiradi.

2.9. O'zgaruvchi va xotira — 1.1-darsga qaytish

1.1-darsda RAM haqida gapirgandik. Endi buni bog'laymiz:

ism = "Sarvar"
yosh = 25

Xotirada nima bo'ldi:

                    RAM
  ┌───────────────────────────────────────┐
  │                                       │
  │   0x7f8a1c00:  str obyekt             │
  │                ├── turi:   str        │
  │                ├── hisob:  1          │
  │                └── qiymat: "Sarvar"   │
  │                                       │
  │   0x7f8a1c40:  int obyekt             │
  │                ├── turi:   int        │
  │                ├── hisob:  1          │
  │                └── qiymat: 25         │
  │                                       │
  └───────────────────────────────────────┘

  Nomlar jadvali (namespace):
    "ism"  → 0x7f8a1c00
    "yosh" → 0x7f8a1c40

Uch muhim jihat:

1. Har bir obyekt o'z turini bilib yuradi — shuning uchun type(x) ishlaydi
2. Har bir obyektda havolalar hisobi bor — nechta yorliq unga ishora qilyapti
3. Nomlar alohida jadvalda saqlanadi — obyektlar bilan bog'lanmagan

Hisob nolga tushganda obyekt o'chiriladi. Bu — havolalarni sanash usuli (11-qismda batafsil).

import sys

x = [1, 2, 3]
print(sys.getrefcount(x))   # 2 (x + getrefcount ning vaqtinchalik havolasi)

y = x
print(sys.getrefcount(x))   # 3

del y
print(sys.getrefcount(x))   # 2

3. Tez ma'lumotnoma

O'zlashtirish

x = 5                       # oddiy
a = b = c = 0               # zanjirli (o'zgarmas turlar uchun xavfsiz)
ism, yosh = "Ali", 25       # ko'p qiymatli
a, b = b, a                 # almashtirish
birinchi, *qolgani = [1,2,3]# yulduzcha bilan
del x                       # yorliqni o'chirish

Tekshirish

type(x)         turi
id(x)           identifikator
x is y          bir xil obyektmi
x == y          bir xil qiymatmi

Asosiy model

Python:  x = 5    →  x YORLIQ, 5 OBYEKT
         b = a    →  yangi obyekt EMAS, ikkinchi yorliq

is  →  bir xil obyekt
==  →  bir xil qiymat

is ni faqat None/True/False bilan ishlating

4. Batafsil misollar

Misol 1 — Yorliq modelini o'z ko'zingiz bilan ko'rish

a = [1, 2, 3]
b = a

print(f"a = {a}, id = {id(a)}")
print(f"b = {b}, id = {id(b)}")
print(f"a is b: {a is b}")

a = [1, 2, 3], id = 140234567891200
b = [1, 2, 3], id = 140234567891200
a is b: True

Bir xil id — bitta obyekt.

b.append(4)
print(f"a = {a}")           # [1, 2, 3, 4] — a ham o'zgardi!

Endi yorliqni ko'chiramiz:

b = [9, 9]
print(f"a = {a}, id = {id(a)}")
print(f"b = {b}, id = {id(b)}")
print(f"a is b: {a is b}")

a = [1, 2, 3, 4], id = 140234567891200
b = [9, 9], id = 140234567894800
a is b: False

Xulosa:

Nima ko'rsatdi: 2.2, 2.3, 2.4-bo'limlar. Bu — Pythondagi eng muhim modellardan biri.

Misol 2 — Kichik sonlar tuzog'i

a = 100
b = 100
print(f"100: a is b → {a is b}")

c = 1000
d = 1000
print(f"1000: c is d → {c is d}")

e = 256
f = 256
print(f"256: e is f → {e is f}")

g = 257
h = 257
print(f"257: g is h → {g is h}")

100:  a is b → True
1000: c is d → False
256:  e is f → True
257:  g is h → False

Chegara aniq ko'rinyapti: 256 gacha keshlangan, 257 dan boshlab yo'q.

Chegarani topish:

for son in [255, 256, 257, 258]:
    a = son
    b = son
    print(f"{son}: {a is b}")

Diqqat: bu kodni faylda ishga tushiring, REPL'da emas. REPL'da natija boshqacha bo'lishi mumkin, chunki bir qatordagi bir xil doimiylar boshqacha optimallashtiriladi.

Amaliy xulosa: is ni sonlar bilan hech qachon ishlatmang.

if son is 256:      # ❌ ba'zan ishlaydi, ba'zan yo'q — eng yomon xato turi
if son == 256:      # ✅

Nima ko'rsatdi: 2.4 va 2.5-bo'limlar. Bu — "ba'zan ishlaydigan" xatolarning klassik manbai.

Misol 3 — Amaliy dastur: do'kon hisobi

"""Do'kon xaridini hisoblaydigan dastur."""

# Doimiylar — o'zgarmaydigan qiymatlar (3.2-darsda batafsil)
QQS_FOIZI = 0.12
CHEGIRMA_CHEGARASI = 500_000
CHEGIRMA_FOIZI = 0.05

# Ma'lumotlar
mahsulot = "Klaviatura"
narx = 250_000
soni = 3

# Hisob
summa = narx * soni
chegirma = summa * CHEGIRMA_FOIZI if summa >= CHEGIRMA_CHEGARASI else 0
chegirmadan_keyin = summa - chegirma
qqs = chegirmadan_keyin * QQS_FOIZI
jami = chegirmadan_keyin + qqs

# Natija
print(f"Mahsulot:       {mahsulot}")
print(f"Narx:           {narx:,} so'm")
print(f"Soni:           {soni}")
print(f"Summa:          {summa:,} so'm")
print(f"Chegirma:      -{chegirma:,.0f} so'm")
print(f"QQS ({QQS_FOIZI:.0%}):       {qqs:,.0f} so'm")
print(f"JAMI:           {jami:,.0f} so'm")

Mahsulot:       Klaviatura
Narx:           250,000 so'm
Soni:           3
Summa:          750,000 so'm
Chegirma:      -37,500 so'm
QQS (12%):       85,500 so'm
JAMI:           798,000 so'm

Kodda nima ko'rish kerak:

• Doimiylar KATTA HARF bilan — bu Python kelishuvi (3.2-dars)
• Har bosqich alohida o'zgaruvchida — nosozlik izlash oson
• 250_000 — pastki chiziq o'qishni osonlashtiradi
• {narx:,} — mingliklarni ajratadi. {qqs:,.0f} — kasrsiz. 3.13-darsda batafsil
• ... if ... else ... — shartli ifoda. 5-qismda batafsil

Endi narxni bir joyda o'zgartiring — butun hisob yangilanadi. Bu — o'zgaruvchilarning asosiy foydasi.

Nima ko'rsatdi: 2.1-bo'lim. Amaliy dasturda o'zgaruvchilar shunday ishlaydi.

Misol 4 — is va == farqi

# 1. Bir xil mazmun, turli obyekt
a = [1, 2, 3]
b = [1, 2, 3]

print(f"a == b  →  {a == b}")     # True  — mazmuni bir xil
print(f"a is b  →  {a is b}")     # False — turli obyekt

# 2. Bitta obyekt
c = a
print(f"a is c  →  {a is c}")     # True

# 3. None bilan — bu yerda IS to'g'ri
qiymat = None
print(f"qiymat is None  →  {qiymat is None}")     # ✅ to'g'ri usul
print(f"qiymat == None  →  {qiymat == None}")     # ishlaydi, lekin noto'g'ri uslub

# 4. Satrlar — kutilmagan natija
s1 = "salom"
s2 = "salom"
print(f"s1 is s2  →  {s1 is s2}")                 # ehtimol True — internlash

s3 = "salom dunyo!"
s4 = "salom dunyo!"
print(f"s3 is s4  →  {s3 is s4}")                 # ehtimol False

Satrlar bilan nima bo'lyapti? Python oddiy (harf va raqamdan iborat) satrlarni internlaydi — bir xil satrni bir marta saqlaydi. Bo'sh joy va tinish belgisi bo'lsa — odatda internlamaydi.

Bu ham — CPython optimizatsiyasi, kafolat emas.

Yakuniy qoida:

• is None, is not None, is True, is False → to'g'ri
• Boshqa hamma joyda → ==

Nima ko'rsatdi: 2.4 va 2.5-bo'limlar.

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

6. Keng tarqalgan xatolar va yechimlari

1. NameError: name 'x' is not defined

Sabablar:

• Imlo xatosi → Python 3.11+ Did you mean: beradi
• O'zgaruvchi ishlatilishidan keyin e'lon qilingan
• Boshqa qamrovda (funksiya ichida) e'lon qilingan (7-qism)

print(natija)       # ❌ hali yo'q
natija = 5

2. Ro'yxatni "nusxalab", asl nusxa o'zgarib qoldi

asl = [1, 2, 3]
nusxa = asl             # ❌ nusxa emas!
nusxa.append(4)
print(asl)              # [1, 2, 3, 4]

Yechim — haqiqiy nusxa:

nusxa = asl.copy()      # ✅
nusxa = asl[:]          # ✅ kesim orqali
nusxa = list(asl)       # ✅

Chuqur nusxa (ichma-ich ro'yxatlar uchun) — 6-qismda.

3. SyntaxWarning: "is" with a literal

if x is 5:              # ❌
if x == 5:              # ✅

4. a = b = [] bilan kutilmagan holat

a = b = []              # ❌ bitta ro'yxat
a.append(1)
print(b)                # [1]

Yechim:

a = []
b = []                  # ✅ ikkita alohida

5. SyntaxError: cannot assign to literal

5 = x                   # ❌ teskari
x = 5                   # ✅

O'zlashtirishda nom chapda, qiymat o'ngda.

6. UnboundLocalError

son = 10

def oshir():
    son = son + 1       # ❌ UnboundLocalError
    return son

Sabab: funksiya ichida o'zlashtirish bo'lsa, Python son ni mahalliy deb hisoblaydi. 7-qismda to'liq tushuntiramiz.

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 3.2-dars: nomlash qoidalari — o'zgaruvchiga qanday nom berish
• 3.3–3.7: har bir tur (int, float, bool, None, str) — bularning hammasi obyekt
• 3.8-dars: type() — obyekt turini bilish
• 6-qism: ro'yxat va lug'atlar — yorliq modeli u yerda hal qiluvchi ahamiyatga ega
• 7-qism: funksiyalar, qamrov, argument uzatish — yana yorliqlar
• 8-qism: obyektlar — self, atributlar, havolalar
• 11-qism: xotira boshqaruvi, havolalarni sanash, axlat yig'ish

8. Eng yaxshi amaliyotlar

1. "Yorliq" modelida o'ylang, "quti" da emas. Bu bitta fikr o'zgarishi ko'p kelajakdagi chalkashlikni oldini oladi.

2. is ni faqat None, True, False bilan ishlating. Qolgan hamma joyda ==.

3. Ro'yxatni nusxalash kerak bo'lsa, aniq nusxalang. b = a nusxa emas.

4. Har bosqichni alohida o'zgaruvchida saqlang. Uzun bir qatorli ifoda tez yoziladi, lekin xatoni topish qiyin.

5. del ni kamdan-kam ishlating. Python xotirani o'zi boshqaradi.

6. Bir o'zgaruvchiga bir ma'no bering. x avval son, keyin satr bo'lsa — kodni o'qish qiyinlashadi.

9. Amaliy topshiriq

Vazifa 1: Yorliq modelini sinash

a = [1, 2, 3]
b = a
c = a.copy()

b.append(4)
c.append(5)

print("a =", a)
print("b =", b)
print("c =", c)

Natijani oldindan bashorat qiling, keyin ishga tushiring.

a = [1, 2, 3, 4]
b = [1, 2, 3, 4]
c = [1, 2, 3, 5]

Vazifa 2: id() bilan tekshirish

1-vazifadagi kodga id() chiqarishlarini qo'shing va tasdiqlang:

print(f"a: {id(a)}")
print(f"b: {id(b)}")
print(f"c: {id(c)}")

Qaysi ikkitasi bir xil?

Vazifa 3: Kichik sonlar chegarasi

2-misoldagi kodni faylga yozing va chegarani aniq toping. Nechada is False bo'la boshladi?

Vazifa 4: Almashtirish

Uchta o'zgaruvchini aylantiring — vaqtinchalik o'zgaruvchisiz:

a, b, c = 1, 2, 3
# a=3, b=1, c=2 bo'lsin

a, b, c = c, a, b

Vazifa 5: Amaliy dastur

3-misoldagi do'kon hisobini kengaytiring:

1. Ikkinchi mahsulot qo'shing
2. Ikkalasining umumiy summasini hisoblang
3. Chegirma umumiy summaga qo'llanilsin
4. Har bir mahsulot uchun alohida qator chiqarsin

Vazifa 6: is va == mashqi

Har biri True yoki False? Oldin bashorat qiling.

a = [1, 2]
b = [1, 2]
c = a

1.  a == b
2.  a is b
3.  a == c
4.  a is c
5.  None is None
6.  "abc" == "abc"
7.  [] == []
8.  [] is []

Vazifa 7: Xotira tajribasi

import sys

x = [1, 2, 3]
print("1:", sys.getrefcount(x))

y = x
print("2:", sys.getrefcount(x))

z = x
print("3:", sys.getrefcount(x))

del y
print("4:", sys.getrefcount(x))

Sonlar qanday o'zgardi va nega?

Nimani mustahkamlaydi: 2.2, 2.3, 2.4, 2.5, 2.6, 2.9-bo'limlar.

Xulosa

Bu darsda o'zgaruvchi tushunchasini to'g'ri modelda o'rgandik.

Eng muhim uch fikr:

1. O'zgaruvchi — quti emas, yorliq. b = a nusxa yaratmaydi, ikkinchi yorliq yaratadi. Bu bitta tushunish o'nlab kelajakdagi chalkashlikni oldini oladi.

2. is — bir xil obyekt, == — bir xil qiymat. is ni faqat None, True, False bilan ishlating. Kichik sonlar keshi is ni "ba'zan ishlaydigan" qiladi — bu eng yomon xato turi.

3. Tur obyektda, o'zgaruvchida emas. Shuning uchun x bugun son, ertaga satr bo'lishi mumkin. Kuch — lekin ehtiyot kerak.

Keyingi darsda nomlash qoidalarini o'rganamiz: o'zgaruvchiga qanday nom berish, nega bu shunchalik muhim va Python jamoasi qanday kelishuvlarga amal qiladi.