27.1-dars: Toza kod tamoyillari

Kod: 1 marta yoziladi, 10 marta o'qiladi
Toza: o'qish, tushunish, o'zgartirish oson
Iflos: ishlaydi, lekin chalkash (vaqt bombasi)

# yomon:
d = 30                    # d nima?
def calc(x, y): ...       # nima hisoblaydi?

# yaxshi:
kunlar_soni = 30
def hisobla_umumiy_narx(narx, soni): ...

# yomon: bir funksiya hammasini qiladi (100 qator)
def process(data):
    # tozalash + tekshirish + hisoblash + saqlash + yuborish

# yaxshi: har biri bitta ish
def tozala(data): ...
def tekshir(data): ...
def hisobla(data): ...

# yomon: takror (3 joyda bir xil hisob)
narx1 = asosiy * 1.12   # QQS
narx2 = boshqa * 1.12
narx3 = uchinchi * 1.12

# yaxshi: bir joyda
def qqs_bilan(narx): return narx * 1.12

# yomon: kod nimani takrorlaydi
i = i + 1   # i ni bittaga oshir

# yaxshi: nega (kod aytolmaydigan)
# QQS 2026 dan 12% (qonun o'zgardi)
soliq = narx * 0.12

# yomon: aqlli, lekin chalkash
r = [x for s in m for x in s if x % 2 == 0][::-1][:3]

# yaxshi: oddiy, ravshan
juftlar = [x for satr in m for x in satr if x % 2 == 0]
natija = juftlar[:3]

# izchil: bir xil uslub (PEP 8)
foydalanuvchi_nomi = "Ali"      # snake_case
class FoydalanuvchiHisobi: ...   # PascalCase
# formatlash: black, ruff (avtomatik)

# NOMLASH — niyatni ayt
d = 30                          # ⚠️
kunlar = 30                     # ✅
def calc(x): ...                # ⚠️
def hisobla_soliq(narx): ...    # ✅

# FUNKSIYA — bir ish (SRP)
def process(d): ...             # ⚠️ hammasi
def tozala(d): def hisobla(d):  # ✅ har biri bir ish

# DRY — bir joyda
x*1.12; y*1.12; z*1.12          # ⚠️ takror
def qqs(n): return n*1.12       # ✅

# KOMMENTARIY — nega
i += 1  # i ni oshir            # ⚠️ nima (takror)
# QQS qonun o'zgardi            # ✅ nega

# KISS — oddiy
[x for s in m for x in s][::-1] # ⚠️ chalkash
# oddiy, bir necha qator        # ✅

# IZCHIL — PEP 8, black, ruff
snake_case / PascalCase

Nomlash (niyat) · Kichik funksiya (bir ish) · DRY (bir joy)
Kommentariy (nega) · KISS (oddiy) · Izchillik (PEP 8, black)
Kod 1 marta yoziladi, 10 marta o'qiladi — o'quvchi uchun yoz

"""nomlash: aniq nom kodni o'z-o'zini tushuntiradigan qiladi."""


def yomon_uslub() -> int:
    # d, p, t — nima ekani noaniq
    d = 30
    p = 100
    t = d * p
    return t


def yaxshi_uslub() -> int:
    # nomlar niyatni aytadi
    kunlar_soni = 30
    kunlik_narx = 100
    umumiy_narx = kunlar_soni * kunlik_narx
    return umumiy_narx


def main() -> None:
    print("=== 1. Yomon nomlash natijasi ===")
    print(f"  natija: {yomon_uslub()} (lekin nima?)")

    print("\n=== 2. Yaxshi nomlash natijasi ===")
    print(f"  umumiy narx: {yaxshi_uslub()} (aniq)")

    print("\n=== 3. Nomlash qoidalari ===")
    qoidalar = [
        "aniq (nima ekani)",
        "talaffuz qilinadigan",
        "qidiriladigan (x emas)",
        "maqsadni ko'rsatgan",
    ]
    for i, q in enumerate(qoidalar, 1):
        print(f"  {i}. {q}")

    print("\n=== 4. Ikki uslub bir xil natija ===")
    print(f"  teng: {yomon_uslub() == yaxshi_uslub()}")
    print("  lekin yaxshisi — o'qish oson")
    print("  ⭐ nom — niyatni aytadi (yarim hujjat)")


if __name__ == "__main__":
    main()

=== 1. Yomon nomlash natijasi ===
  natija: 3000 (lekin nima?)

=== 2. Yaxshi nomlash natijasi ===
  umumiy narx: 3000 (aniq)

=== 3. Nomlash qoidalari ===
  1. aniq (nima ekani)
  2. talaffuz qilinadigan
  3. qidiriladigan (x emas)
  4. maqsadni ko'rsatgan

=== 4. Ikki uslub bir xil natija ===
  teng: True
  lekin yaxshisi — o'qish oson
  ⭐ nom — niyatni aytadi (yarim hujjat)

"""SRP: bir funksiya bir ish — o'qish, sinash, qayta ishlatish oson."""


def yomon_hammasi(malumot: list) -> dict:
    """Bir funksiya: tozala + tekshir + hisobla (ko'p ish)."""
    tozalangan = [x for x in malumot if x is not None]
    yaroqli = [x for x in tozalangan if x > 0]
    return {"jami": sum(yaroqli), "soni": len(yaroqli)}


# yaxshi: har biri bir ish
def tozala(malumot: list) -> list:
    return [x for x in malumot if x is not None]


def yaroqlilarni_ol(malumot: list) -> list:
    return [x for x in malumot if x > 0]


def hisobla(malumot: list) -> dict:
    return {"jami": sum(malumot), "soni": len(malumot)}


def main() -> None:
    xom = [10, None, -5, 20, None, 30]

    print("=== 1. Yomon (hammasi bir joyda) ===")
    print(f"  natija: {yomon_hammasi(xom)}")

    print("\n=== 2. Yaxshi (bir-bir qadam) ===")
    tozalangan = tozala(xom)
    print(f"  tozalangan: {tozalangan}")
    yaroqli = yaroqlilarni_ol(tozalangan)
    print(f"  yaroqli: {yaroqli}")
    print(f"  hisob: {hisobla(yaroqli)}")

    print("\n=== 3. Har funksiya alohida sinaladi ===")
    print(f"  tozala([1, None]): {tozala([1, None])}")
    print(f"  yaroqli([-1, 5]): {yaroqlilarni_ol([-1, 5])}")

    print("\n=== 4. Bir xil natija ===")
    print(f"  teng: {yomon_hammasi(xom) == hisobla(yaroqlilarni_ol(tozala(xom)))}")
    print("  ⭐ kichik funksiya — bir ish (o'qish, sinash oson)")


if __name__ == "__main__":
    main()

=== 1. Yomon (hammasi bir joyda) ===
  natija: {'jami': 60, 'soni': 3}

=== 2. Yaxshi (bir-bir qadam) ===
  tozalangan: [10, -5, 20, 30]
  yaroqli: [10, 20, 30]
  hisob: {'jami': 60, 'soni': 3}

=== 3. Har funksiya alohida sinaladi ===
  tozala([1, None]): [1]
  yaroqli([-1, 5]): [5]

=== 4. Bir xil natija ===
  teng: True
  ⭐ kichik funksiya — bir ish (o'qish, sinash oson)

"""DRY: takrorlangan mantiqni bir joyga chiqarish (o'zgartirish oson)."""


def takrorli(asosiy: float, xizmat: float, yetkazish: float) -> dict:
    # QQS 12% uch joyda takror — o'zgarsa, uchalasini topish kerak
    asosiy_qqs = asosiy + asosiy * 0.12
    xizmat_qqs = xizmat + xizmat * 0.12
    yetkazish_qqs = yetkazish + yetkazish * 0.12
    return {"asosiy": asosiy_qqs, "xizmat": xizmat_qqs, "yetkazish": yetkazish_qqs}


# DRY: bir joyda
QQS_STAVKASI = 0.12


def qqs_qosh(narx: float) -> float:
    return narx + narx * QQS_STAVKASI


def dry_usul(asosiy: float, xizmat: float, yetkazish: float) -> dict:
    return {
        "asosiy": qqs_qosh(asosiy),
        "xizmat": qqs_qosh(xizmat),
        "yetkazish": qqs_qosh(yetkazish),
    }


def main() -> None:
    print("=== 1. Takrorli usul ===")
    print(f"  {takrorli(100, 50, 30)}")

    print("\n=== 2. DRY usul (bir funksiya) ===")
    print(f"  {dry_usul(100, 50, 30)}")

    print("\n=== 3. O'zgartirish oson (stavka bir joyda) ===")
    print(f"  qqs_qosh(100): {qqs_qosh(100)}")
    print("  stavka o'zgarsa — faqat QQS_STAVKASI (bir joy)")

    print("\n=== 4. Bir xil natija ===")
    print(f"  teng: {takrorli(100, 50, 30) == dry_usul(100, 50, 30)}")
    print("  ⭐ DRY — bir mantiq, bir joy (xato kam)")


if __name__ == "__main__":
    main()

=== 1. Takrorli usul ===
  {'asosiy': 112.0, 'xizmat': 56.0, 'yetkazish': 33.6}

=== 2. DRY usul (bir funksiya) ===
  {'asosiy': 112.0, 'xizmat': 56.0, 'yetkazish': 33.6}

=== 3. O'zgartirish oson (stavka bir joyda) ===
  qqs_qosh(100): 112.0
  stavka o'zgarsa — faqat QQS_STAVKASI (bir joy)

=== 4. Bir xil natija ===
  teng: True
  ⭐ DRY — bir mantiq, bir joy (xato kam)

"""KISS: aqlli bir qatorni oddiy, o'qiladigan kodga aylantirish."""


def chalkash(matritsa: list) -> list:
    # bir qator — o'qish qiyin (nima qiladi?)
    return sorted({x for satr in matritsa for x in satr if x > 0})[:3]


def oddiy(matritsa: list) -> list:
    # bir necha qadam — ravshan
    barcha = []
    for satr in matritsa:
        for x in satr:
            if x > 0:
                barcha.append(x)
    noyob = set(barcha)          # takrorni olib tashla
    tartibli = sorted(noyob)     # tartibla
    return tartibli[:3]          # birinchi 3


def main() -> None:
    m = [[3, -1, 5], [5, 2, -4], [8, 3, 1]]

    print("=== 1. Chalkash (bir qator) ===")
    print(f"  natija: {chalkash(m)}")
    print("  o'qish qiyin (bir qatorda 4 amal)")

    print("\n=== 2. Oddiy (bir necha qadam) ===")
    print(f"  natija: {oddiy(m)}")
    print("  har qadam ravshan (nomli)")

    print("\n=== 3. Bir xil natija ===")
    print(f"  teng: {chalkash(m) == oddiy(m)}")

    print("\n=== 4. Qaysi yaxshi ===")
    print("  oddiysi — o'qish, tuzatish, o'zgartirish oson")
    print("  'aqlli' kod — faqat yozgan tushunadi")
    print("  ⭐ KISS — oddiy, ravshan (jamoa uchun)")


if __name__ == "__main__":
    main()

=== 1. Chalkash (bir qator) ===
  natija: [1, 2, 3]
  o'qish qiyin (bir qatorda 4 amal)

=== 2. Oddiy (bir necha qadam) ===
  natija: [1, 2, 3]
  har qadam ravshan (nomli)

=== 3. Bir xil natija ===
  teng: True

=== 4. Qaysi yaxshi ===
  oddiysi — o'qish, tuzatish, o'zgartirish oson
  'aqlli' kod — faqat yozgan tushunadi
  ⭐ KISS — oddiy, ravshan (jamoa uchun)

d = get()      # d nima?                     # ⚠️
faol_kunlar = get()                          # ✅

def process(): ...  # 200 qator               # ⚠️
def a(): def b(): def c()  # bo'lingan        # ✅

x*1.12; y*1.12  # takror                       # ⚠️
def qqs(n): return n*1.12                      # ✅

x += 1  # x ni oshir                           # ⚠️ foydasiz
# QQS qonun o'zgardi                           # ✅ nega

r = [f(x) for x in d if g(x)][::-1][:5]        # ⚠️ chalkash
# bir necha oddiy qator                        # ✅

userName = ...; foydalanuvchi_nomi = ...       # ⚠️ aralash
# bir uslub (snake_case)                        # ✅

# 2 marta o'xshash → darrov abstraksiya        # ⚠️
# 3+ marta va bir mantiq → chiqar               # ✅

1.  # toza kod nima?
2.  # nega o'qish muhim?
3.  # aniq nomlash nima?
4.  # 'd' yoki 'kunlar' — qaysi?
5.  # SRP nima?
6.  # katta funksiya nega yomon?
7.  # DRY nima?
8.  # takror nega yomon?
9.  # kommentariy nimani tushuntiradi?
10. # KISS nima?
11. # PEP 8 nima?
12. # black nima?

1.  d = get()                    # aniq nom

2.  def process(): # 200 qator   # bo'l

3.  x*1.12; y*1.12               # DRY

4.  x += 1  # x ni oshir         # nega

5.  [f(x) for x in d][::-1][:5]  # KISS