Python kursi5.2-dars: Qo'riqchi shart va kod tuzilmasi
Python kursi · Boshqaruv oqimi

5.2-dars: Qo'riqchi shart va kod tuzilmasi

28 daqiqa2/12-dars

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.

python
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.

python
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
  • else qachon 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:

python
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.

python
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 uzoq

Qaysi 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.

python
def f(a, b):                    # 1
    if a:                       # +1 = 2
        if b:                   # +1 = 3
            return 1
        return 2
    return 3

Murakkablik: 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:

python
# 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:

bash
pip install radon
radon cc main.py -s

Ruff ham tekshiradi:

toml
[tool.ruff.lint]
select = ["C90"]

[tool.ruff.lint.mccabe]
max-complexity = 10

2.3. Qo'riqchi shart naqshi

Qoida:

Xato va maxsus holatlarni boshida hal qiling. Asosiy mantiq oxirida, eng kam chekinishda bo'lsin.

python
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:

text
┌─────────────────────────┐
│  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:

python
# 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:

python
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:

python
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):

python
lugat.get("kalit")              # None
lugat["kalit"]                  # KeyError

Qoida:

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:

python
# ❌ 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:

python
# ❌ 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:

python
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:

python
# ❌ 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:

python
def baho(ball):
    if ball >= 60:
        return "O'tdi"
    else:                       # ortiqcha — return dan keyin
        return "O'tmadi"

Ruff: RET505.

Zarur else — simmetriya:

python
if shart:
    a = 1
else:
    a = 2

Bu yerda ikkala tarmoq teng — else mantiqni aks ettiradi.

Zarur else — elif zanjirida:

python
if ball >= 90:
    baho = "A'lo"
elif ball >= 71:
    baho = "Yaxshi"
else:
    baho = "Qoniqarsiz"         # "qolgan hamma holat"

Qoida:

if bloki return, raise, break yoki continue bilan tugasa — else ortiqcha.

Uchlik operator bilan (4-darsda batafsil):

python
a = 1 if shart else 2           # ✅ qisqa holatda

2.7. Ijobiy shartlarni afzal ko'ring

python
# ❌ Ikki karra inkor
if not user.nofaol:
    ...

# ✅ Ijobiy
if user.faol:
    ...
python
# ❌ Inkor bilan boshlash
if not (a and b):
    xato()
else:
    ishla()

# ✅ De Morgan qonuni
if a and b:
    ishla()
else:
    xato()

De Morgan qonunlari:

text
not (a and b)  ≡  (not a) or (not b)
not (a or b)   ≡  (not a) and (not b)
python
# Bir xil
if not (yosh >= 18 and faol):
if yosh < 18 or not faol:

Lekin qo'riqchi shartda inkor tabiiy:

python
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:

python
# ❌ 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):

python
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:

python
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 None

Yangi tekshiruv qo'shish — bir qator.

5. any / all (3.5-dars):

python
if all(t(user) for t, _ in TEKSHIRUVLAR):
    ...

if any(xato in xabar for xato in XAVFLI_SOZLAR):
    ...

6. match/case (12-dars):

python
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:

python
# ❌ 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:

python
# ⚠️ 15 ta return — o'qish qiyin
def f(x):
    if a: return 1
    if b: return 2
    ...
    if o: return 15

Agar juda ko'p bo'lsa — lug'at yoki jadval ishlating.

Yon ta'sirlar tartibi:

python
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:

python
def f(user):
    if not user:
        return
    log("Boshlandi")
    ...

3. Tez ma'lumotnoma

Qo'riqchi shart naqshi

python
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

python
return sukut        funksiyada
raise Xato(...)     xato holatida
continue            siklda — keyingisiga
break               siklda — chiqish

return vs raise

text
return None   — "topilmaslik" normal holat
raise         — bu xato
Ikkalasi      — kutubxona API'da (.get() va [])

Murakkablik

text
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 = 10

Tekislash usullari

text
1. Qo'riqchi shart
2. Funksiyaga ajratish
3. Lug'at bilan tarmoqlanish
4. Tekshiruvlar ro'yxati
5. any() / all()
6. match/case

Chegaralar

text
Resurs tozalash → with ishlating
Yon ta'sirlar → qo'riqchi shartni OLDIN qo'ying
Juda ko'p return → lug'at/jadval

4. Batafsil misollar

Misol 1 — Murakkablikni o'lchash

python
"""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
""")
text
  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'q

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

Misol 2 — Bosqichma-bosqich refaktoring

python
"""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.
""")
text
=== 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               2

Nima ko'rsatdi: 2.3, 2.5, 2.8-bo'limlar.

Misol 3 — return vs raise va xato xabarlari

python
"""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.
""")
text
=== 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 kerak

Nima ko'rsatdi: 2.4, 2.9-bo'limlar. Muhim: qo'riqchi shart har doim to'g'ri emas.

Misol 4 — Shartlarni nomlash

python
"""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.
""")
text
  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

python
if a:
    if b:
        if c:                   # ❌
            ...

if not a: return
if not b: return
if not c: return                # ✅
...

2. Erta qaytishda resurs oqishi

python
fayl = open("x.txt")            # ❌
if shart:
    return                      # fayl yopilmadi

with open("x.txt") as fayl:     # ✅
    if shart:
        return

3. Xato sababini yo'qotish

python
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

python
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

python
if x:
    return 1
else:                           # ❌ RET505
    return 2

if x:
    return 1
return 2                        # ✅

6. Shartni nomlashda qisqa tutashuvni yo'qotish

python
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

python
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 xatolar

8. Ikki karra inkor

python
if not user.nofaol:             # ❌
if user.faol:                   # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 5.1-dars (o'tilgan): if/elif/else asoslari
  • 5.3-dars: shartlarni birlashtirish, De Morgan
  • 5.10-dars: continue bilan 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

  1. Xato holatlarini boshida hal qiling. "Baxtli yo'l" oxirida, eng kam chekinishda.

  2. Chekinishni ikki darajada saqlashga harakat qiling. Uchdan oshsa — refaktoring signali.

  3. Murakkab shartlarni nomlang. Nom — bepul hujjat. Lekin qisqa tutashuvni yo'qotmang.

  4. Murakkablikni o'lchang. ruff C90 yoki radon. 10 dan oshsa — bo'ling.

  5. return dan keyin else yozmang. RET505.

  6. Resurslar uchun with. Erta qaytish xavfsiz bo'ladi.

  7. Barcha xatoni yig'ish kerak bo'lsa — qo'riqchi shart ishlatmang. Kontekstga qarang.

  8. Ijobiy shartlarni afzal ko'ring. if faol: if not nofaol: dan yaxshiroq.


9. Amaliy topshiriq

Vazifa 1: Murakkablikni hisoblang

python
def f(a, b, c):
    if a and b:
        for x in c:
            if x > 0:
                return x
            elif x < 0:
                continue
    return None

Siklomatik murakkablikni qo'lda hisoblang, keyin radon bilan tekshiring.

Javob
text
1 (asosiy)
+1 (if a and b)
+1 (and)
+1 (for)
+1 (if x > 0)
+1 (elif x < 0)
= 6

Vazifa 2: Qo'riqchi shartga o'tkazish

python
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:

  1. Qo'riqchi shart
  2. Tekshiruvlar jadvali
  3. Funksiyalarga ajratish

Har birining qatorlar sonini va max chekinishini solishtiring.

Vazifa 4: Shartlarni nomlash

python
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 50000

Barcha 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:

  1. map(f) — muvaffaqiyat bo'lsa funksiyani qo'llaydi
  2. then(f) — zanjirlash
  3. or_else(sukut) — xato bo'lsa sukut qiymat
  4. unwrap() — qiymat yoki raise
Yechim
python
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.qiymat

Bu — 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:

c
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 tozalash

Har 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:

  1. Axlat yig'ish — xotira avtomatik tozalanadi (11-qism)
  2. with — resurslar avtomatik yopiladi (10-qism)
  3. try/finally — kafolatlangan tozalash (9-qism)
python
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:

  1. 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.

  2. Siklomatik murakkablik o'zgarmaydi, kognitiv murakkablik kamayadi. Qo'riqchi shart yo'llar sonini kamaytirmaydi — u ularni odam o'qishi oson shaklga keltiradi.

  3. 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.

Boshqaruv oqimi · 2-dars yakunlandi

5.2-dars: Qo'riqchi shart va kod tuzilmasi

28 daqvaqt
0belgi
Keyingi dars: 5.3-dars: Shartlarni birlashtirish
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0