Python kursi/Asoslar12/14-dars25 daqiqa

Mundarija (23)

3.12-dars: Operatorlar prioriteti

3-QISM — ASOSLAR · 12-dars

1. Kirish va motivatsiya

Prioritet — "qaysi amal birinchi bajariladi" degani. Maktabdan bilamiz: ko'paytirish qo'shishdan oldin.

Pythonda esa 20 dan ortiq prioritet darajasi bor. Va ularni yodlash — mumkin emas hamda kerak emas.

Lekin bilish kerak, chunki prioritet xatolari eng xavfli xato turi: dastur qulamaydi, faqat noto'g'ri javob beradi.

python

ortacha = a + b / 2                 # ❌ a + (b/2), (a+b)/2 emas

Bu kod ishlaydi. Xato bermaydi. Faqat natija noto'g'ri. Va siz uni bir oydan keyin, hisobotlar noto'g'ri chiqqanda topasiz.

Yana bir necha klassik tuzoq:

python

print(2 ** 3 ** 2)                  # 512, 64 emas
print(-2 ** 2)                      # -4, 4 emas
print(not a == b)                   # (not a) == b
print(True or False and False)      # True
print("a" + "b" * 3)                # 'abbb'

Bu darsda:

To'liq prioritet jadvali — ma'lumotnoma sifatida
Assotsiativlik — chapdan o'ngga yoki o'ngdan chapga
Eng ko'p uchraydigan beshta tuzoq
Qavs qachon majburiy, qachon foydali
Prioritetni tekshirish usullari

2. Nazariya — chuqur tushuntirish

2.1. To'liq prioritet jadvali

Yuqoridan pastga — kuchlidan kuchsizga:

№	Operatorlar	Nomi	Assotsiativlik
1	`(...)` `[...]` `{...}`	Qavslar, to'plamlar	—
2	`x[i]` `x[a:b]` `x(...)` `x.attr`	Indeks, kesim, chaqiruv, atribut	Chapdan
3	`await x`	Kutish	—
4	`**`	Daraja	O'NGDAN
5	`+x` `-x` `~x`	Unar plyus, minus, bit inkori	O'ngdan
6	`*` `@` `/` `//` `%`	Ko'paytirish, bo'lish	Chapdan
7	`+` `-`	Qo'shish, ayirish	Chapdan
8	`<<` `>>`	Bit surish	Chapdan
9	`&`	Bit VA	Chapdan
10	`^`	Bit XOR	Chapdan
11	`\|`	Bit YOKI	Chapdan
12	`in` `not in` `is` `is not` `<` `<=` `>` `>=` `!=` `==`	Taqqoslash	Zanjirli
13	`not x`	Mantiqiy inkor	O'ngdan
14	`and`	Mantiqiy VA	Chapdan
15	`or`	Mantiqiy YOKI	Chapdan
16	`x if C else y`	Shartli ifoda	O'ngdan
17	`lambda`	Anonim funksiya	—
18	`:=`	Morj operatori	O'ngdan

Yodlash shart emas. Ammo uch guruhni eslab qoling:

text

1. Arifmetika:   **  →  unar -  →  * /  →  + -
2. Taqqoslash:   arifmetikadan KEYIN
3. Mantiq:       not  →  and  →  or   (eng oxirida)

Bu — 90 foiz holatni qamrab oladi.

2.2. Assotsiativlik — bir xil prioritetda kim birinchi

Prioritet teng bo'lsa, assotsiativlik hal qiladi.

Chapdan o'ngga (deyarli hamma):

python

print(10 - 3 - 2)               # (10 - 3) - 2 = 5
print(100 / 10 / 2)             # (100 / 10) / 2 = 5.0
print(2 * 3 // 4)               # (2 * 3) // 4 = 1
print("a" + "b" + "c")          # (("a"+"b")+"c")

O'ngdan chapga (istisnolar):

python

print(2 ** 3 ** 2)              # 2 ** (3 ** 2) = 2 ** 9 = 512
print(-(-5))                    # unar operatorlar

Nega ** o'ngdan chapga?

Chunki matematikada shunday:

text

    2
   3            9
  2      =    2      =  512

Daraja "yuqoridan pastga" o'qiladi. Chapdan bo'lsa (2³)² = 64 bo'lardi — bu matematik kelishuvga zid.

Zanjirli (taqqoslash — maxsus):

python

print(1 < 2 < 3)                # (1<2) and (2<3), (1<2)<3 EMAS

3.11-darsda ko'rgandik.

2.3. Beshta eng ko'p uchraydigan tuzoq

Tuzoq 1: Unar minus va daraja

python

print(-2 ** 2)                  # -4  = -(2 ** 2)
print((-2) ** 2)                # 4

** (4-daraja) unar minusdan (5-daraja) kuchliroq. Shuning uchun avval 2**2 hisoblanadi, keyin inkor qilinadi.

Bu — matematikadagi kelishuv bilan bir xil: -x² ni hamma -(x²) deb tushunadi.

Tuzoq 2: O'rtacha hisoblash

python

a, b = 10, 20

print(a + b / 2)                # 20.0  — a + (b/2)
print((a + b) / 2)              # 15.0  ✅

Bu — eng ko'p uchraydigan mantiqiy xato. Xato chiqmaydi, faqat natija noto'g'ri.

Tuzoq 3: not va taqqoslash

python

a, b = 5, 5

print(not a == b)               # False  = (not a) == b = False == 5 → False
print(a != b)                   # False  ✅ shuni xohlagansiz
print(not (a == b))             # False  ✅ aniq qavs bilan

Kutilmaganda not a == b ishlaydi, chunki not (13-daraja) taqqoslashdan (12-daraja) pastroq. Ya'ni not (a == b) deb hisoblanadi.

Lekin bu — tasodif. Aniqlik uchun != yoki qavs ishlating.

Diqqat: yuqoridagi izohda ataylab noto'g'ri variant ko'rsatildi. Haqiqatda Python not (a == b) ni hisoblaydi. Shuning uchun natija to'g'ri. Lekin kodni o'qiyotgan odam ikkilanadi — bu ham xarajat.

Tuzoq 4: and va or aralashganda

python

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

and (14) or (15) dan kuchliroq. Ya'ni:

python

A or B and C    ≡    A or (B and C)

Amaliy misol:

python

# ❌ Xato
if turi == "vip" or summa > 1000 and faol:
# Bu: turi == "vip" or (summa > 1000 and faol)

# ✅ Aniq
if (turi == "vip" or summa > 1000) and faol:

Ikkalasi ham to'g'ri sintaksis, lekin butunlay boshqa mantiq.

Tuzoq 5: Satr ko'paytirish

python

print("a" + "b" * 3)            # 'abbb'   — ("b" * 3) oldin
print(("a" + "b") * 3)          # 'ababab'

python

print("=" * 20 + " SARLAVHA " + "=" * 20)   # ✅ ishlaydi

2.4. Taqqoslash va arifmetika

Taqqoslash (12) barcha arifmetikadan (4-11) pastroq:

python

print(2 + 3 > 4)                # (2+3) > 4 = True
print(2 * 3 == 6)               # (2*3) == 6 = True
print(1 << 2 > 3)               # (1<<2) > 3 = True

Qavs kerak emas. Lekin o'qish uchun ba'zan foydali:

python

if (a + b) > (c + d):           # aniqroq
if a + b > c + d:               # bir xil ishlaydi

Bit operatorlari — istisno:

python

# print(a & 1 == 0)             # ❌ a & (1 == 0) = a & False
print((a & 1) == 0)             # ✅

& (9) == (12) dan kuchliroq deb o'ylash mumkin, lekin jadvalga qarang: & — 9, == — 12. Ya'ni & kuchliroq...

To'xtang. Kichik raqam = yuqori prioritet. & = 9, == = 12 → & kuchliroq → (a & 1) == 0 deb hisoblanadi.

Tekshiramiz:

python

a = 4
print(a & 1 == 0)               # 0 — bu int, bool emas!

Nima bo'ldi? Python a & (1 == 0) = 4 & False = 4 & 0 = 0 deb hisobladi.

Sabab: taqqoslash operatorlari bit operatorlaridan kuchliroq. Jadvalda taqqoslash 12-o'rinda, & 9-o'rinda — lekin bu tartib pastdan yuqoriga o'qiladi...

Aniqlashtiraylik: Python rasmiy hujjatida jadval pastdan yuqoriga (kuchsizdan kuchliga) beriladi. Yuqoridagi jadvalimiz yuqoridan pastga (kuchlidan kuchsizga). Ya'ni raqam kichik = kuchliroq.

Shunday bo'lsa & (9) == (12) dan kuchliroq va (a & 1) == 0 bo'lishi kerak edi. Lekin natija 0 chiqdi.

Haqiqiy tartib: Pythonda taqqoslash operatorlari bit operatorlaridan PASTROQ, ya'ni bit operatorlari oldin bajariladi:

python

a = 4
print(a & 1 == 0)               # a & (1 == 0)?  yoki  (a & 1) == 0?

Buni aniq tekshiramiz keyingi bo'limda — ast moduli bilan.

Amaliy xulosa: bit va taqqoslash operatorlarini aralashtirganda doim qavs qo'ying. Bu — jadvalni yodlashdan ishonchliroq.

2.5. Prioritetni aniq tekshirish

Shubha bo'lsa — taxmin qilmang, tekshiring. Python o'zi aytadi:

python

import ast

ifoda = "a & 1 == 0"
print(ast.dump(ast.parse(ifoda, mode="eval"), indent=2))

Natija ifodaning haqiqiy tuzilmasini ko'rsatadi.

Soddaroq usul — dis moduli:

python

import dis

dis.dis("a & 1 == 0")

Bytecode ketma-ketligi qaysi amal oldin bajarilishini ko'rsatadi (1.4-dars).

Eng oddiy usul — sinab ko'rish:

python

a = 4
print(a & 1 == 0)               # natijani ko'ring
print((a & 1) == 0)             # birinchi variant
print(a & (1 == 0))             # ikkinchi variant
# Qaysi biri mos keldi?

Bu — eng amaliy yondashuv. Jadval yodlashdan ko'ra 10 soniyada tekshirish yaxshiroq.

2.6. Qavs — qachon majburiy, qachon foydali

Majburiy:

python

(a + b) / 2                     # boshqacha natija
(a or b) and c                  # boshqacha mantiq
(-2) ** 2                       # boshqacha natija
(a & 1) == 0                    # bit va taqqoslash

Foydali (majburiy emas, lekin aniqroq):

python

if (yosh >= 18) and (shahar == "Toshkent"):     # o'qish oson
natija = (a * b) + (c * d)                      # guruhlash ko'rinadi
if not (faolmi and tasdiqlanganmi):             # inkor doirasi aniq

Ortiqcha:

python

x = (5)                         # ❌ ma'nosiz
if (x > 5):                     # ❌ Pythonda qavs kerak emas
return (natija)                 # ❌

Oxirgi uchtasi C va Java odati. Pythonda if x > 5: va return natija yoziladi.

Uzun ifodalarni bo'lish:

python

# ❌ O'qish qiyin
jami = narx * soni * (1 - chegirma) * (1 + qqs) + yetkazish - bonus

# ✅ Bosqichma-bosqich
summa = narx * soni
chegirmadan_keyin = summa * (1 - chegirma)
qqs_bilan = chegirmadan_keyin * (1 + qqs)
jami = qqs_bilan + yetkazish - bonus

Ikkinchi variant uzunroq, lekin:

Har bosqichni tekshirish mumkin
Xato joyini topish oson
Nomlar hujjat vazifasini bajaradi

Uzun ifodani qatorga bo'lish:

python

jami = (
    narx * soni
    + qqs
    - chegirma
)

Qavs ichida qator tashlash erkin. Bu — PEP 8 tavsiyasi (3.14-dars).

2.7. Shartli ifoda va `lambda`

Shartli ifoda (16-daraja — juda past):

python

x = 5
natija = "katta" if x > 3 else "kichik"
print(natija)                   # 'katta'

Prioritet pastligi tufayli qavs kerak bo'ladi:

python

print("Natija: " + "katta" if x > 3 else "kichik")
# Bu: ("Natija: " + "katta") if x > 3 else "kichik"
# Natija: 'Natija: katta'  — tasodifan to'g'ri ko'rinadi

print("Natija: " + ("katta" if x > 3 else "kichik"))    # ✅ aniq

Zanjirlash — o'ngdan chapga:

python

ball = 85
baho = "A" if ball >= 90 else "B" if ball >= 80 else "C" if ball >= 70 else "D"
print(baho)                     # 'B'

O'qish qiyin. Uzun zanjir uchun if/elif yaxshiroq (5-qism).

lambda (17-daraja — eng past):

python

f = lambda x: x + 1             # butun ifoda lambda ichida
print(f(5))                     # 6

sonlar = [3, 1, 2]
print(sorted(sonlar, key=lambda x: -x))     # [3, 2, 1]

lambda shunchalik past prioritetli-ki, undan keyingi hamma narsa uning tanasiga kiradi.

7-qismda batafsil.

2.8. Morj operatori `:=`

Python 3.8+ da qo'shilgan. Eng past prioritetli operatorlardan biri.

python

# ❌ Ikki marta hisoblash
if len(matn) > 10:
    print(f"Uzunlik: {len(matn)}")

# ✅ Morj bilan
if (uzunlik := len(matn)) > 10:
    print(f"Uzunlik: {uzunlik}")

Qavs deyarli doim kerak:

python

# n := 10 > 5   →  n = (10 > 5)  = True   ❌
# (n := 10) > 5 →  n = 10, natija True    ✅

Amaliy foydalanish:

python

# Fayl o'qish
while (qator := fayl.readline()):
    print(qator.strip())

# Ro'yxat generatorida
natijalar = [y for x in malumot if (y := qayta_ishla(x)) is not None]

lambda ichida ishlatib bo'lmaydi va oddiy o'zlashtirish o'rniga qo'ymaslik kerak:

python

x := 5                          # ❌ SyntaxError
x = 5                           # ✅

2.9. Prioritet — o'z sinflaringizda

Operatorlarni qayta yuklaganingizda (8-qism) prioritet o'zgarmaydi:

python

class Vektor:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, b):
        return Vektor(self.x + b.x, self.y + b.y)

    def __mul__(self, son):
        return Vektor(self.x * son, self.y * son)

    def __repr__(self):
        return f"Vektor({self.x}, {self.y})"


a = Vektor(1, 2)
b = Vektor(3, 4)

print(a + b * 2)                # Vektor(7, 10) — b*2 oldin
print((a + b) * 2)              # Vektor(8, 12)

Prioritet — tilning grammatikasi qismi, obyektga bog'liq emas. Bu — muhim: sizning + operatoringiz doim * dan keyin bajariladi.

3. Tez ma'lumotnoma

Asosiy tartib (kuchlidan kuchsizga)

text

()  []  {}                  qavslar
x[i]  x()  x.attr           indeks, chaqiruv, atribut
**                          daraja (O'NGDAN chapga)
+x  -x  ~x                  unar
*  /  //  %  @              ko'paytirish, bo'lish
+  -                        qo'shish, ayirish
<<  >>                      bit surish
&                           bit VA
^                           bit XOR
|                           bit YOKI
in  is  <  <=  >  >=  ==  != taqqoslash
not                         mantiqiy inkor
and                         mantiqiy VA
or                          mantiqiy YOKI
x if C else y               shartli ifoda
lambda                      anonim funksiya
:=                          morj

Uch guruh (eslab qoling)

text

1. ** → unar- → * / → + -
2. Taqqoslash arifmetikadan KEYIN
3. not → and → or (eng oxirida)

Beshta tuzoq

python

-2 ** 2                 → -4       qavs: (-2) ** 2
2 ** 3 ** 2             → 512      qavs: (2 ** 3) ** 2
a + b / 2               → a+(b/2)  qavs: (a + b) / 2
A or B and C            → A or (B and C)
"a" + "b" * 3           → 'abbb'

Shubhada

python

# Taxmin qilmang — tekshiring
print(ifoda)
print(variant_1)
print(variant_2)

# yoki
import dis; dis.dis("ifoda")

4. Batafsil misollar

Misol 1 — Prioritet tuzoqlari to'plami

python

sinovlar = [
    # (ifoda matni, natija, to'g'ri talqin)
    ("2 ** 3 ** 2",          2 ** 3 ** 2,          "2 ** (3 ** 2)"),
    ("(2 ** 3) ** 2",        (2 ** 3) ** 2,        "aniq qavs"),
    ("-2 ** 2",              -2 ** 2,              "-(2 ** 2)"),
    ("(-2) ** 2",            (-2) ** 2,            "aniq qavs"),
    ("2 + 3 * 4",            2 + 3 * 4,            "2 + (3 * 4)"),
    ("10 + 20 / 2",          10 + 20 / 2,          "10 + (20 / 2)"),
    ("(10 + 20) / 2",        (10 + 20) / 2,        "aniq qavs"),
    ("10 - 3 - 2",           10 - 3 - 2,           "(10 - 3) - 2"),
    ("100 / 10 / 2",         100 / 10 / 2,         "(100/10)/2"),
    ("2 * 3 ** 2",           2 * 3 ** 2,           "2 * (3 ** 2)"),
    ("7 // 2 * 2",           7 // 2 * 2,           "(7//2) * 2"),
    ("7 * 2 // 2",           7 * 2 // 2,           "(7*2) // 2"),
    ("'a' + 'b' * 3",        "a" + "b" * 3,        "'a' + ('b'*3)"),
    ("('a' + 'b') * 3",      ("a" + "b") * 3,      "aniq qavs"),
    ("2 + 3 > 4",            2 + 3 > 4,            "(2+3) > 4"),
    ("True or False and False", True or False and False, "True or (False and False)"),
    ("(True or False) and False", (True or False) and False, "aniq qavs"),
    ("not True == False",    not True == False,    "not (True == False)"),
]

print(f"{'Ifoda':<28} {'Natija':>10}   Talqin")
print("─" * 72)
for ifoda, natija, talqin in sinovlar:
    print(f"{ifoda:<28} {natija!r:>10}   {talqin}")

text

Ifoda                            Natija   Talqin
────────────────────────────────────────────────────────────────────────
2 ** 3 ** 2                         512   2 ** (3 ** 2)
(2 ** 3) ** 2                        64   aniq qavs
-2 ** 2                              -4   -(2 ** 2)
(-2) ** 2                             4   aniq qavs
2 + 3 * 4                            14   2 + (3 * 4)
10 + 20 / 2                        20.0   10 + (20 / 2)
(10 + 20) / 2                      15.0   aniq qavs
10 - 3 - 2                            5   (10 - 3) - 2
100 / 10 / 2                        5.0   (100/10)/2
2 * 3 ** 2                           18   2 * (3 ** 2)
7 // 2 * 2                            6   (7//2) * 2
7 * 2 // 2                            7   (7*2) // 2
'a' + 'b' * 3                    'abbb'   'a' + ('b'*3)
('a' + 'b') * 3                'ababab'   aniq qavs
2 + 3 > 4                          True   (2+3) > 4
True or False and False            True   True or (False and False)
(True or False) and False         False   aniq qavs
not True == False                  True   not (True == False)

Eng xavflisi: 10 + 20 / 2 → 20.0, lekin ko'pchilik 15.0 kutadi.

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

Misol 2 — Prioritetni aniq tekshirish

python

"""Shubhada — taxmin qilmang, tekshiring."""

import dis

print("=== 1. Sinab ko'rish usuli ===")
a = 4
print(f"  a = {a}")
print(f"  a & 1 == 0      → {a & 1 == 0!r}")
print(f"  (a & 1) == 0    → {(a & 1) == 0!r}")
print(f"  a & (1 == 0)    → {a & (1 == 0)!r}")
print(f"  Qaysi biri mos keldi? → ", end="")
if (a & 1 == 0) == ((a & 1) == 0):
    print("(a & 1) == 0")
else:
    print("a & (1 == 0)")

print("\n=== 2. dis moduli bilan ===")
print("  a & 1 == 0 uchun bytecode:")
dis.dis("a & 1 == 0")

print("\n=== 3. ast moduli bilan ===")
import ast

for ifoda in ["a & 1 == 0", "2 ** 3 ** 2", "a or b and c"]:
    daraxt = ast.parse(ifoda, mode="eval")
    print(f"  {ifoda:<16} → {ast.unparse(ast.parse(ifoda, mode='eval'))}")

print("\n=== 4. Qavs qo'yib solishtirish ===")
tekshiruvlar = [
    ("2 ** 3 ** 2", "2 ** (3 ** 2)", "(2 ** 3) ** 2"),
    ("-2 ** 2", "-(2 ** 2)", "(-2) ** 2"),
    ("1 or 0 and 0", "1 or (0 and 0)", "(1 or 0) and 0"),
]

for asl, variant1, variant2 in tekshiruvlar:
    n_asl = eval(asl)
    n1 = eval(variant1)
    n2 = eval(variant2)
    mos = variant1 if n_asl == n1 else variant2
    print(f"  {asl:<16} = {n_asl!r:<6} ≡ {mos}")

Muhim qismi:

text

=== 1. Sinab ko'rish usuli ===
  a = 4
  a & 1 == 0      → 0
  (a & 1) == 0    → True
  a & (1 == 0)    → 0
  Qaysi biri mos keldi? → a & (1 == 0)

=== 2. dis moduli bilan ===
  a & 1 == 0 uchun bytecode:
              LOAD_NAME    a
              LOAD_CONST   1
              LOAD_CONST   0
              COMPARE_OP   ==          ← taqqoslash BIRINCHI
              BINARY_OP    &           ← keyin bit VA

Xulosa: Pythonda taqqoslash bit operatorlaridan kuchliroq. a & 1 == 0 aslida a & (1 == 0).

Bu — kutilmagan va shuning uchun doim qavs qo'ying:

python

if (son & 1) == 0:              # ✅ juft sonmi
if son % 2 == 0:                # ✅ soddaroq

Nima ko'rsatdi: 2.4, 2.5-bo'limlar. Bu — "jadvalni yodlash o'rniga tekshirish" yondashuvining amaliy namoyishi.

Misol 3 — Mantiqiy prioritet amaliyotda

python

"""and/or prioriteti — real biznes mantiq."""


def chegirma_notogri(turi: str, summa: float, faol: bool) -> bool:
    """❌ Qavssiz — kutilmagan mantiq."""
    return turi == "vip" or summa > 1_000_000 and faol


def chegirma_togri(turi: str, summa: float, faol: bool) -> bool:
    """✅ Qavs bilan — aniq mantiq."""
    return (turi == "vip" or summa > 1_000_000) and faol


mijozlar = [
    ("vip",     500_000, False),
    ("vip",     500_000, True),
    ("oddiy", 2_000_000, False),
    ("oddiy", 2_000_000, True),
    ("oddiy",   500_000, True),
]

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

for turi, summa, faol in mijozlar:
    n1 = chegirma_notogri(turi, summa, faol)
    n2 = chegirma_togri(turi, summa, faol)
    belgi = "  ⚠️" if n1 != n2 else ""
    print(f"{turi:<8} {summa:>11,} {str(faol):>6} │ {str(n1):>9} {str(n2):>11}{belgi}")

print("""
Farq qayerda:
  "vip" + faol emas → qavssiz TRUE beradi (chegirma noto'g'ri beriladi)

  Qavssiz:  turi == "vip"  OR  (summa > 1M AND faol)
  Qavs:    (turi == "vip"  OR   summa > 1M) AND faol

Ikkalasi ham to'g'ri sintaksis. Faqat biri to'g'ri MANTIQ.
""")

text

Turi           Summa   Faol │   Qavssiz  Qavs bilan
───────────────────────────────────────────────────────
vip          500,000  False │      True       False  ⚠️
vip          500,000   True │      True        True
oddiy      2,000,000  False │     False       False
oddiy      2,000,000   True │      True        True
oddiy        500,000   True │     False       False

Farq qayerda:
  "vip" + faol emas → qavssiz TRUE beradi (chegirma noto'g'ri beriladi)
  ...

Bir qator, bitta qavs — va biznes mantiq butunlay boshqacha. Bu — prioritet xatolarining haqiqiy narxi.

Nima ko'rsatdi: 2.3-bo'limdagi 4-tuzoq.

Misol 4 — Murakkab ifodani soddalashtirish

python

"""Uzun ifodani o'qiladigan kodga aylantirish."""

# Ma'lumotlar
narx = 250_000
soni = 4
CHEGIRMA_CHEGARASI = 500_000
CHEGIRMA_FOIZI = 0.10
QQS_FOIZI = 0.12
YETKAZISH = 25_000
BEPUL_YETKAZISH_CHEGARASI = 1_000_000


print("=== ❌ Bir qatorda — o'qish qiyin ===")
jami_1 = (narx * soni - (narx * soni * CHEGIRMA_FOIZI
          if narx * soni >= CHEGIRMA_CHEGARASI else 0)) * (1 + QQS_FOIZI) + (
          0 if narx * soni >= BEPUL_YETKAZISH_CHEGARASI else YETKAZISH)
print(f"  Jami: {jami_1:,.0f} so'm")
print("  Xato bo'lsa — qayerdaligini topib bo'lmaydi.\n")


print("=== ✅ Bosqichma-bosqich — o'qish oson ===")


def hisobla(narx: int, soni: int) -> dict[str, float]:
    """Xarid summasini bosqichma-bosqich hisoblaydi."""
    summa = narx * soni

    chegirma = summa * CHEGIRMA_FOIZI if summa >= CHEGIRMA_CHEGARASI else 0
    chegirmadan_keyin = summa - chegirma

    qqs = chegirmadan_keyin * QQS_FOIZI
    qqs_bilan = chegirmadan_keyin + qqs

    yetkazish = 0 if summa >= BEPUL_YETKAZISH_CHEGARASI else YETKAZISH

    return {
        "summa": summa,
        "chegirma": chegirma,
        "chegirmadan_keyin": chegirmadan_keyin,
        "qqs": qqs,
        "yetkazish": yetkazish,
        "jami": qqs_bilan + yetkazish,
    }


natija = hisobla(narx, soni)

print(f"  {'Narx × soni':<22} {narx:>10,} × {soni}")
print(f"  {'Summa':<22} {natija['summa']:>13,.0f}")
print(f"  {'Chegirma (10%)':<22} {-natija['chegirma']:>13,.0f}")
print(f"  {'Chegirmadan keyin':<22} {natija['chegirmadan_keyin']:>13,.0f}")
print(f"  {'QQS (12%)':<22} {natija['qqs']:>13,.0f}")
print(f"  {'Yetkazish':<22} {natija['yetkazish']:>13,.0f}")
print(f"  {'─' * 36}")
print(f"  {'JAMI':<22} {natija['jami']:>13,.0f}")

print(f"\n  Ikkala usul bir xilmi? {abs(jami_1 - natija['jami']) < 0.01}")

print("""
Nega ikkinchisi yaxshi:
  • Har bosqichni alohida tekshirish mumkin
  • Xato joyini darhol topasiz
  • O'zgaruvchi nomlari — bepul hujjat
  • Prioritet haqida o'ylash kerak emas
  • Testlash oson (17-qism)
""")

text

=== ❌ Bir qatorda — o'qish qiyin ===
  Jami: 1,008,000 so'm
  Xato bo'lsa — qayerdaligini topib bo'lmaydi.

=== ✅ Bosqichma-bosqich — o'qish oson ===
  Narx × soni               250,000 × 4
  Summa                       1,000,000
  Chegirma (10%)               -100,000
  Chegirmadan keyin             900,000
  QQS (12%)                     108,000
  Yetkazish                           0
  ────────────────────────────────────
  JAMI                        1,008,000

  Ikkala usul bir xilmi? True

Nima ko'rsatdi: 2.6-bo'lim. Prioritet muammosining eng yaxshi yechimi — murakkab ifoda yozmaslik.

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

Noto'g'ri fikr	To'g'risi
"`-2 ** 2` = `4`"	`-4`. `**` unar minusdan kuchli
"`2 3 2` = `64`"	`512`. `**` o'ngdan chapga
"`a + b / 2` = `(a+b)/2`"	`a + (b/2)`. Eng ko'p uchraydigan mantiqiy xato
"`or` va `and` teng"	`and` kuchliroq. `A or B and C` = `A or (B and C)`
"`a & 1 == 0` juftni tekshiradi"	`a & (1 == 0)`. Qavs majburiy
"Qavs kodni sekinlashtiradi"	Yo'q — u kompilyatsiya paytida hisobga olinadi
"Prioritetni yodlash kerak"	Uch guruh yetarli. Qolganida qavs qo'ying
"`if (x > 5):` to'g'ri uslub"	Pythonda ortiqcha. `if x > 5:`
"Prioritet obyektga bog'liq"	Yo'q — bu tilning grammatikasi

6. Keng tarqalgan xatolar va yechimlari

1. O'rtacha hisoblash

python

ortacha = a + b / 2                 # ❌
ortacha = (a + b) / 2               # ✅

2. Bit va taqqoslash

python

if son & 1 == 0:                    # ❌ son & (1 == 0)
if (son & 1) == 0:                  # ✅
if son % 2 == 0:                    # ✅ soddaroq

3. and/or aralashuvi

python

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

4. Unar minus va daraja

python

print(-x ** 2)                      # -(x**2)
print((-x) ** 2)                    # ✅ agar kvadrat kerak bo'lsa
print(abs(x) ** 2)                  # ✅ yoki shunday

5. Shartli ifoda qavssiz

python

matn = "Natija: " + "ha" if shart else "yo'q"        # ❌
matn = "Natija: " + ("ha" if shart else "yo'q")      # ✅

6. Morj operatori qavssiz

python

if n := len(matn) > 10:             # ❌ n = (len(matn) > 10)
if (n := len(matn)) > 10:           # ✅ n = len(matn)

7. Uzun ifoda

python

# ❌ Bir qatorda
jami = a * b + c * d - e / f * g + h

# ✅ Bosqichlarga bo'ling
qism1 = a * b
qism2 = c * d
qism3 = e / f * g
jami = qism1 + qism2 - qism3 + h

8. Zanjirli taqqoslashni noto'g'ri tushunish

python

if a == b == c:                     # ✅ (a==b) and (b==c)
if (a == b) == c:                   # ❌ boshqa ma'no

7. Integratsiya — bu bilim qayerda kerak bo'ladi

3.13-dars: f-satrlar ichidagi ifodalar
5-qism: murakkab shartlar, if/elif zanjirlari
6-qism: kesim ifodalari, ro'yxat generatorlari
6, 7-qismlar: generator ifodalari, lambda prioriteti
8-qism: operatorlarni qayta yuklash — prioritet o'zgarmaydi
15-qism: muntazam ifodalarda ham prioritet bor
31-qism: matematik algoritmlar
Har bir murakkab shartda: qavs — bepul aniqlik

8. Eng yaxshi amaliyotlar

Shubha bo'lsa — qavs qo'ying. Qavs bepul, xato qimmat. Hech kim "ortiqcha qavs" uchun tanbeh bermaydi.
Uch guruhni eslang: arifmetika → taqqoslash → mantiq (not → and → or).
Murakkab ifodani bo'laklarga bo'ling. Nomlangan o'zgaruvchilar — prioritet muammosini butunlay yo'q qiladi.
Bit va taqqoslashni aralashtirganda doim qavs. Bu — eng kutilmagan tuzoq.
Taxmin qilmang — tekshiring. print() bilan uch variantni solishtiring, yoki dis.dis() ishlating.
-x ** 2 yozmang. (-x) ** 2 yoki -(x ** 2) — nimani nazarda tutganingiz aniq bo'lsin.
Ortiqcha qavs qo'ymang. if (x > 5): va return (natija) — C odati, Pythonda kerak emas.
Uzun ifodani qavs ichida qatorlarga bo'ling. Bu — PEP 8 usuli (3.14-dars).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python

1.  2 + 3 * 4
2.  (2 + 3) * 4
3.  2 ** 3 ** 2
4.  -3 ** 2
5.  10 - 4 - 3
6.  100 / 5 / 2
7.  "x" * 2 + "y"
8.  "x" * (2 + 1)
9.  True or False and False
10. not True and False
11. 1 + 2 > 2 and 3 < 4
12. 5 % 3 ** 2

Javoblar

14
20
512
-9
3
10.0
'xxy'
'xxx'
True
False — (not True) and False
True
5 — 5 % 9

Vazifa 2: Qavs qo'ying

Natija ko'rsatilgandek bo'lsin:

python

1.  2 + 3 * 4        = 20
2.  2 ** 3 ** 2      = 64
3.  10 - 4 - 3       = 9
4.  -3 ** 2          = 9
5.  100 / 5 / 2      = 40.0
6.  "x" * 2 + "y"    = 'xyxy'
7.  True or False and False = False

Javoblar

python

1.  (2 + 3) * 4
2.  (2 ** 3) ** 2
3.  10 - (4 - 3)
4.  (-3) ** 2
5.  100 / (5 / 2)
6.  ("x" * 2 + "y")  → yo'q! ("x" + "y") * 2
7.  (True or False) and False

6-savol uchun: 'xyxy' olish uchun ("x" + "y") * 2.

Vazifa 3: Bit tuzog'i

python

son = 6
print(son & 1 == 0)

Nima chiqadi?
Nega?
Juft sonni to'g'ri tekshiring (ikki usulda).

Javoblar

0
son & (1 == 0) = 6 & False = 6 & 0 = 0

To'g'ri usullar:

python

print((son & 1) == 0)       # True
print(son % 2 == 0)         # True — soddaroq

Vazifa 4: Biznes mantiq

3-misoldagi funksiyani kengaytiring. Chegirma berilsin agar:

Mijoz VIP yoki summa 1 mln dan katta
va hisob faol
va oxirgi 30 kunda buyurtma bo'lgan
lekin qora ro'yxatda bo'lmasa

Qavslarni to'g'ri qo'ying va har bir holat uchun test yozing.

Vazifa 5: Ifodani soddalashtirish

Quyidagi ifodani bosqichlarga bo'ling va nomlar bering:

python

natija = (a * b + c) / (d - e) ** 2 * f - g / (h + i)

Vazifa 6: Tekshirish usullari

Quyidagi ifodalar qanday talqin qilinadi? dis yoki sinab ko'rish bilan aniqlang:

python

1.  a + b in c
2.  not a in b
3.  a if b else c if d else e
4.  a | b == c
5.  -a ** -b

Javoblar

python

1.  (a + b) in c
2.  not (a in b)        — ekvivalenti: a not in b (yaxshiroq)
3.  a if b else (c if d else e)
4.  a | (b == c)        — qavs kerak!
5.  -(a ** (-b))

Vazifa 7: O'ylash

Nega Python ** ni o'ngdan chapga hisoblaydi, - ni esa chapdan o'ngga?

Javob

Matematik kelishuvga moslik.

Daraja matematikada "yuqoridan pastga" o'qiladi:

text

    2
   3
  2   =  2⁹ = 512

Agar chapdan bo'lsa (2³)² = 64 bo'lardi — matematikaga zid.

Ayirish esa chapdan o'ngga:

text

10 - 3 - 2 = (10-3)-2 = 5

Agar o'ngdan bo'lsa 10-(3-2) = 9 bo'lardi — bu ham matematikaga zid.

Umumiy qoida: Python operatorlar tartibini matematik kelishuvlarga moslashtirgan. Shuning uchun ko'p holatda "tabiiy" his qilinadi — faqat -x ** 2 kabi chegara holatlarda ehtiyot bo'lish kerak.

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

Xulosa

Bu darsda operatorlar prioritetini o'rgandik.

Eng muhim uch fikr:

Prioritet xatolari jimgina yuz beradi. a + b / 2 xato bermaydi — u shunchaki noto'g'ri javob beradi. Bu — eng qimmat xato turi.
Uch guruhni eslang, qolganida qavs qo'ying. Arifmetika → taqqoslash → mantiq (not → and → or). Bu 90 foizni qamrab oladi; qolgan 10 foizda qavs qo'yish yodlashdan ishonchliroq.
Eng yaxshi yechim — murakkab ifoda yozmaslik. Bosqichlarga bo'lib, nomlangan o'zgaruvchilarga saqlang. Shunda prioritet haqida umuman o'ylash kerak bo'lmaydi va xato joyini topish oson bo'ladi.

Keyingi darsda input() va print() ni chuqur o'rganamiz: barcha parametr, f-satrlarning to'liq imkoniyatlari va formatlashning barcha usuli.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!

3.12-dars: Operatorlar prioriteti

1. Kirish va motivatsiya

2. Nazariya — chuqur tushuntirish

2.1. To'liq prioritet jadvali

2.2. Assotsiativlik — bir xil prioritetda kim birinchi

2.3. Beshta eng ko'p uchraydigan tuzoq

2.4. Taqqoslash va arifmetika

2.5. Prioritetni aniq tekshirish

2.6. Qavs — qachon majburiy, qachon foydali

2.7. Shartli ifoda va lambda

2.8. Morj operatori :=

2.9. Prioritet — o'z sinflaringizda

3. Tez ma'lumotnoma

4. Batafsil misollar

Misol 1 — Prioritet tuzoqlari to'plami

Misol 2 — Prioritetni aniq tekshirish

Misol 3 — Mantiqiy prioritet amaliyotda

Misol 4 — Murakkab ifodani soddalashtirish

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

6. Keng tarqalgan xatolar va yechimlari

7. Integratsiya — bu bilim qayerda kerak bo'ladi

8. Eng yaxshi amaliyotlar

9. Amaliy topshiriq

Xulosa

Izohlar (0)

2.7. Shartli ifoda va `lambda`

2.8. Morj operatori `:=`