IlmHamroh
Python kursi/Boshqaruv oqimi3/12-dars30 daqiqa
Mundarija (23)

5.3-dars: Shartlarni birlashtirish

5-QISM — BOSHQARUV OQIMI · 3-dars

1. Kirish va motivatsiya

Bitta shart kamdan-kam yetadi. Haqiqiy mantiq — bir necha shartning kombinatsiyasi:

python
if yosh >= 18 and mamlakat == "UZ" and not bloklangan:
    ...

3.5-darsda and, or, not bilan tanishdik. Bu darsda ularni murakkab holatlarda ishlatishni o'rganamiz.

Va bu yerda ko'p tuzoq bor:

python
if a or b and c:                # ← qaysi biri oldin?
if not a == b:                  # ← not nimaga tegishli?
if x == 1 or 2:                 # ← ❌ har doim rost!
if not (a and b):               # ← soddalashtirish mumkinmi?

Va eng ko'p uchraydigan mantiqiy xato:

python
# ❌ "x 1 yoki 2 ga tengmi" — noto'g'ri yozuv
if x == 1 or 2:
    print("mos")                # HAR DOIM bajariladi!

Bu darsda:

  • Prioritet: not → and → or
  • De Morgan qonunlari — inkorni soddalashtirish
  • Klassik xatolar: x == 1 or 2, a < b < c chalkashligi
  • any() / all() bilan ko'p shart
  • To'plamlar bilan mantiq
  • Murakkab shartlarni soddalashtirish usullari

2. Nazariya — chuqur tushuntirish

2.1. Prioritet — takrorlash

3.12-darsda ko'rgandik. Mantiqiy operatorlar tartibi:

text
1. not      (eng yuqori)
2. and
3. or       (eng past)
python
print(True or False and False)      # True
# = True or (False and False)
# = True or False
# = True

print((True or False) and False)    # False

Amaliy misol:

python
turi = "oddiy"
summa = 2_000_000
faol = False

# ❌ Kutilmagan natija
if turi == "vip" or summa > 1_000_000 and faol:
    print("Chegirma")               # bajarilmaydi
# = turi == "vip" or (summa > 1_000_000 and faol)
# = False or (True and False)
# = False

# ✅ Aniq
if (turi == "vip" or summa > 1_000_000) and faol:
    print("Chegirma")

Qoida:

and va or aralashganda doim qavs qo'ying. Qavs bepul, xato qimmat.

not prioriteti — nozik jihat:

python
a, b = 5, 5

print(not a == b)               # False
# not (a == b) — chunki == not dan YUQORI prioritetli

Bu — tasodifan to'g'ri ishlaydi. Lekin o'qish chalkash:

python
if not a == b:                  # ⚠️ ikkilanish
if a != b:                      # ✅ aniq

To'liq prioritet (3.12-dars):

text
==  !=  <  >  in  is        ← taqqoslash
not
and
or

Ya'ni: taqqoslash mantiqdan yuqori. Shuning uchun:

python
if x > 5 and y < 10:            # ✅ qavs kerak emas
if (x > 5) and (y < 10):        # ✅ lekin aniqroq

2.2. x == 1 or 2 tuzog'i

Bu — eng ko'p uchraydigan mantiqiy xato.

python
x = 5

if x == 1 or 2:
    print("mos keldi")          # ← HAR DOIM bajariladi!

Nima bo'lyapti?

text
x == 1 or 2
= (x == 1) or 2
= False or 2
= 2                             ← truthy!

or qiymat qaytaradi (3.5-dars), va 2 — truthy. Shuning uchun shart har doim rost.

Boshqa shakllar:

python
if x == 1 or x == 2:            # ✅ to'g'ri
if x in (1, 2):                 # ✅ yaxshiroq
if x in {1, 2}:                 # ✅ eng yaxshi (to'plam — O(1))

Xuddi shunday and bilan:

python
if x == 1 and 2:                # (x == 1) and 2
                                # x == 1 bo'lsa → 2 (truthy)
                                # aks holda → False

Satrlar bilan:

python
javob = "yo'q"

if javob == "ha" or "h":        # ❌ har doim rost ("h" truthy)
if javob in {"ha", "h"}:        # ✅

Bo'sh satr bilan — yanada chalkash:

python
if javob == "ha" or "":         # (javob == "ha") or ""
                                # javob != "ha" bo'lsa → "" (falsy)
                                # Tasodifan TO'G'RI ishlaydi!

Ruff topadi: ba'zi holatlarni. Lekin hammasini emas — ehtiyot bo'ling.

2.3. De Morgan qonunlari

Inkorni ichkariga "tarqatish" qoidalari:

text
not (a and b)  ≡  (not a) or (not b)
not (a or b)   ≡  (not a) and (not b)

Tekshirish:

python
from itertools import product

print(f"  {'a':>6} {'b':>6} │ {'not(a and b)':>14} {'(not a) or (not b)':>20}")
print("  " + "─" * 52)
for a, b in product([True, False], repeat=2):
    chap = not (a and b)
    ong = (not a) or (not b)
    print(f"  {a!s:>6} {b!s:>6} │ {chap!s:>14} {ong!s:>20}  {'✅' if chap == ong else '❌'}")
text
       a      b │   not(a and b)   (not a) or (not b)
  ────────────────────────────────────────────────────
    True   True │          False                False  ✅
    True  False │           True                 True  ✅
   False   True │           True                 True  ✅
   False  False │           True                 True  ✅

Amaliy foydalanish — o'qilishni yaxshilash:

python
# ❌ Ikki karra inkor
if not (yosh < 18 or bloklangan):
    ruxsat_ber()

# ✅ De Morgan bilan
if yosh >= 18 and not bloklangan:
    ruxsat_ber()
python
# ❌ Chalkash
if not (fayl.exists() and fayl.readable()):
    return "Fayl bilan muammo"

# ✅ Aniqroq
if not fayl.exists() or not fayl.readable():
    return "Fayl bilan muammo"

Yoki shartni teskarilash:

python
# ❌
if not (a and b):
    xato()
else:
    ishla()

# ✅ Ijobiy shart oldinda
if a and b:
    ishla()
else:
    xato()

Taqqoslashni inkor qilish:

text
not (x > 5)   ≡  x <= 5
not (x >= 5)  ≡  x < 5
not (x == 5)  ≡  x != 5
not (x in y)  ≡  x not in y
not (x is y)  ≡  x is not y
python
# ❌
if not x > 5:
if not x in royxat:
if not x is None:

# ✅
if x <= 5:
if x not in royxat:
if x is not None:

Ruff topadi: E713 (not in), E714 (is not).

Kasr sonlar bilan ehtiyot:

python
import math

x = float("nan")
print(x > 5)                    # False
print(not (x > 5))              # True
print(x <= 5)                   # False!  ← teng emas

nan bilan barcha taqqoslash False (3.4-dars). Shuning uchun not (x > 5) va x <= 5 farq qiladi.

2.4. Zanjirli taqqoslash va mantiq

3.11-darsda ko'rgandik:

python
if 18 <= yosh <= 65:            # ✅
if yosh >= 18 and yosh <= 65:   # ⚠️ uzunroq

Lekin chalkash zanjirlar bo'ladi:

python
print(1 < 2 < 3)                # True  — mantiqiy
print(1 < 2 > 0)                # True  — (1<2) and (2>0)
print(3 > 2 < 5)                # True  — g'alati, lekin to'g'ri

Oxirgisi — texnik jihatdan to'g'ri, lekin niyat noaniq. Bunday yozuvdan qoching.

Aralash zanjirlar:

python
a, b, c = 1, 2, 3

print(a < b == 2)               # True — (a<b) and (b==2)
print(a != b != c)              # True — a!=b va b!=c
print(a != b != c != a)         # True — lekin a va c ni solishtirmaydi!

Oxirgisi — tuzoq. "Uchalasi ham farqli" degani emas:

python
a, b, c = 1, 2, 1
print(a != b != c)              # True — lekin a == c!
print(len({a, b, c}) == 3)      # False — ✅ to'g'ri usul

Uchta qiymat farqli ekanini tekshirish:

python
# ✅ To'plam bilan
if len({a, b, c}) == 3:
    ...

# ✅ Yoki aniq
if a != b and b != c and a != c:
    ...

2.5. any() va all() — ko'p shart

3.5-darsda tanishgandik. Amaliy qo'llanish:

python
sonlar = [12, 5, 8, 21, 16]

print(all(s > 0 for s in sonlar))       # True  — hammasi musbat
print(any(s > 20 for s in sonlar))      # True  — kamida bittasi
print(all(s % 2 == 0 for s in sonlar))  # False

Shartlar ro'yxati bilan:

python
parol = "Salom123!"

TALABLAR = [
    len(parol) >= 8,
    any(c.isupper() for c in parol),
    any(c.islower() for c in parol),
    any(c.isdigit() for c in parol),
]

if all(TALABLAR):
    print("Parol kuchli")

Bu yerda barcha shart hisoblanadi — qisqa tutashuv yo'q, chunki ro'yxat oldindan quriladi.

Dangasa hisoblash uchun generator:

python
def talablar(parol: str):
    yield len(parol) >= 8
    yield any(c.isupper() for c in parol)
    yield any(c.islower() for c in parol)
    yield any(c.isdigit() for c in parol)


if all(talablar(parol)):        # ✅ birinchi False da to'xtaydi
    ...

Bo'sh to'plam tuzog'i (3.5-dars):

python
print(all([]))                  # True!
print(any([]))                  # False
python
def hammasi_musbatmi(sonlar):
    return all(s > 0 for s in sonlar)

print(hammasi_musbatmi([]))     # True — kutilmagan bo'lishi mumkin

def hammasi_musbatmi(sonlar):
    return bool(sonlar) and all(s > 0 for s in sonlar)   # ✅

Qaysi shart buzilganini bilish:

python
TEKSHIRUVLAR = {
    "uzunlik": len(parol) >= 8,
    "katta harf": any(c.isupper() for c in parol),
    "raqam": any(c.isdigit() for c in parol),
}

buzilgan = [nom for nom, natija in TEKSHIRUVLAR.items() if not natija]
if buzilgan:
    print(f"Muammolar: {', '.join(buzilgan)}")

2.6. To'plamlar bilan mantiq

To'plam amallari — mantiqiy operatorlarning to'plam varianti (3.10-dars):

python
a = {1, 2, 3}
b = {3, 4, 5}

print(a & b)                    # {3}          kesishma  (AND)
print(a | b)                    # {1,2,3,4,5}  birlashma (OR)
print(a - b)                    # {1, 2}       ayirma
print(a ^ b)                    # {1,2,4,5}    XOR

Amaliy foydalanish:

python
KERAKLI_RUXSATLAR = {"oqish", "yozish"}
foydalanuvchi_ruxsatlari = {"oqish", "yozish", "ochirish"}

# Barcha kerakli ruxsat bormi?
if KERAKLI_RUXSATLAR <= foydalanuvchi_ruxsatlari:       # qism to'plam
    print("✅ Ruxsat berildi")

# Kamida bitta umumiy bormi?
if KERAKLI_RUXSATLAR & foydalanuvchi_ruxsatlari:
    print("Qisman ruxsat")

# Nima yetishmaydi?
yetishmaydi = KERAKLI_RUXSATLAR - foydalanuvchi_ruxsatlari
if yetishmaydi:
    print(f"Yetishmaydi: {yetishmaydi}")

and/or bilan solishtiring:

python
# ❌ Uzun
if "oqish" in ruxsatlar and "yozish" in ruxsatlar:
    ...

# ✅ To'plam bilan
if {"oqish", "yozish"} <= ruxsatlar:
    ...

Teglar bilan filtrlash:

python
maqolalar = [
    {"nom": "Python asoslari", "teglar": {"python", "boshlovchi"}},
    {"nom": "Django", "teglar": {"python", "veb"}},
    {"nom": "React", "teglar": {"js", "veb"}},
]

qidiruv = {"python"}

# Kamida bitta teg mos
mos = [m for m in maqolalar if m["teglar"] & qidiruv]

# Barcha teg mos
qidiruv = {"python", "veb"}
mos = [m for m in maqolalar if qidiruv <= m["teglar"]]

6-qismda to'plamlarni to'liq o'rganamiz.

2.7. Shartlarni soddalashtirish

1. Ortiqcha taqqoslash:

python
# ❌
if faolmi == True:
if faolmi != False:
if bool(faolmi):

# ✅
if faolmi:
python
# ❌
if len(royxat) > 0:
if royxat != []:

# ✅
if royxat:

2. Ortiqcha if/else:

python
# ❌
def musbatmi(x):
    if x > 0:
        return True
    else:
        return False

# ✅
def musbatmi(x):
    return x > 0

Ruff: SIM103 ("return the condition directly").

3. Takrorlanuvchi tekshiruvlar:

python
# ❌
if x > 0 and x < 10:
if x >= 0 and x <= 10:

# ✅
if 0 < x < 10:
if 0 <= x <= 10:

4. Ketma-ket or:

python
# ❌
if x == "a" or x == "b" or x == "c":

# ✅
if x in {"a", "b", "c"}:

5. Ichma-ich if — and bilan:

python
# ❌
if a:
    if b:
        ishla()

# ✅
if a and b:
    ishla()

Ruff: SIM102 ("collapsible if").

Lekin xato xabarlari kerak bo'lsa — ajratib qoldiring:

python
if not a:
    return "a yo'q"
if not b:
    return "b yo'q"             # ✅ har biri o'z xabari bilan

6. Uchlik operator (4-darsda batafsil):

python
# ❌
if shart:
    x = 1
else:
    x = 2

# ✅ Qisqa holatda
x = 1 if shart else 2

7. or bilan sukut qiymat (3.5-dars):

python
# ❌
if ism:
    korsatiladigan = ism
else:
    korsatiladigan = "Mehmon"

# ✅
korsatiladigan = ism or "Mehmon"

# ⚠️ Lekin 0 va "" ni ehtiyot qiling
qiymat = kirish if kirish is not None else sukut

2.8. Qisqa tutashuv — amaliy naqshlar

3.5-darsda o'rgandik. Amaliy qo'llanish:

1. Himoyalovchi shart:

python
if royxat and royxat[0] > 5:            # ✅
if user and user.faol and user.balans > 0:
if matn and matn.strip():

2. Nolga bo'lishdan himoya:

python
if soni and jami / soni > 100:          # ✅
ortacha = jami / soni if soni else 0    # ✅

3. Qimmat amallarni oxirga:

python
# ❌ Har safar bazaga so'rov
if bazadan_tekshir(user_id) and user.faol:

# ✅ Arzon tekshiruv birinchi
if user.faol and bazadan_tekshir(user_id):

4. Zanjirli xavfsiz kirish:

python
shahar = user and user.manzil and user.manzil.shahar

Bu None yoki satr qaytaradi — turini tekshiring.

5. Sukut qiymat zanjiri:

python
port = (
    argumentlar.port
    or muhit.get("PORT")
    or konfig.get("port")
    or 8000
)

Birinchi truthy qiymat olinadi.

2.9. Murakkab mantiqni jadvalga aylantirish

Ba'zan shartlar juda ko'p bo'lganda haqiqat jadvali yaxshiroq:

python
# ❌ 8 ta kombinatsiya
def ruxsat(admin, egasi, ommaviy):
    if admin:
        return True
    elif egasi:
        return True
    elif ommaviy:
        return True
    else:
        return False

Bu — admin or egasi or ommaviy. Lekin murakkabroq holatda:

python
RUXSATLAR = {
    # (admin, egasi, ommaviy): ruxsat
    (True,  True,  True):  "to'liq",
    (True,  True,  False): "to'liq",
    (True,  False, True):  "to'liq",
    (True,  False, False): "to'liq",
    (False, True,  True):  "tahrirlash",
    (False, True,  False): "tahrirlash",
    (False, False, True):  "o'qish",
    (False, False, False): "yo'q",
}


def ruxsat(admin: bool, egasi: bool, ommaviy: bool) -> str:
    return RUXSATLAR[(admin, egasi, ommaviy)]

Afzalliklari:

  • Barcha holat aniq ko'rinadi
  • Unutilgan kombinatsiya bo'lmaydi
  • Test qilish oson — jadvalning o'zi test

Kamchiliklari:

  • Ko'p o'zgaruvchida jadval katta (2ⁿ)
  • Diapazon shartlari uchun yaramaydi

Oraliq yechim — funksiyalar jadvali:

python
QOIDALAR = [
    (lambda a, e, o: a,       "to'liq"),
    (lambda a, e, o: e,       "tahrirlash"),
    (lambda a, e, o: o,       "o'qish"),
    (lambda a, e, o: True,    "yo'q"),           # sukut
]


def ruxsat(admin, egasi, ommaviy):
    for shart, natija in QOIDALAR:
        if shart(admin, egasi, ommaviy):
            return natija

Tartib muhim — birinchi mos keladigani g'olib (1-dars).

3. Tez ma'lumotnoma

Prioritet

text
==  !=  <  >  in  is        taqqoslash (eng yuqori)
not
and
or                          (eng past)

⚠️ and va or aralashganda QAVS QO'YING

Klassik xatolar

python
if x == 1 or 2:             ❌ har doim rost
if x in {1, 2}:             ✅

if a != b != c:             ⚠️ a va c solishtirilmaydi
if len({a,b,c}) == 3:       ✅

if not x > 5:               ⚠️ nan bilan farq qiladi
if x <= 5:                  ✅

De Morgan

text
not (a and b)  ≡  (not a) or (not b)
not (a or b)   ≡  (not a) and (not b)

not (x > 5)    ≡  x <= 5
not (x in y)   ≡  x not in y
not (x is y)   ≡  x is not y

Soddalashtirish

python
if faolmi == True:      → if faolmi:
if len(x) > 0:          → if x:
if a: if b:             → if a and b:              (SIM102)
return True if c else False → return c             (SIM103)
if x=="a" or x=="b":    → if x in {"a","b"}:
if x>0 and x<10:        → if 0 < x < 10:

any / all

python
all(shart(x) for x in y)        hammasi
any(shart(x) for x in y)        kamida bittasi
all([]) → True                  ⚠️ eslab qoling
bool(x) and all(...)            bo'sh to'plamdan himoya

To'plamlar

python
A <= B          A — B ning qism to'plami (barcha element bor)
A & B           kesishma (kamida bitta umumiy)
A - B           yetishmayotgan elementlar

4. Batafsil misollar

Misol 1 — Klassik mantiqiy xatolar

python
"""Eng ko'p uchraydigan mantiqiy tuzoqlar."""

print("=== 1. ⭐ x == 1 or 2 tuzog'i ===")

for x in [1, 2, 5, 0]:
    notogri = bool(x == 1 or 2)
    togri = x in {1, 2}
    belgi = "⚠️" if notogri != togri else "  "
    print(f"  x={x}:  (x == 1 or 2) → {notogri!s:<6}   "
          f"(x in {{1,2}}) → {togri!s:<6} {belgi}")

print("\n  Sabab:")
print("    x == 1 or 2")
print("    = (x == 1) or 2")
print("    = False or 2")
print("    = 2          ← truthy!")


print("\n\n=== 2. Satrlar bilan ===")
for javob in ["ha", "h", "yo'q", ""]:
    notogri = bool(javob == "ha" or "h")
    togri = javob in {"ha", "h"}
    belgi = "⚠️" if notogri != togri else "  "
    print(f"  {javob!r:<8} notogri={notogri!s:<6} togri={togri!s:<6} {belgi}")


print("\n\n=== 3. a != b != c tuzog'i ===")
holatlar = [(1, 2, 3), (1, 2, 1), (1, 1, 2), (1, 1, 1)]

print(f"  {'a':>3} {'b':>3} {'c':>3} │ {'a!=b!=c':>9} {'hammasi farqli':>16}")
print("  " + "─" * 42)
for a, b, c in holatlar:
    zanjir = a != b != c
    haqiqiy = len({a, b, c}) == 3
    belgi = "⚠️" if zanjir != haqiqiy else "  "
    print(f"  {a:>3} {b:>3} {c:>3} │ {zanjir!s:>9} {haqiqiy!s:>16} {belgi}")

print("\n  a != b != c = (a != b) and (b != c)")
print("  a va c SOLISHTIRILMAYDI!")


print("\n\n=== 4. and / or prioriteti ===")
holatlar = [
    ("vip", 500_000, False),
    ("vip", 500_000, True),
    ("oddiy", 2_000_000, False),
    ("oddiy", 2_000_000, True),
]

print(f"  {'Turi':<8} {'Summa':>11} {'Faol':>6} │ "
      f"{'Qavssiz':>9} {'Qavs bilan':>12}")
print("  " + "─" * 56)

for turi, summa, faol in holatlar:
    qavssiz = turi == "vip" or summa > 1_000_000 and faol
    qavs = (turi == "vip" or summa > 1_000_000) and faol
    belgi = "  ⚠️" if qavssiz != qavs else ""
    print(f"  {turi:<8} {summa:>11,} {faol!s:>6} │ "
          f"{qavssiz!s:>9} {qavs!s:>12}{belgi}")


print("\n\n=== 5. nan bilan inkor ===")
import math

qiymatlar = [3.0, 5.0, 7.0, float("nan"), float("inf")]

print(f"  {'x':>6} │ {'x > 5':>7} {'not (x > 5)':>13} {'x <= 5':>8} {'Teng?':>7}")
print("  " + "─" * 48)
for x in qiymatlar:
    a = x > 5
    b = not (x > 5)
    c = x <= 5
    teng = "✅" if b == c else "⚠️"
    print(f"  {x!s:>6} │ {a!s:>7} {b!s:>13} {c!s:>8} {teng:>7}")

print("\n  nan bilan BARCHA taqqoslash False (3.4-dars)")
print("  Shuning uchun not (x > 5) va x <= 5 FARQ QILADI")
text
=== 1. ⭐ x == 1 or 2 tuzog'i ===
  x=1:  (x == 1 or 2) → True     (x in {1,2}) → True     
  x=2:  (x == 1 or 2) → True     (x in {1,2}) → True     
  x=5:  (x == 1 or 2) → True     (x in {1,2}) → False  ⚠️
  x=0:  (x == 1 or 2) → True     (x in {1,2}) → False  ⚠️

=== 3. a != b != c tuzog'i ===
    a   b   c │   a!=b!=c   hammasi farqli
  ──────────────────────────────────────────
    1   2   3 │      True             True   
    1   2   1 │      True            False ⚠️
    1   1   2 │     False            False   
    1   1   1 │     False            False   

=== 5. nan bilan inkor ===
       x │   x > 5   not (x > 5)   x <= 5   Teng?
  ────────────────────────────────────────────────
     3.0 │    False          True     True      ✅
     5.0 │    False          True     True      ✅
     7.0 │     True         False    False      ✅
     nan │    False          True    False      ⚠️
     inf │     True         False    False      ✅

Nima ko'rsatdi: 2.2, 2.3, 2.4-bo'limlar.

Misol 2 — De Morgan qonunlari

python
"""Inkorni soddalashtirish."""

from itertools import product

print("=== 1. Haqiqat jadvali ===")

print(f"  {'a':>6} {'b':>6} │ {'not(a and b)':>13} {'(!a) or (!b)':>14} │ "
      f"{'not(a or b)':>12} {'(!a) and (!b)':>15}")
print("  " + "─" * 76)

for a, b in product([True, False], repeat=2):
    c1, c2 = not (a and b), (not a) or (not b)
    c3, c4 = not (a or b), (not a) and (not b)
    print(f"  {a!s:>6} {b!s:>6} │ {c1!s:>13} {c2!s:>14} │ "
          f"{c3!s:>12} {c4!s:>15}")

print("\n  Ikkala qonun ham har doim ishlaydi ✅")


print("\n\n=== 2. Taqqoslashni inkor qilish ===")
almashtirishlar = [
    ("not (x > 5)",   "x <= 5"),
    ("not (x >= 5)",  "x < 5"),
    ("not (x == 5)",  "x != 5"),
    ("not (x != 5)",  "x == 5"),
    ("not (x in y)",  "x not in y"),
    ("not (x is y)",  "x is not y"),
    ("not (x is None)", "x is not None"),
]

print(f"  {'Chalkash':<20} {'Aniq':<20}")
print("  " + "─" * 42)
for chalkash, aniq in almashtirishlar:
    print(f"  {chalkash:<20} {aniq:<20}")

print("\n  Ruff: E713 (not in), E714 (is not)")


print("\n\n=== 3. Amaliy misollar ===")

print("""
  ❌ Ikki karra inkor:
       if not (yosh < 18 or bloklangan):
           ruxsat_ber()

  ✅ De Morgan bilan:
       if yosh >= 18 and not bloklangan:
           ruxsat_ber()

  ─────────────────────────────────────────

  ❌ Inkor bilan boshlash:
       if not (fayl_bor and oqish_mumkin):
           return "Xato"
       ishla()

  ✅ Ijobiy shart oldinda:
       if fayl_bor and oqish_mumkin:
           ishla()
       else:
           return "Xato"

  ─────────────────────────────────────────

  ❌ Chalkash:
       if not x > 5 and not y > 5:

  ✅ Aniq:
       if x <= 5 and y <= 5:
""")


print("=== 4. Tekshirish funksiyasi ===")


def de_morgan_tekshir(n: int = 3) -> None:
    """n ta o'zgaruvchi uchun De Morgan qonunini tekshiradi."""
    from functools import reduce
    import operator

    xatolar = 0
    holatlar = 0

    for qiymatlar in product([True, False], repeat=n):
        holatlar += 1

        # not (a and b and c) == (not a) or (not b) or (not c)
        chap1 = not reduce(operator.and_, qiymatlar)
        ong1 = reduce(operator.or_, [not q for q in qiymatlar])

        # not (a or b or c) == (not a) and (not b) and (not c)
        chap2 = not reduce(operator.or_, qiymatlar)
        ong2 = reduce(operator.and_, [not q for q in qiymatlar])

        if chap1 != ong1 or chap2 != ong2:
            xatolar += 1

    print(f"  {n} o'zgaruvchi: {holatlar} holat tekshirildi, "
          f"{xatolar} xato → {'✅' if xatolar == 0 else '❌'}")


for n in [2, 3, 4, 5]:
    de_morgan_tekshir(n)


print("\n\n=== 5. Murakkab shartni soddalashtirish ===")


def ruxsat_yomon(user):
    return not (user is None or not user.faol or user.bloklangan
                or not user.email_tasdiq)


def ruxsat_yaxshi(user):
    return (user is not None and user.faol and not user.bloklangan
            and user.email_tasdiq)


from dataclasses import dataclass


@dataclass
class User:
    faol: bool = True
    bloklangan: bool = False
    email_tasdiq: bool = True


USERLAR = [
    None,
    User(),
    User(faol=False),
    User(bloklangan=True),
    User(email_tasdiq=False),
]

print(f"  {'User':<32} {'Yomon':>8} {'Yaxshi':>8} {'Teng?':>7}")
print("  " + "─" * 60)
for u in USERLAR:
    y = ruxsat_yomon(u)
    x = ruxsat_yaxshi(u)
    print(f"  {str(u):<32} {y!s:>8} {x!s:>8} {'✅' if y == x else '❌':>7}")

Natijaning muhim qismi:

text
=== 1. Haqiqat jadvali ===
       a      b │  not(a and b)   (!a) or (!b) │  not(a or b)   (!a) and (!b)
  ────────────────────────────────────────────────────────────────────────────
    True   True │         False          False │        False           False
    True  False │          True           True │        False           False
   False   True │          True           True │        False           False
   False  False │          True           True │         True            True

=== 4. Tekshirish funksiyasi ===
  2 o'zgaruvchi: 4 holat tekshirildi, 0 xato → ✅
  3 o'zgaruvchi: 8 holat tekshirildi, 0 xato → ✅
  4 o'zgaruvchi: 16 holat tekshirildi, 0 xato → ✅
  5 o'zgaruvchi: 32 holat tekshirildi, 0 xato → ✅

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — any/all va to'plamlar

python
"""Ko'p shartni idiomatik tekshirish."""

from dataclasses import dataclass, field

print("=== 1. Parol tekshiruvi ===")

MAXSUS = "!@#$%^&*()_+-=[]{}|;:,.<>?"


def parol_tekshir(parol: str) -> dict[str, bool]:
    return {
        "Kamida 8 belgi": len(parol) >= 8,
        "Katta harf": any(c.isupper() for c in parol),
        "Kichik harf": any(c.islower() for c in parol),
        "Raqam": any(c.isdigit() for c in parol),
        "Maxsus belgi": any(c in MAXSUS for c in parol),
        "Bo'sh joysiz": not any(c.isspace() for c in parol),
    }


for parol in ["123", "salom123", "Salom123", "Salom123!", "Salom 123!"]:
    natijalar = parol_tekshir(parol)
    bajarilgan = sum(natijalar.values())
    jami = len(natijalar)

    holat = "✅ Kuchli" if all(natijalar.values()) else f"❌ {bajarilgan}/{jami}"
    print(f"\n  {parol!r:<16} {holat}")

    buzilgan = [nom for nom, ok in natijalar.items() if not ok]
    if buzilgan:
        print(f"    Yetishmaydi: {', '.join(buzilgan)}")


print("\n\n=== 2. ⚠️ Bo'sh to'plam tuzog'i ===")


def hammasi_musbat_yomon(sonlar):
    return all(s > 0 for s in sonlar)


def hammasi_musbat_yaxshi(sonlar):
    return bool(sonlar) and all(s > 0 for s in sonlar)


for sonlar in [[1, 2, 3], [1, -2, 3], []]:
    y = hammasi_musbat_yomon(sonlar)
    x = hammasi_musbat_yaxshi(sonlar)
    belgi = "⚠️" if y != x else ""
    print(f"  {str(sonlar):<12} yomon={y!s:<6} yaxshi={x!s:<6} {belgi}")


print("\n\n=== 3. Dangasa hisoblash ===")

chaqiruvlar = 0


def qimmat_tekshiruv(x):
    global chaqiruvlar
    chaqiruvlar += 1
    return x > 0


sonlar = [1, 2, -3, 4, 5]

chaqiruvlar = 0
natija = all([qimmat_tekshiruv(s) for s in sonlar])      # ro'yxat
print(f"  Ro'yxat bilan:  {natija}, chaqiruvlar: {chaqiruvlar}")

chaqiruvlar = 0
natija = all(qimmat_tekshiruv(s) for s in sonlar)        # generator
print(f"  Generator bilan: {natija}, chaqiruvlar: {chaqiruvlar}  ← to'xtadi")


print("\n\n=== 4. To'plamlar bilan ruxsatlar ===")


@dataclass
class Foydalanuvchi:
    ism: str
    ruxsatlar: set[str] = field(default_factory=set)


TALABLAR = {
    "ko'rish": {"oqish"},
    "tahrirlash": {"oqish", "yozish"},
    "boshqarish": {"oqish", "yozish", "ochirish"},
    "admin": {"oqish", "yozish", "ochirish", "sozlash"},
}

FOYDALANUVCHILAR = [
    Foydalanuvchi("Mehmon", set()),
    Foydalanuvchi("O'quvchi", {"oqish"}),
    Foydalanuvchi("Muallif", {"oqish", "yozish"}),
    Foydalanuvchi("Moderator", {"oqish", "yozish", "ochirish"}),
    Foydalanuvchi("Admin", {"oqish", "yozish", "ochirish", "sozlash"}),
]

print(f"  {'Foydalanuvchi':<14}", end="")
for amal in TALABLAR:
    print(f"{amal:>13}", end="")
print()
print("  " + "─" * 66)

for f in FOYDALANUVCHILAR:
    print(f"  {f.ism:<14}", end="")
    for amal, kerak in TALABLAR.items():
        ruxsat = "✅" if kerak <= f.ruxsatlar else "❌"
        print(f"{ruxsat:>13}", end="")
    print()


print("\n  Nima yetishmayapti:")
for f in FOYDALANUVCHILAR[:3]:
    yetishmaydi = TALABLAR["boshqarish"] - f.ruxsatlar
    if yetishmaydi:
        print(f"    {f.ism:<12} boshqarish uchun: {sorted(yetishmaydi)}")


print("\n\n=== 5. Teglar bilan qidiruv ===")

MAQOLALAR = [
    {"nom": "Python asoslari", "teglar": {"python", "boshlovchi", "dasturlash"}},
    {"nom": "Django veb", "teglar": {"python", "veb", "framework"}},
    {"nom": "React", "teglar": {"js", "veb", "frontend"}},
    {"nom": "Algoritmlar", "teglar": {"dasturlash", "algoritm"}},
    {"nom": "FastAPI", "teglar": {"python", "veb", "api"}},
]

qidiruvlar = [
    ({"python"}, "kamida bitta"),
    ({"python", "veb"}, "kamida bitta"),
    ({"python", "veb"}, "barchasi"),
    ({"dasturlash"}, "kamida bitta"),
]

for teglar, rejim in qidiruvlar:
    if rejim == "kamida bitta":
        mos = [m for m in MAQOLALAR if m["teglar"] & teglar]
    else:
        mos = [m for m in MAQOLALAR if teglar <= m["teglar"]]

    print(f"\n  {sorted(teglar)} ({rejim}):")
    for m in mos:
        print(f"    • {m['nom']}")
    if not mos:
        print("    (topilmadi)")

Natijaning muhim qismi:

text
=== 2. ⚠️ Bo'sh to'plam tuzog'i ===
  [1, 2, 3]    yomon=True   yaxshi=True   
  [1, -2, 3]   yomon=False  yaxshi=False  
  []           yomon=True   yaxshi=False  ⚠️

=== 3. Dangasa hisoblash ===
  Ro'yxat bilan:  False, chaqiruvlar: 5
  Generator bilan: False, chaqiruvlar: 3  ← to'xtadi

=== 4. To'plamlar bilan ruxsatlar ===
  Foydalanuvchi       ko'rish   tahrirlash   boshqarish        admin
  ──────────────────────────────────────────────────────────────────
  Mehmon                   ❌           ❌           ❌           ❌
  O'quvchi                 ✅           ❌           ❌           ❌
  Muallif                  ✅           ✅           ❌           ❌
  Moderator                ✅           ✅           ✅           ❌
  Admin                    ✅           ✅           ✅           ✅

Nima ko'rsatdi: 2.5, 2.6-bo'limlar.

Misol 4 — Shartlarni soddalashtirish

python
"""Ruff SIM qoidalari va qo'lda soddalashtirish."""

from dataclasses import dataclass

print("=== Ruff SIM qoidalari ===")

MISOLLAR = [
    (
        "SIM103",
        "if x > 0:\n    return True\nelse:\n    return False",
        "return x > 0",
    ),
    (
        "SIM102",
        "if a:\n    if b:\n        ishla()",
        "if a and b:\n    ishla()",
    ),
    (
        "SIM108",
        "if shart:\n    x = 1\nelse:\n    x = 2",
        "x = 1 if shart else 2",
    ),
    (
        "SIM110",
        "for x in y:\n    if shart(x):\n        return True\nreturn False",
        "return any(shart(x) for x in y)",
    ),
    (
        "SIM111",
        "for x in y:\n    if not shart(x):\n        return False\nreturn True",
        "return all(shart(x) for x in y)",
    ),
    (
        "SIM118",
        "if k in lugat.keys():",
        "if k in lugat:",
    ),
    (
        "SIM201",
        "if not a == b:",
        "if a != b:",
    ),
    (
        "SIM208",
        "if not (not a):",
        "if a:",
    ),
    (
        "E713",
        "if not x in royxat:",
        "if x not in royxat:",
    ),
    (
        "E714",
        "if not x is None:",
        "if x is not None:",
    ),
]

for kod, yomon, yaxshi in MISOLLAR:
    print(f"\n  ── {kod} ──")
    print("  ❌ Oldin:")
    for q in yomon.splitlines():
        print(f"       {q}")
    print("  ✅ Keyin:")
    for q in yaxshi.splitlines():
        print(f"       {q}")


print("\n\n=== Amaliy refaktoring ===")


@dataclass
class Buyurtma:
    summa: int
    shahar: str
    tez: bool = False
    ogirlik: float = 1.0


# ═══ ❌ Soddalashtirilmagan ═══
def yetkazish_yomon(b: Buyurtma) -> int:
    if b.tez == True:
        if b.shahar == "Toshkent":
            return 50000
        else:
            return 100000
    else:
        if b.summa >= 500000:
            if b.ogirlik <= 5.0:
                if b.shahar == "Toshkent":
                    return 0
                else:
                    if b.summa >= 1000000:
                        return 0
                    else:
                        return 30000
            else:
                return 40000
        else:
            if b.shahar == "Toshkent":
                return 25000
            else:
                return 50000


# ═══ ✅ Soddalashtirilgan ═══
def yetkazish_yaxshi(b: Buyurtma) -> int:
    toshkent = b.shahar == "Toshkent"

    # Tez yetkazish
    if b.tez:
        return 50_000 if toshkent else 100_000

    # Og'ir yuk
    if b.summa >= 500_000 and b.ogirlik > 5.0:
        return 40_000

    # Bepul yetkazish
    if b.summa >= 500_000 and toshkent:
        return 0
    if b.summa >= 1_000_000:
        return 0

    # Chegirmali
    if b.summa >= 500_000:
        return 30_000

    # Oddiy
    return 25_000 if toshkent else 50_000


BUYURTMALAR = [
    Buyurtma(300_000, "Toshkent"),
    Buyurtma(300_000, "Samarqand"),
    Buyurtma(600_000, "Toshkent"),
    Buyurtma(600_000, "Samarqand"),
    Buyurtma(1_500_000, "Samarqand"),
    Buyurtma(600_000, "Toshkent", ogirlik=8.0),
    Buyurtma(300_000, "Toshkent", tez=True),
    Buyurtma(300_000, "Buxoro", tez=True),
]

print(f"\n  {'Summa':>10} {'Shahar':<12} {'Tez':>5} {'Ogʻirlik':>9} "
      f"{'Yomon':>8} {'Yaxshi':>8}")
print("  " + "─" * 60)

for b in BUYURTMALAR:
    y = yetkazish_yomon(b)
    x = yetkazish_yaxshi(b)
    assert y == x, f"Farq: {y} != {x}"
    print(f"  {b.summa:>10,} {b.shahar:<12} {b.tez!s:>5} {b.ogirlik:>9.1f} "
          f"{y:>8,} {x:>8,}")


import inspect
import textwrap

print("\n\n=== Solishtirish ===")
for nom, f in [("Yomon", yetkazish_yomon), ("Yaxshi", yetkazish_yaxshi)]:
    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:<8} qatorlar: {len(qatorlar):>3}  max chekinish: {ch}")
text
=== Amaliy refaktoring ===

       Summa Shahar         Tez  Og'irlik    Yomon   Yaxshi
  ────────────────────────────────────────────────────────────
     300,000 Toshkent     False       1.0   25,000   25,000
     300,000 Samarqand    False       1.0   50,000   50,000
     600,000 Toshkent     False       1.0        0        0
     600,000 Samarqand    False       1.0   30,000   30,000
   1,500,000 Samarqand    False       1.0        0        0
     600,000 Toshkent     False       8.0   40,000   40,000
     300,000 Toshkent      True       1.0   50,000   50,000
     300,000 Buxoro        True       1.0  100,000  100,000

=== Solishtirish ===
  Yomon    qatorlar:  21  max chekinish: 5
  Yaxshi   qatorlar:  15  max chekinish: 1

Nima ko'rsatdi: 2.7-bo'lim.

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

Noto'g'ri fikr To'g'risi
"x == 1 or 2 — 'x 1 yoki 2 ga teng'" Har doim rost. x in {1, 2} yozing
"a != b != c — hammasi farqli" Yo'q — a va c solishtirilmaydi
"not (x > 5) ≡ x <= 5" nan bilan farq qiladi
"and va or teng prioritetli" and yuqoriroq
"all([]) → False" True! Bo'sh to'plamga nisbatan "hammasi" rost
"all([shart(x) for x in y]) va generator bir xil" Ro'yxat barchasini hisoblaydi
"De Morgan faqat nazariya" Kundalik soddalashtirish vositasi
"Shartni nomlash sekinlashtiradi" Deyarli yo'q, lekin qisqa tutashuv yo'qoladi

6. Keng tarqalgan xatolar va yechimlari

1. x == 1 or 2

python
if x == 1 or 2:                 # ❌ har doim rost
if x == 1 or x == 2:            # ✅
if x in {1, 2}:                 # ✅ eng yaxshi

2. and/or prioriteti

python
if a or b and c:                # ❌ noaniq
if a or (b and c):              # ✅
if (a or b) and c:              # ✅ boshqa mantiq

3. Ortiqcha inkor

python
if not x in y:                  # ❌ E713
if x not in y:                  # ✅

if not x is None:               # ❌ E714
if x is not None:               # ✅

if not a == b:                  # ❌ SIM201
if a != b:                      # ✅

4. all([]) tuzog'i

python
if all(shart(x) for x in royxat):       # ⚠️ bo'sh → True
if royxat and all(...):                 # ✅

5. Ro'yxat vs generator

python
all([qimmat(x) for x in y])     # ❌ barchasini hisoblaydi
all(qimmat(x) for x in y)       # ✅ birinchi False da to'xtaydi

6. Ichma-ich if

python
if a:
    if b:                       # ❌ SIM102
        ishla()

if a and b:                     # ✅
    ishla()

7. return True/False

python
if x > 0:                       # ❌ SIM103
    return True
return False

return x > 0                    # ✅

8. a != b != c

python
if a != b != c:                 # ❌ a va c solishtirilmaydi
if len({a, b, c}) == 3:         # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 3.5-dars (o'tilgan): and/or qiymat qaytaradi, qisqa tutashuv
  • 3.11-dars (o'tilgan): taqqoslash, in, zanjirli taqqoslash
  • 3.12-dars (o'tilgan): operatorlar prioriteti
  • 5.4-dars: uchlik operator
  • 5.10-dars: siklda any/all naqshi
  • 6-qism: to'plam amallari to'liq
  • 7, 10-qismlar: filter, generatorlar
  • 15-qism: muntazam ifodalarda mantiq

8. Eng yaxshi amaliyotlar

  1. and va or aralashganda qavs qo'ying. Prioritetni yodlashdan ishonchliroq.

  2. x in {a, b, c} ishlating. or zanjiridan qisqa, tez va xatosiz.

  3. Inkorni ichkariga tarqating. x not in y, x is not None, x <= 5.

  4. any/all uchun generator ishlating. Ro'yxat qisqa tutashuvni yo'qotadi.

  5. Bo'sh to'plamdan himoyalaning. bool(x) and all(...).

  6. To'plam amallarini eslang. A <= B — and zanjiridan aniqroq.

  7. Ruff SIM qoidalarini yoqing. U ko'p soddalashtirishni avtomatik topadi.

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

9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
x, y = 5, 10

1.  x == 5 or 2
2.  x == 3 or 2
3.  x in {3, 5}
4.  True or False and False
5.  (True or False) and False
6.  not x == y
7.  x != y
8.  not x > 3
9.  1 != 2 != 1
10. all([])
11. any([])
12. all([0, 1, 2])
Javoblar
  1. True
  2. 2 — truthy, lekin bool emas!
  3. True
  4. True
  5. False
  6. True
  7. True
  8. False
  9. True — 1 va 1 solishtirilmaydi
  10. True
  11. False
  12. False — 0 falsy

Vazifa 2: Xatolarni tuzatish

python
1.  if javob == "ha" or "h":
2.  if not son in royxat:
3.  if not qiymat is None:
4.  if a != b != c:  # uchalasi farqli
5.  if turi == "vip" or summa > 1000000 and faol:
6.  if x > 0:
        return True
    else:
        return False
Javoblar
python
1.  if javob in {"ha", "h"}:
2.  if son not in royxat:
3.  if qiymat is not None:
4.  if len({a, b, c}) == 3:
5.  if (turi == "vip" or summa > 1000000) and faol:
6.  return x > 0

Vazifa 3: De Morgan bilan soddalashtiring

python
1.  not (a and b and c)
2.  not (x > 5 or y < 3)
3.  not (fayl_bor and oqish_mumkin)
4.  not (not a or not b)
5.  not (x in royxat and x > 0)
Javoblar
python
1.  (not a) or (not b) or (not c)
2.  x <= 5 and y >= 3
3.  (not fayl_bor) or (not oqish_mumkin)
4.  a and b
5.  x not in royxat or x <= 0

Vazifa 4: To'plamlar bilan

Ruxsatlar tizimini yozing:

  1. ruxsat_bormi(user, kerak) — barcha kerakli ruxsat bormi
  2. yetishmaydi(user, kerak) — nima yetishmaydi
  3. ortiqcha(user, kerak) — ortiqcha ruxsatlar
  4. umumiy(user1, user2) — ikki foydalanuvchining umumiy ruxsatlari

Vazifa 5: Parol tekshiruvchi

3-misoldagi funksiyani kengaytiring:

  1. Ketma-ket takrorlanuvchi belgilar (aaa) — taqiqlansin
  2. Klaviatura ketma-ketligi (qwerty, 12345) — taqiqlansin
  3. Keng tarqalgan parollar ro'yxati bilan solishtirish
  4. Kuch ballini hisoblash (0-100)

Vazifa 6: Yetkazish narxini soddalashtirish

4-misoldagi yetkazish_yomon funksiyasini o'zingiz soddalashtiring (yechimga qaramasdan). Keyin solishtiring.

Vazifa 7: O'ylash

Nega if x == 1 or 2: sintaksis xatosi emas?

Javob

Chunki bu — yaroqli ifoda.

text
x == 1 or 2

Python uni shunday tahlil qiladi:

  1. == prioriteti or dan yuqori → (x == 1) or 2
  2. or — mantiqiy operator, har qanday operandlarni qabul qiladi
  3. 2 — yaroqli ifoda

Natija: (x == 1) or 2 — sintaktik jihatdan to'g'ri.

Nega Python ogohlantirmaydi?

Chunki bunday yozuv ba'zan foydali:

python
port = konfig.get("port") or 8000       # ✅ sukut qiymat
ism = kirish or "Mehmon"                # ✅
qiymat = a or b or c or sukut           # ✅ birinchi truthy

or ning qiymat qaytarishi — ataylab qilingan xususiyat (3.5-dars). Uni cheklash ko'p foydali naqshni buzardi.

Yechim — linter:

Ba'zi linterlar bu naqshni topadi. Lekin universal emas, chunki x == 1 or funksiya() — mutlaqo normal kod.

Amaliy xulosa: bu — Python bilmagan xato turi. Uni odat bilan oldini oling: ko'p qiymat bilan solishtirishda doim in ishlating.

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

Xulosa

Bu darsda shartlarni birlashtirishni o'rgandik.

Eng muhim uch fikr:

  1. x == 1 or 2 — har doim rost. Bu — eng ko'p uchraydigan mantiqiy xato va Python uni topa olmaydi. Ko'p qiymat bilan solishtirishda doim x in {1, 2}.

  2. De Morgan qonunlari kundalik vosita. not (a and b) ≡ (not a) or (not b). Inkorni ichkariga tarqatish kodni ancha o'qiladigan qiladi: x not in y, x is not None, x <= 5.

  3. any/all uchun generator ishlating, ro'yxat emas. Ro'yxat barcha shartni hisoblaydi; generator birinchi mos kelmaganda to'xtaydi. Va all([]) True ekanini eslang.

Keyingi darsda uchlik operatorni o'rganamiz: x if shart else y — qachon foydali, qachon zararli va uni qanday to'g'ri ishlatish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
5.3-dars: Shartlarni birlashtirish — IlmHamroh