5.2-dars: Qo'riqchi shart va kod tuzilmasi
5-QISM — BOSHQARUV OQIMI · 2-dars
1. Kirish va motivatsiya
1-darsda qo'riqchi shart bilan tanishdik. Bu darsda uni to'liq o'rganamiz — chunki bu bitta naqsh kod sifatiga eng katta ta'sir ko'rsatadi.
Nega bu shunchalik muhim?
Chunki murakkablik chekinish darajasida ko'rinadi.
def f(a, b, c, d):
if a:
if b:
if c:
if d:
return "hammasi joyida"Bu funksiyani tushunish uchun to'rt shartni bir vaqtda yodda tutish kerak. Miya buni yomon uddalaydi.
def f(a, b, c, d):
if not a:
return "a yo'q"
if not b:
return "b yo'q"
if not c:
return "c yo'q"
if not d:
return "d yo'q"
return "hammasi joyida"Bu yerda har bir qatorni alohida o'qish mumkin. Yodda tutish kerak bo'lgan kontekst — nol.
Bu darsda:
- Sikloмatik murakkablik — qanday o'lchanadi
- Qo'riqchi shart — qachon va qanday
- Erta qaytish va uning chegaralari
- Shartlarni ajratish va nomlash
elseqachon kerak, qachon ortiqcha- Murakkab mantiqni tekislash usullari
2. Nazariya — chuqur tushuntirish
2.1. Nima uchun chuqur ichma-ich yomon
1. Kognitiv yuk.
Har bir if — yodda tutiladigan kontekst:
if user.faol: # ← yodda: user faol
if mahsulot.mavjud: # ← yodda: user faol VA mahsulot mavjud
if soni > 0: # ← yodda: uchtasi
if balans >= narx: # ← yodda: to'rttasi
...Psixologiyada bu — ishchi xotira chegarasi: odam bir vaqtda ~4-7 elementni ushlab tura oladi.
2. Xato xabarlari uzoqda.
if a:
if b:
if c:
asosiy_mantiq()
else:
return "c yo'q" # ← c tekshiruvidan 2 qator uzoq
else:
return "b yo'q" # ← b tekshiruvidan 5 qator uzoq
else:
return "a yo'q" # ← a tekshiruvidan 8 qator uzoqQaysi else qaysi if ga tegishli — sanash kerak.
3. O'zgartirish qiyin.
Yangi tekshiruv qo'shish — butun tuzilmani qayta chekintirish.
4. Test qilish qiyin.
Har bir yo'l uchun alohida test kerak. Chuqurlik oshgani sari yo'llar soni eksponensial o'sadi.
2.2. Siklomatik murakkablik
Siklomatik murakkablik — kod bo'ylab mustaqil yo'llar soni.
Hisoblash: 1 + (qaror nuqtalari soni)
Qaror nuqtalari: if, elif, for, while, and, or, except, uchlik operator.
def f(a, b): # 1
if a: # +1 = 2
if b: # +1 = 3
return 1
return 2
return 3Murakkablik: 3.
Tavsiya etiladigan chegaralar:
| Murakkablik | Baho |
|---|---|
| 1–5 | Sodda |
| 6–10 | Maqbul |
| 11–20 | Murakkab — bo'lish haqida o'ylang |
| 21+ | Juda murakkab — albatta bo'ling |
Muhim: qo'riqchi shart murakkablikni kamaytirmaydi — u bir xil qoladi:
# Murakkablik: 5
def f(a, b, c, d):
if a:
if b:
if c:
if d:
return "ok"
# Murakkablik: 5 (bir xil)
def f(a, b, c, d):
if not a: return "a"
if not b: return "b"
if not c: return "c"
if not d: return "d"
return "ok"Lekin kognitiv murakkablik — odam uchun tushunish qiyinligi — sezilarli kamayadi. Chunki chekinish darajasi tekis.
O'lchash:
pip install radon
radon cc main.py -sRuff ham tekshiradi:
[tool.ruff.lint]
select = ["C90"]
[tool.ruff.lint.mccabe]
max-complexity = 102.3. Qo'riqchi shart naqshi
Qoida:
Xato va maxsus holatlarni boshida hal qiling. Asosiy mantiq oxirida, eng kam chekinishda bo'lsin.
def qayta_ishla(malumot):
# 1. Qo'riqchi shartlar — xato holatlar
if malumot is None:
return xato("Ma'lumot yo'q")
if not malumot:
return xato("Ma'lumot bo'sh")
if not tekshir(malumot):
return xato("Format noto'g'ri")
# 2. Asosiy mantiq — bir daraja chekinish
natija = hisobla(malumot)
saqla(natija)
return muvaffaqiyat(natija)Tuzilma:
┌─────────────────────────┐
│ Qo'riqchi shartlar │ ← xato holatlar, erta chiqish
│ (bir necha qator) │
├─────────────────────────┤
│ │
│ Asosiy mantiq │ ← "baxtli yo'l"
│ (funksiyaning maqsadi) │
│ │
└─────────────────────────┘"Baxtli yo'l" (happy path) — hamma narsa yaxshi ketgan holat. U eng ko'rinadigan joyda bo'lishi kerak.
Qo'riqchi shart shakllari:
# 1. return bilan
if xato_shart:
return sukut_qiymat
# 2. raise bilan
if xato_shart:
raise ValueError("Sabab")
# 3. continue bilan (siklda)
for x in royxat:
if not tekshir(x):
continue
ishla(x)
# 4. break bilan (siklda)
while True:
if tugadi():
break
davom_et()2.4. return va raise — qaysi biri
return — "topilmaslik" normal holat bo'lsa:
def foydalanuvchi_topish(user_id: int) -> User | None:
if user_id not in BAZA:
return None # normal holat
return BAZA[user_id]raise — bu xato bo'lsa:
def foydalanuvchi_olish(user_id: int) -> User:
if user_id not in BAZA:
raise KeyError(f"Foydalanuvchi topilmadi: {user_id}")
return BAZA[user_id]Standart kutubxona ikkalasini ham beradi (3.6-dars):
lugat.get("kalit") # None
lugat["kalit"] # KeyErrorQoida:
| Vaziyat | Yechim |
|---|---|
| Chaqiruvchi kutishi mumkin | return None |
| Dasturchi xatosi | raise |
| Ma'lumot xatosi | raise yoki return — kontekstga qarab |
| Kutubxona API | Ikkalasini bering |
Xato xabarini yo'qotmang:
# ❌ Nima noto'g'ri ekani noma'lum
if not tekshir(malumot):
return None
# ✅ Aniq
if not tekshir(malumot):
raise ValueError(f"Noto'g'ri format: {malumot!r}")
# ✅ Yoki natija obyekti
if not tekshir(malumot):
return Natija(muvaffaqiyat=False, xato="Format noto'g'ri")9-qismda istisnolarni to'liq o'rganamiz.
2.5. Shartlarni ajratish va nomlash
Murakkab shart — nomlangan o'zgaruvchiga:
# ❌ O'qish qiyin
if (user.yosh >= 18 and user.faol and not user.bloklangan
and user.email_tasdiq and user.balans > 0):
...
# ✅ Nomlangan
voyaga_yetgan = user.yosh >= 18
hisob_ishlaydi = user.faol and not user.bloklangan
tasdiqlangan = user.email_tasdiq
mablag_bor = user.balans > 0
if voyaga_yetgan and hisob_ishlaydi and tasdiqlangan and mablag_bor:
...Yoki funksiyaga:
def buyurtma_bera_oladimi(user: User) -> bool:
"""Foydalanuvchi buyurtma bera oladimi."""
return (
user.yosh >= 18
and user.faol
and not user.bloklangan
and user.email_tasdiq
and user.balans > 0
)
if buyurtma_bera_oladimi(user):
...Afzalliklari:
- Nom — bepul hujjat (3.2-dars)
- Alohida test qilish mumkin
- Qayta ishlatish mumkin
- Nosozlik izlash oson
Lekin qisqa tutashuvni yo'qotmang:
# ❌ Barcha shart hisoblanadi
voyaga_yetgan = user.yosh >= 18
qimmat_tekshiruv = bazadan_tekshir(user) # user yo'q bo'lsa ham chaqiriladi
if voyaga_yetgan and qimmat_tekshiruv:
...
# ✅ Qisqa tutashuv saqlanadi
if user.yosh >= 18 and bazadan_tekshir(user):
...Nomlash — arzon shartlar uchun. Qimmat amallarni shart ichida qoldiring (3.5-dars).
2.6. else — qachon kerak
Ortiqcha else:
def baho(ball):
if ball >= 60:
return "O'tdi"
else: # ortiqcha — return dan keyin
return "O'tmadi"Ruff: RET505.
Zarur else — simmetriya:
if shart:
a = 1
else:
a = 2Bu yerda ikkala tarmoq teng — else mantiqni aks ettiradi.
Zarur else — elif zanjirida:
if ball >= 90:
baho = "A'lo"
elif ball >= 71:
baho = "Yaxshi"
else:
baho = "Qoniqarsiz" # "qolgan hamma holat"Qoida:
ifblokireturn,raise,breakyokicontinuebilan tugasa —elseortiqcha.
Uchlik operator bilan (4-darsda batafsil):
a = 1 if shart else 2 # ✅ qisqa holatda2.7. Ijobiy shartlarni afzal ko'ring
# ❌ Ikki karra inkor
if not user.nofaol:
...
# ✅ Ijobiy
if user.faol:
...# ❌ Inkor bilan boshlash
if not (a and b):
xato()
else:
ishla()
# ✅ De Morgan qonuni
if a and b:
ishla()
else:
xato()De Morgan qonunlari:
not (a and b) ≡ (not a) or (not b)
not (a or b) ≡ (not a) and (not b)# Bir xil
if not (yosh >= 18 and faol):
if yosh < 18 or not faol:Lekin qo'riqchi shartda inkor tabiiy:
def f(user):
if not user: # ✅ bu yerda inkor to'g'ri
return "Yo'q"
if not user.faol: # ✅
return "Bloklangan"
return asosiy_mantiq(user)Chunki qo'riqchi shart — "agar muammo bo'lsa chiqib ket".
2.8. Murakkab mantiqni tekislash usullari
1. Qo'riqchi shart (asosiy usul)
2. Funksiyaga ajratish:
# ❌ Bitta katta funksiya
def buyurtma_ishla(...):
# 50 qator tekshiruv
# 30 qator hisob
# 20 qator saqlash
# ✅ Bo'laklarga
def buyurtma_ishla(...):
xato = tekshiruvlar(...)
if xato:
return xato
natija = hisobla(...)
return saqla(natija)3. Lug'at bilan tarmoqlanish (1-dars):
ISHLOVCHILAR = {
"csv": csv_ishla,
"json": json_ishla,
"xml": xml_ishla,
}
ishlovchi = ISHLOVCHILAR.get(turi)
if ishlovchi is None:
raise ValueError(f"Noma'lum tur: {turi}")
return ishlovchi(malumot)4. Ro'yxat bilan tekshiruvlar:
TEKSHIRUVLAR = [
(lambda u: u is not None, "Foydalanuvchi yo'q"),
(lambda u: u.faol, "Hisob bloklangan"),
(lambda u: u.email_tasdiq, "Email tasdiqlanmagan"),
(lambda u: u.balans > 0, "Balans nol"),
]
def tekshir(user) -> str | None:
for shart, xabar in TEKSHIRUVLAR:
if not shart(user):
return xabar
return NoneYangi tekshiruv qo'shish — bir qator.
5. any / all (3.5-dars):
if all(t(user) for t, _ in TEKSHIRUVLAR):
...
if any(xato in xabar for xato in XAVFLI_SOZLAR):
...6. match/case (12-dars):
match javob:
case {"holat": "ok", "malumot": malumot}:
return malumot
case {"holat": "xato", "xabar": xabar}:
raise ValueError(xabar)
case _:
raise ValueError("Noma'lum javob")2.9. Erta qaytishning chegaralari
Qo'riqchi shart — kuchli, lekin universal emas.
Tozalash kerak bo'lsa:
# ❌ Erta qaytish resursni oqizadi
def f():
fayl = open("x.txt")
if shart:
return None # fayl yopilmadi!
malumot = fayl.read()
fayl.close()
return malumot
# ✅ with bilan
def f():
with open("x.txt") as fayl:
if shart:
return None # with fayl yopadi
return fayl.read()with — kontekst menejeri (10-qismda batafsil).
Ko'p qaytish nuqtasi — chalkashlik:
Ba'zi uslub qo'llanmalari "bitta qaytish nuqtasi" ni talab qiladi. Bu — eskirgan qoida (C dan qolgan, u yerda goto cleanup naqshi ishlatilardi).
Zamonaviy Pythonda bir necha qaytish nuqtasi normal — ayniqsa qo'riqchi shartda.
Lekin:
# ⚠️ 15 ta return — o'qish qiyin
def f(x):
if a: return 1
if b: return 2
...
if o: return 15Agar juda ko'p bo'lsa — lug'at yoki jadval ishlating.
Yon ta'sirlar tartibi:
def f(user):
log("Boshlandi")
if not user:
return # log yozildi, lekin ish qilinmadi
...Bu — maqsadli bo'lishi kerak. Qo'riqchi shartni yon ta'sirlardan oldin qo'ying:
def f(user):
if not user:
return
log("Boshlandi")
...3. Tez ma'lumotnoma
Qo'riqchi shart naqshi
def f(...):
if xato_1: return/raise # qo'riqchi shartlar
if xato_2: return/raise
if xato_3: return/raise
asosiy_mantiq() # "baxtli yo'l"Shakllari
return sukut funksiyada
raise Xato(...) xato holatida
continue siklda — keyingisiga
break siklda — chiqishreturn vs raise
return None — "topilmaslik" normal holat
raise — bu xato
Ikkalasi — kutubxona API'da (.get() va [])Murakkablik
1 + (if, elif, for, while, and, or, except, ternary)
1–5 ✅ sodda
6–10 ✅ maqbul
11–20 ⚠️ bo'lish haqida o'ylang
21+ ❌ albatta bo'ling
radon cc main.py -s
ruff: select = ["C90"], max-complexity = 10Tekislash usullari
1. Qo'riqchi shart
2. Funksiyaga ajratish
3. Lug'at bilan tarmoqlanish
4. Tekshiruvlar ro'yxati
5. any() / all()
6. match/caseChegaralar
Resurs tozalash → with ishlating
Yon ta'sirlar → qo'riqchi shartni OLDIN qo'ying
Juda ko'p return → lug'at/jadval4. Batafsil misollar
Misol 1 — Murakkablikni o'lchash
"""Siklomatik va kognitiv murakkablik."""
import ast
import inspect
def murakkablik(f) -> int:
"""Siklomatik murakkablikni hisoblaydi."""
manba = inspect.getsource(f)
# Chekinishni olib tashlash
import textwrap
daraxt = ast.parse(textwrap.dedent(manba))
hisob = 1
for tugun in ast.walk(daraxt):
if isinstance(tugun, (ast.If, ast.For, ast.While,
ast.ExceptHandler, ast.IfExp)):
hisob += 1
elif isinstance(tugun, ast.BoolOp):
hisob += len(tugun.values) - 1
return hisob
def max_chekinish(f) -> int:
"""Eng chuqur chekinish darajasini qaytaradi."""
import textwrap
manba = textwrap.dedent(inspect.getsource(f))
qatorlar = [q for q in manba.splitlines()
if q.strip() and not q.strip().startswith(("#", '"""', "def"))]
if not qatorlar:
return 0
return max((len(q) - len(q.lstrip())) // 4 for q in qatorlar)
# ═══ Sinov funksiyalari ═══
def ichma_ich(a, b, c, d):
if a:
if b:
if c:
if d:
return "ok"
return "d yo'q"
return "c yo'q"
return "b yo'q"
return "a yo'q"
def qoriqchi(a, b, c, d):
if not a:
return "a yo'q"
if not b:
return "b yo'q"
if not c:
return "c yo'q"
if not d:
return "d yo'q"
return "ok"
def jadval_bilan(a, b, c, d):
TEKSHIRUVLAR = [(a, "a yo'q"), (b, "b yo'q"),
(c, "c yo'q"), (d, "d yo'q")]
for shart, xabar in TEKSHIRUVLAR:
if not shart:
return xabar
return "ok"
def sodda(x):
return x * 2
def orta(x, y):
if x > y:
return x
return y
FUNKSIYALAR = [sodda, orta, jadval_bilan, qoriqchi, ichma_ich]
print(f" {'Funksiya':<16} {'Murakkablik':>12} {'Max chekinish':>15} {'Baho'}")
print(" " + "─" * 56)
for f in FUNKSIYALAR:
m = murakkablik(f)
ch = max_chekinish(f)
if m <= 5:
baho = "✅ sodda"
elif m <= 10:
baho = "✅ maqbul"
elif m <= 20:
baho = "⚠️ murakkab"
else:
baho = "❌ juda murakkab"
print(f" {f.__name__:<16} {m:>12} {ch:>15} {baho}")
print("\n\n=== Natijalar bir xil ===")
HOLATLAR = [
(True, True, True, True),
(True, True, True, False),
(True, False, True, True),
(False, True, True, True),
]
print(f" {'a':>6} {'b':>6} {'c':>6} {'d':>6} {'ichma_ich':<10} "
f"{'qoriqchi':<10} {'jadval':<10}")
print(" " + "─" * 62)
for a, b, c, d in HOLATLAR:
n1 = ichma_ich(a, b, c, d)
n2 = qoriqchi(a, b, c, d)
n3 = jadval_bilan(a, b, c, d)
assert n1 == n2 == n3
print(f" {a!s:>6} {b!s:>6} {c!s:>6} {d!s:>6} "
f"{n1:<10} {n2:<10} {n3:<10}")
print("""
⚠️ MUHIM: siklomatik murakkablik bir xil qoladi.
Lekin KOGNITIV murakkablik — odam uchun tushunish qiyinligi —
sezilarli farq qiladi:
ichma_ich: har qatorda 4 tagacha shartni yodda tutish kerak
qoriqchi: har qatorni ALOHIDA o'qish mumkin
jadval: mantiq ma'lumotga aylandi — yangi tekshiruv = 1 qator
""") Funksiya Murakkablik Max chekinish Baho
────────────────────────────────────────────────────────
sodda 1 1 ✅ sodda
orta 2 1 ✅ sodda
jadval_bilan 3 2 ✅ sodda
qoriqchi 5 1 ✅ sodda
ichma_ich 5 4 ✅ sodda
=== Natijalar bir xil ===
a b c d ichma_ich qoriqchi jadval
──────────────────────────────────────────────────────────────
True True True True ok ok ok
True True True False d yo'q d yo'q d yo'q
True False True True b yo'q b yo'q b yo'q
False True True True a yo'q a yo'q a yo'qNima ko'rsatdi: 2.1, 2.2-bo'limlar.
Misol 2 — Bosqichma-bosqich refaktoring
"""Bitta funksiya — to'rt bosqichda yaxshilash."""
from dataclasses import dataclass
from decimal import Decimal
@dataclass
class Foydalanuvchi:
ism: str
yosh: int = 25
faol: bool = True
bloklangan: bool = False
email_tasdiq: bool = True
balans: Decimal = Decimal("0")
@dataclass
class Mahsulot:
nom: str
narx: Decimal
qoldiq: int
faqat_18: bool = False
# ═══ 0-BOSQICH: dastlabki kod ═══
def buyurtma_v0(user, mahsulot, soni):
"""❌ Chuqur ichma-ich."""
if user is not None:
if user.faol and not user.bloklangan:
if user.email_tasdiq:
if mahsulot is not None:
if mahsulot.qoldiq >= soni:
if soni > 0:
if not mahsulot.faqat_18 or user.yosh >= 18:
summa = mahsulot.narx * soni
if user.balans >= summa:
return f"✅ {summa:,}"
else:
return "❌ Balans yetarli emas"
else:
return "❌ 18+ mahsulot"
else:
return "❌ Soni noto'g'ri"
else:
return "❌ Omborda yetarli emas"
else:
return "❌ Mahsulot yo'q"
else:
return "❌ Email tasdiqlanmagan"
else:
return "❌ Hisob ishlamaydi"
else:
return "❌ Foydalanuvchi yo'q"
# ═══ 1-BOSQICH: qo'riqchi shart ═══
def buyurtma_v1(user, mahsulot, soni):
"""✅ Tekis tuzilma."""
if user is None:
return "❌ Foydalanuvchi yo'q"
if not user.faol or user.bloklangan:
return "❌ Hisob ishlamaydi"
if not user.email_tasdiq:
return "❌ Email tasdiqlanmagan"
if mahsulot is None:
return "❌ Mahsulot yo'q"
if soni <= 0:
return "❌ Soni noto'g'ri"
if mahsulot.qoldiq < soni:
return "❌ Omborda yetarli emas"
if mahsulot.faqat_18 and user.yosh < 18:
return "❌ 18+ mahsulot"
summa = mahsulot.narx * soni
if user.balans < summa:
return "❌ Balans yetarli emas"
return f"✅ {summa:,}"
# ═══ 2-BOSQICH: funksiyalarga ajratish ═══
def _user_tekshir(user) -> str | None:
if user is None:
return "Foydalanuvchi yo'q"
if not user.faol or user.bloklangan:
return "Hisob ishlamaydi"
if not user.email_tasdiq:
return "Email tasdiqlanmagan"
return None
def _mahsulot_tekshir(mahsulot, soni) -> str | None:
if mahsulot is None:
return "Mahsulot yo'q"
if soni <= 0:
return "Soni noto'g'ri"
if mahsulot.qoldiq < soni:
return "Omborda yetarli emas"
return None
def buyurtma_v2(user, mahsulot, soni):
"""✅ Mantiqiy guruhlar."""
if xato := _user_tekshir(user):
return f"❌ {xato}"
if xato := _mahsulot_tekshir(mahsulot, soni):
return f"❌ {xato}"
if mahsulot.faqat_18 and user.yosh < 18:
return "❌ 18+ mahsulot"
summa = mahsulot.narx * soni
if user.balans < summa:
return "❌ Balans yetarli emas"
return f"✅ {summa:,}"
# ═══ 3-BOSQICH: tekshiruvlar jadvali ═══
TEKSHIRUVLAR = [
(lambda u, m, s: u is not None, "Foydalanuvchi yo'q"),
(lambda u, m, s: u.faol and not u.bloklangan, "Hisob ishlamaydi"),
(lambda u, m, s: u.email_tasdiq, "Email tasdiqlanmagan"),
(lambda u, m, s: m is not None, "Mahsulot yo'q"),
(lambda u, m, s: s > 0, "Soni noto'g'ri"),
(lambda u, m, s: m.qoldiq >= s, "Omborda yetarli emas"),
(lambda u, m, s: not m.faqat_18 or u.yosh >= 18, "18+ mahsulot"),
(lambda u, m, s: u.balans >= m.narx * s, "Balans yetarli emas"),
]
def buyurtma_v3(user, mahsulot, soni):
"""✅ Ma'lumotga asoslangan — yangi tekshiruv = 1 qator."""
for shart, xabar in TEKSHIRUVLAR:
if not shart(user, mahsulot, soni):
return f"❌ {xabar}"
return f"✅ {mahsulot.narx * soni:,}"
# ═══ SINOV ═══
HOLATLAR = [
(None, Mahsulot("Kitob", Decimal("50000"), 10), 2),
(Foydalanuvchi("Ali", bloklangan=True),
Mahsulot("Kitob", Decimal("50000"), 10), 2),
(Foydalanuvchi("Ali", email_tasdiq=False),
Mahsulot("Kitob", Decimal("50000"), 10), 2),
(Foydalanuvchi("Ali", balans=Decimal("1000000")), None, 2),
(Foydalanuvchi("Ali", balans=Decimal("1000000")),
Mahsulot("Kitob", Decimal("50000"), 10), 0),
(Foydalanuvchi("Ali", balans=Decimal("1000000")),
Mahsulot("Kitob", Decimal("50000"), 1), 5),
(Foydalanuvchi("Ali", yosh=16, balans=Decimal("1000000")),
Mahsulot("Vino", Decimal("50000"), 10, faqat_18=True), 2),
(Foydalanuvchi("Ali", balans=Decimal("10000")),
Mahsulot("Kitob", Decimal("50000"), 10), 2),
(Foydalanuvchi("Ali", balans=Decimal("1000000")),
Mahsulot("Kitob", Decimal("50000"), 10), 2),
]
VERSIYALAR = [
("v0 (ichma-ich)", buyurtma_v0),
("v1 (qo'riqchi)", buyurtma_v1),
("v2 (funksiyalar)", buyurtma_v2),
("v3 (jadval)", buyurtma_v3),
]
print("=== Barcha versiya bir xil natija beradi ===\n")
for user, mahsulot, soni in HOLATLAR:
natijalar = [f(user, mahsulot, soni) for _, f in VERSIYALAR]
assert len(set(natijalar)) == 1, f"Farq: {natijalar}"
u_nom = user.ism if user else "None"
m_nom = mahsulot.nom if mahsulot else "None"
print(f" {u_nom:<5} {m_nom:<7} soni={soni:<2} → {natijalar[0]}")
print("\n\n=== Solishtirish ===")
import inspect
import textwrap
print(f" {'Versiya':<20} {'Qatorlar':>10} {'Max chekinish':>15}")
print(" " + "─" * 48)
for nom, f in VERSIYALAR:
manba = textwrap.dedent(inspect.getsource(f))
qatorlar = [q for q in manba.splitlines()
if q.strip() and not q.strip().startswith(('"""', "#", "def"))]
ch = max((len(q) - len(q.lstrip())) // 4 for q in qatorlar)
print(f" {nom:<20} {len(qatorlar):>10} {ch:>15}")
print("""
Qaysi biri eng yaxshi? — KONTEKSTGA BOG'LIQ:
v1 (qo'riqchi) — eng ko'p holatda. Sodda va aniq
v2 (funksiyalar) — tekshiruvlar guruhlanadigan bo'lsa
v3 (jadval) — tekshiruvlar tez-tez o'zgarsa yoki
sozlanadigan bo'lishi kerak bo'lsa
v0 — hech qachon.
""")=== Barcha versiya bir xil natija beradi ===
None Kitob soni=2 → ❌ Foydalanuvchi yo'q
Ali Kitob soni=2 → ❌ Hisob ishlamaydi
Ali Kitob soni=2 → ❌ Email tasdiqlanmagan
Ali None soni=2 → ❌ Mahsulot yo'q
Ali Kitob soni=0 → ❌ Soni noto'g'ri
Ali Kitob soni=5 → ❌ Omborda yetarli emas
Ali Vino soni=2 → ❌ 18+ mahsulot
Ali Kitob soni=2 → ❌ Balans yetarli emas
Ali Kitob soni=2 → ✅ 100,000
=== Solishtirish ===
Versiya Qatorlar Max chekinish
────────────────────────────────────────────────
v0 (ichma-ich) 24 8
v1 (qo'riqchi) 19 1
v2 (funksiyalar) 11 1
v3 (jadval) 5 2Nima ko'rsatdi: 2.3, 2.5, 2.8-bo'limlar.
Misol 3 — return vs raise va xato xabarlari
"""Xato holatlarini qaytarishning uch usuli."""
from dataclasses import dataclass
from typing import Generic, TypeVar
T = TypeVar("T")
# ═══ 1-usul: None qaytarish ═══
def topish_none(baza: dict, kalit: str) -> str | None:
"""Topilmasa None — chaqiruvchi tekshiradi."""
if kalit not in baza:
return None
return baza[kalit]
# ═══ 2-usul: istisno ═══
def topish_raise(baza: dict, kalit: str) -> str:
"""Topilmasa xato — chaqiruvchi ushlaydi yoki qulaydi."""
if kalit not in baza:
raise KeyError(f"Topilmadi: {kalit!r}")
return baza[kalit]
# ═══ 3-usul: natija obyekti ═══
@dataclass
class Natija(Generic[T]):
"""Muvaffaqiyat yoki xato — ikkalasi ham qiymat."""
qiymat: T | None = None
xato: str | None = None
@property
def ok(self) -> bool:
return self.xato is None
def __bool__(self) -> bool:
return self.ok
def topish_natija(baza: dict, kalit: str) -> Natija[str]:
"""Natija obyekti — xato sababi bilan."""
if kalit not in baza:
return Natija(xato=f"Topilmadi: {kalit!r}")
return Natija(qiymat=baza[kalit])
BAZA = {"a": "birinchi", "b": "ikkinchi"}
print("=== 1. None qaytarish ===")
for kalit in ["a", "yoq"]:
natija = topish_none(BAZA, kalit)
if natija is None:
print(f" {kalit!r:<6} → topilmadi (sabab NOMA'LUM)")
else:
print(f" {kalit!r:<6} → {natija}")
print("\n=== 2. Istisno ===")
for kalit in ["a", "yoq"]:
try:
natija = topish_raise(BAZA, kalit)
print(f" {kalit!r:<6} → {natija}")
except KeyError as x:
print(f" {kalit!r:<6} → KeyError: {x}")
print("\n=== 3. Natija obyekti ===")
for kalit in ["a", "yoq"]:
natija = topish_natija(BAZA, kalit)
if natija:
print(f" {kalit!r:<6} → {natija.qiymat}")
else:
print(f" {kalit!r:<6} → {natija.xato}")
print("\n\n=== Qaysi birini qachon ===")
print("""
None qaytarish:
✅ "Topilmaslik" — normal, kutilgan holat
✅ Sodda API (dict.get)
❌ Sabab yo'qoladi
❌ Chaqiruvchi tekshirishni unutishi mumkin
Istisno:
✅ Sabab saqlanadi
✅ Tekshirishni unutib bo'lmaydi
✅ Stack trace bor
❌ Kutilgan holat uchun og'ir
❌ try/except kerak
Natija obyekti:
✅ Sabab saqlanadi
✅ Istisno xarajatisiz
✅ Zanjirlash mumkin
❌ Qo'shimcha tur
❌ Pythonda kam tarqalgan (Rust'da standart)
""")
print("=== Amaliy: tekshiruvlar zanjiri ===")
@dataclass
class Forma:
ism: str = ""
email: str = ""
yosh: str = ""
parol: str = ""
def formani_tekshir(forma: Forma) -> dict[str, str]:
"""Barcha xatoni bir vaqtda qaytaradi — erta qaytish EMAS."""
xatolar = {}
if not forma.ism.strip():
xatolar["ism"] = "Ism majburiy"
elif len(forma.ism.strip()) < 2:
xatolar["ism"] = "Ism juda qisqa"
if not forma.email.strip():
xatolar["email"] = "Email majburiy"
elif "@" not in forma.email:
xatolar["email"] = "Email formati noto'g'ri"
if not forma.yosh.strip():
xatolar["yosh"] = "Yosh majburiy"
elif not forma.yosh.isdecimal():
xatolar["yosh"] = "Yosh son bo'lishi kerak"
elif not 1 <= int(forma.yosh) <= 120:
xatolar["yosh"] = "Yosh 1-120 oralig'ida bo'lishi kerak"
if len(forma.parol) < 8:
xatolar["parol"] = "Parol kamida 8 belgi"
elif not any(c.isdigit() for c in forma.parol):
xatolar["parol"] = "Parolda raqam bo'lishi kerak"
return xatolar
FORMALAR = [
Forma("Ali", "ali@example.com", "25", "Salom123"),
Forma("", "notogri", "abc", "qisqa"),
Forma("A", "ali@example.com", "200", "parolsizraqam"),
]
for i, forma in enumerate(FORMALAR, 1):
xatolar = formani_tekshir(forma)
print(f"\n Forma #{i}:")
if not xatolar:
print(" ✅ Barcha maydon to'g'ri")
else:
for maydon, xato in xatolar.items():
print(f" ❌ {maydon:<8} {xato}")
print("""
⚠️ DIQQAT: bu yerda qo'riqchi shart ISHLATILMADI.
Sabab: foydalanuvchiga BARCHA xatoni bir vaqtda ko'rsatish kerak.
Erta qaytish faqat birinchi xatoni ko'rsatardi — bu yomon UX.
Qo'riqchi shart — universal emas. Kontekstga qarang.
""")=== 1. None qaytarish ===
'a' → birinchi
'yoq' → topilmadi (sabab NOMA'LUM)
=== 2. Istisno ===
'a' → birinchi
'yoq' → KeyError: "Topilmadi: 'yoq'"
=== 3. Natija obyekti ===
'a' → birinchi
'yoq' → Topilmadi: 'yoq'
=== Amaliy: tekshiruvlar zanjiri ===
Forma #1:
✅ Barcha maydon to'g'ri
Forma #2:
❌ ism Ism majburiy
❌ email Email formati noto'g'ri
❌ yosh Yosh son bo'lishi kerak
❌ parol Parol kamida 8 belgi
Forma #3:
❌ ism Ism juda qisqa
❌ yosh Yosh 1-120 oralig'ida bo'lishi kerak
❌ parol Parolda raqam bo'lishi kerakNima ko'rsatdi: 2.4, 2.9-bo'limlar. Muhim: qo'riqchi shart har doim to'g'ri emas.
Misol 4 — Shartlarni nomlash
"""Murakkab mantiqni o'qiladigan qilish."""
from dataclasses import dataclass
from datetime import date, timedelta
@dataclass
class Mijoz:
ism: str
yosh: int
royxat_sanasi: date
oxirgi_kirish: date
buyurtmalar: int
jami_xarid: int
qora_royxat: bool = False
email_tasdiq: bool = True
BUGUN = date(2026, 9, 8)
# ═══ ❌ O'qish qiyin ═══
def chegirma_yomon(m: Mijoz) -> int:
if (not m.qora_royxat and m.email_tasdiq and m.yosh >= 18
and (BUGUN - m.royxat_sanasi).days >= 365
and (BUGUN - m.oxirgi_kirish).days <= 30
and (m.buyurtmalar >= 10 or m.jami_xarid >= 5_000_000)):
return 15
elif (not m.qora_royxat and m.email_tasdiq
and (BUGUN - m.royxat_sanasi).days >= 180
and m.buyurtmalar >= 5):
return 10
elif not m.qora_royxat and m.buyurtmalar >= 1:
return 5
return 0
# ═══ ✅ Nomlangan shartlar ═══
def chegirma_yaxshi(m: Mijoz) -> int:
# Asosiy talablar
hisob_yaroqli = not m.qora_royxat
tasdiqlangan = m.email_tasdiq
voyaga_yetgan = m.yosh >= 18
# Vaqt bo'yicha
royxatda_kunlar = (BUGUN - m.royxat_sanasi).days
kirmagan_kunlar = (BUGUN - m.oxirgi_kirish).days
bir_yildan_kop = royxatda_kunlar >= 365
olti_oydan_kop = royxatda_kunlar >= 180
faol_mijoz = kirmagan_kunlar <= 30
# Xarid bo'yicha
kop_buyurtma = m.buyurtmalar >= 10
katta_xarid = m.jami_xarid >= 5_000_000
ortacha_buyurtma = m.buyurtmalar >= 5
hech_bolmasa_bitta = m.buyurtmalar >= 1
# Qo'riqchi shart
if not hisob_yaroqli:
return 0
# Darajalar — qat'iydan erkinga
if (tasdiqlangan and voyaga_yetgan and bir_yildan_kop
and faol_mijoz and (kop_buyurtma or katta_xarid)):
return 15
if tasdiqlangan and olti_oydan_kop and ortacha_buyurtma:
return 10
if hech_bolmasa_bitta:
return 5
return 0
# ═══ ✅✅ Funksiyalarga ajratilgan ═══
def _hisob_yaroqli(m: Mijoz) -> bool:
return not m.qora_royxat
def _platina_shartlari(m: Mijoz) -> bool:
royxatda = (BUGUN - m.royxat_sanasi).days
kirmagan = (BUGUN - m.oxirgi_kirish).days
return (
m.email_tasdiq
and m.yosh >= 18
and royxatda >= 365
and kirmagan <= 30
and (m.buyurtmalar >= 10 or m.jami_xarid >= 5_000_000)
)
def _oltin_shartlari(m: Mijoz) -> bool:
royxatda = (BUGUN - m.royxat_sanasi).days
return m.email_tasdiq and royxatda >= 180 and m.buyurtmalar >= 5
def chegirma_eng_yaxshi(m: Mijoz) -> int:
"""Mijoz darajasiga qarab chegirma foizini qaytaradi."""
if not _hisob_yaroqli(m):
return 0
if _platina_shartlari(m):
return 15
if _oltin_shartlari(m):
return 10
if m.buyurtmalar >= 1:
return 5
return 0
MIJOZLAR = [
Mijoz("Ali", 25, date(2024, 1, 1), date(2026, 9, 1), 15, 8_000_000),
Mijoz("Vali", 30, date(2025, 1, 1), date(2026, 9, 5), 7, 2_000_000),
Mijoz("Guli", 22, date(2026, 6, 1), date(2026, 9, 7), 2, 500_000),
Mijoz("Sardor", 28, date(2020, 1, 1), date(2026, 9, 1), 50, 20_000_000,
qora_royxat=True),
Mijoz("Dilnoza", 17, date(2024, 1, 1), date(2026, 9, 1), 20, 10_000_000),
Mijoz("Bekzod", 35, date(2020, 1, 1), date(2025, 1, 1), 30, 15_000_000),
Mijoz("Nigora", 26, date(2026, 9, 1), date(2026, 9, 8), 0, 0),
]
print(f" {'Mijoz':<10} {'Yosh':>5} {'Buyurt.':>8} {'Xarid':>12} "
f"{'Holat':<14} {'Chegirma':>9}")
print(" " + "─" * 64)
for m in MIJOZLAR:
ch1 = chegirma_yomon(m)
ch2 = chegirma_yaxshi(m)
ch3 = chegirma_eng_yaxshi(m)
assert ch1 == ch2 == ch3, f"Farq: {ch1}, {ch2}, {ch3}"
holat = "qora ro'yxat" if m.qora_royxat else "faol"
print(f" {m.ism:<10} {m.yosh:>5} {m.buyurtmalar:>8} "
f"{m.jami_xarid:>12,} {holat:<14} {ch3:>8}%")
print("""
Nomlangan shartlarning afzalliklari:
1. Nom — bepul hujjat
`bir_yildan_kop` vs `(BUGUN - m.royxat_sanasi).days >= 365`
2. Alohida test qilish mumkin
assert _platina_shartlari(mijoz) is True
3. Qayta ishlatish
Boshqa funksiyada ham kerak bo'lishi mumkin
4. Nosozlik izlash oson
print(f"{bir_yildan_kop=}, {faol_mijoz=}")
⚠️ Lekin: qisqa tutashuvni yo'qotmang.
Qimmat amallarni shart ichida qoldiring.
""") Mijoz Yosh Buyurt. Xarid Holat Chegirma
────────────────────────────────────────────────────────────────
Ali 25 15 8,000,000 faol 15%
Vali 30 7 2,000,000 faol 10%
Guli 22 2 500,000 faol 5%
Sardor 28 50 20,000,000 qora ro'yxat 0%
Dilnoza 17 20 10,000,000 faol 10%
Bekzod 35 30 15,000,000 faol 10%
Nigora 26 0 0 faol 0%Nima ko'rsatdi: 2.5-bo'lim.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
| "Qo'riqchi shart murakkablikni kamaytiradi" | Siklomatik — yo'q. Kognitiv — ha |
"Funksiyada bitta return bo'lishi kerak" |
Eskirgan C qoidasi. Pythonda ko'p return normal |
| "Qo'riqchi shart har doim to'g'ri" | Yo'q — barcha xatoni yig'ish kerak bo'lsa ishlamaydi |
"else doim ortiqcha" |
elif zanjirida va simmetrik holatda kerak |
| "Shartlarni nomlash sekinlashtiradi" | Deyarli yo'q. Lekin qisqa tutashuv yo'qoladi |
| "Erta qaytish resursni oqizadi" | with bilan yo'q |
| "Ichma-ich shart o'qishga oson" | 2-3 darajadan keyin — yo'q |
6. Keng tarqalgan xatolar va yechimlari
1. Chuqur ichma-ich
if a:
if b:
if c: # ❌
...
if not a: return
if not b: return
if not c: return # ✅
...2. Erta qaytishda resurs oqishi
fayl = open("x.txt") # ❌
if shart:
return # fayl yopilmadi
with open("x.txt") as fayl: # ✅
if shart:
return3. Xato sababini yo'qotish
if not tekshir(x):
return None # ❌ nima noto'g'ri?
if not tekshir(x):
raise ValueError(f"Noto'g'ri: {x!r}") # ✅4. Qo'riqchi shartni yon ta'sirdan keyin
def f(user):
log("Boshlandi") # ❌ user yo'q bo'lsa ham yoziladi
if not user:
return
def f(user):
if not user: # ✅
return
log("Boshlandi")5. Ortiqcha else
if x:
return 1
else: # ❌ RET505
return 2
if x:
return 1
return 2 # ✅6. Shartni nomlashda qisqa tutashuvni yo'qotish
tekshiruv = qimmat_amal() # ❌ har doim chaqiriladi
if user and tekshiruv:
...
if user and qimmat_amal(): # ✅
...7. Barcha xatoni yig'ish kerak bo'lganda erta qaytish
def forma_tekshir(f):
if not f.ism: return "Ism yo'q" # ❌ faqat birinchi xato
if not f.email: return "Email yo'q"
def forma_tekshir(f):
xatolar = {} # ✅ hammasi
if not f.ism: xatolar["ism"] = "..."
if not f.email: xatolar["email"] = "..."
return xatolar8. Ikki karra inkor
if not user.nofaol: # ❌
if user.faol: # ✅7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 5.1-dars (o'tilgan):
if/elif/elseasoslari - 5.3-dars: shartlarni birlashtirish, De Morgan
- 5.10-dars:
continuebilan qo'riqchi shart siklda - 7-qism: funksiyalar, erta qaytish, qisqa funksiyalar
- 9-qism: istisnolar,
try/except,raise - 31-qism: kod ko'rib chiqish — murakkablik birinchi e'tibor
- 10-qism:
with— resurs boshqaruvi - Har bir funksiyada: bu — kod sifatining asosiy o'lchovi
8. Eng yaxshi amaliyotlar
Xato holatlarini boshida hal qiling. "Baxtli yo'l" oxirida, eng kam chekinishda.
Chekinishni ikki darajada saqlashga harakat qiling. Uchdan oshsa — refaktoring signali.
Murakkab shartlarni nomlang. Nom — bepul hujjat. Lekin qisqa tutashuvni yo'qotmang.
Murakkablikni o'lchang.
ruffC90yokiradon. 10 dan oshsa — bo'ling.returndan keyinelseyozmang.RET505.Resurslar uchun
with. Erta qaytish xavfsiz bo'ladi.Barcha xatoni yig'ish kerak bo'lsa — qo'riqchi shart ishlatmang. Kontekstga qarang.
Ijobiy shartlarni afzal ko'ring.
if faol:if not nofaol:dan yaxshiroq.
9. Amaliy topshiriq
Vazifa 1: Murakkablikni hisoblang
def f(a, b, c):
if a and b:
for x in c:
if x > 0:
return x
elif x < 0:
continue
return NoneSiklomatik murakkablikni qo'lda hisoblang, keyin radon bilan tekshiring.
Javob
1 (asosiy)
+1 (if a and b)
+1 (and)
+1 (for)
+1 (if x > 0)
+1 (elif x < 0)
= 6Vazifa 2: Qo'riqchi shartga o'tkazish
def parol_ozgartir(user, eski, yangi, tasdiq):
if user is not None:
if user.faol:
if user.parol_tekshir(eski):
if len(yangi) >= 8:
if yangi == tasdiq:
if yangi != eski:
user.parol_ornat(yangi)
return "✅ Parol o'zgartirildi"
else:
return "❌ Yangi parol eskisi bilan bir xil"
else:
return "❌ Parollar mos kelmadi"
else:
return "❌ Parol qisqa"
else:
return "❌ Eski parol noto'g'ri"
else:
return "❌ Hisob bloklangan"
else:
return "❌ Foydalanuvchi topilmadi"Vazifa 3: Uch usulda yozing
2-vazifadagi funksiyani uch usulda qayta yozing:
- Qo'riqchi shart
- Tekshiruvlar jadvali
- Funksiyalarga ajratish
Har birining qatorlar sonini va max chekinishini solishtiring.
Vazifa 4: Shartlarni nomlash
def yetkazish_narxi(buyurtma, mijoz):
if (buyurtma.summa >= 500000 and mijoz.shahar == "Toshkent"
and buyurtma.ogirlik <= 5 and not buyurtma.tez_yetkazish):
return 0
elif (buyurtma.summa >= 1000000 and buyurtma.ogirlik <= 10
and not buyurtma.tez_yetkazish):
return 0
elif buyurtma.tez_yetkazish:
return 50000 if mijoz.shahar == "Toshkent" else 100000
else:
return 25000 if mijoz.shahar == "Toshkent" else 50000Barcha shartni nomlab, o'qiladigan qiling.
Vazifa 5: Forma tekshiruvi
Ro'yxatdan o'tish formasini tekshiruvchi yozing:
- Barcha xatoni bir vaqtda qaytarsin
- Har maydon uchun bir necha qoida bo'lsin
- Xatolar tartibi bashorat qilinadigan bo'lsin
- Tekshiruvlarni jadval sifatida saqlang
Vazifa 6: Natija obyekti
3-misoldagi Natija sinfini kengaytiring:
map(f)— muvaffaqiyat bo'lsa funksiyani qo'llaydithen(f)— zanjirlashor_else(sukut)— xato bo'lsa sukut qiymatunwrap()— qiymat yokiraise
Yechim
from dataclasses import dataclass
from typing import Callable, Generic, TypeVar
T = TypeVar("T")
U = TypeVar("U")
@dataclass
class Natija(Generic[T]):
qiymat: T | None = None
xato: str | None = None
@property
def ok(self) -> bool:
return self.xato is None
def __bool__(self) -> bool:
return self.ok
def map(self, f: Callable[[T], U]) -> "Natija[U]":
if not self.ok:
return Natija(xato=self.xato)
return Natija(qiymat=f(self.qiymat))
def then(self, f: Callable[[T], "Natija[U]"]) -> "Natija[U]":
if not self.ok:
return Natija(xato=self.xato)
return f(self.qiymat)
def or_else(self, sukut: T) -> T:
return self.qiymat if self.ok else sukut
def unwrap(self) -> T:
if not self.ok:
raise ValueError(self.xato)
return self.qiymatBu — Rust'dagi Result turining soddalashtirilgan varianti.
Vazifa 7: O'ylash
Nega "bitta qaytish nuqtasi" qoidasi eskirgan?
Javob
Bu qoida C tilidan kelgan va u yerda asosli edi.
C da resurslarni qo'lda boshqarish kerak:
FILE *f = fopen("x.txt", "r");
char *bufer = malloc(1024);
if (xato) {
free(bufer); // ← unutmaslik kerak
fclose(f); // ← bu ham
return -1;
}
// ... yana 5 ta erta qaytish, har birida tozalashHar bir erta qaytishda barcha resursni qo'lda tozalash kerak. Bitta unutish — xotira oqishi. Shuning uchun goto cleanup naqshi va "bitta qaytish nuqtasi" qoidasi paydo bo'ldi.
Pythonda bu muammo yo'q:
- Axlat yig'ish — xotira avtomatik tozalanadi (11-qism)
with— resurslar avtomatik yopiladi (10-qism)try/finally— kafolatlangan tozalash (9-qism)
with open("x.txt") as f:
if xato:
return None # ✅ fayl avtomatik yopiladi
return f.read()Va zamonaviy tadqiqotlar ko'rsatadi: erta qaytish kodni o'qish oson qiladi, chunki kognitiv yuk kamayadi.
Xulosa: qoida o'z kontekstida to'g'ri edi, lekin u kontekst o'zgardi. Kod uslubi qoidalarini sababini tushunmasdan ko'chirmang.
Nimani mustahkamlaydi: 2.2, 2.3, 2.4, 2.5, 2.8, 2.9-bo'limlar.
Xulosa
Bu darsda kod tuzilmasini o'rgandik.
Eng muhim uch fikr:
Xato holatlarini boshida hal qiling. Qo'riqchi shart chekinishni tekis saqlaydi va har bir tekshiruvni uning xatosi bilan yonma-yon qo'yadi. "Baxtli yo'l" — oxirida, eng ko'rinadigan joyda.
Siklomatik murakkablik o'zgarmaydi, kognitiv murakkablik kamayadi. Qo'riqchi shart yo'llar sonini kamaytirmaydi — u ularni odam o'qishi oson shaklga keltiradi.
Qo'riqchi shart universal emas. Barcha xatoni bir vaqtda ko'rsatish kerak bo'lsa (forma tekshiruvi) — u noto'g'ri. Naqshni sababini tushunib qo'llang.
Keyingi darsda shartlarni birlashtirishni o'rganamiz: and, or, not ni to'g'ri ishlatish, De Morgan qonunlari va murakkab mantiqiy ifodalarni soddalashtirish.
Izohlar · 0
Izoh yozish uchun kiring.