Python kursi/Asoslar10/14-dars25 daqiqa

Mundarija (23)

3.10-dars: Arifmetik operatorlar

3-QISM — ASOSLAR · 10-dars

1. Kirish va motivatsiya

Arifmetika — eng oddiy mavzu, shundaymi? +, -, *, /. Maktabdan bilamiz.

Lekin Pythonda operatorlar sonlarga tegishli emas — ular obyektlarga tegishli:

python

print(3 * 4)                    # 12
print("ha" * 3)                 # 'hahaha'
print([1, 2] * 2)               # [1, 2, 1, 2]
print((1, 2) + (3, 4))          # (1, 2, 3, 4)

Bir xil operator — turli ma'no. Bu — operatorlarni qayta yuklash (8-qism).

Va bir necha nozik jihat bor:

python

print(7 // 2)                   # 3
print(7.0 // 2)                 # 3.0   ← float!
print(2 ** 3 ** 2)              # 512   ← 64 emas
print(-2 ** 2)                  # -4    ← 4 emas

Bu darsda:

Barcha arifmetik operator va ularning nozik jihatlari
Turlar aralashganda nima qaytadi
Joyida o'zgartiruvchi shakllar (+=) va ular bilan bog'liq tuzoq
divmod, abs, pow va math moduli
Operatorlarning obyektlar uchun ma'nosi

2. Nazariya — chuqur tushuntirish

2.1. Asosiy operatorlar

Operator	Nomi	Misol	Natija
`+`	Qo'shish	`7 + 2`	`9`
`-`	Ayirish	`7 - 2`	`5`
`*`	Ko'paytirish	`7 * 2`	`14`
`/`	Haqiqiy bo'lish	`7 / 2`	`3.5`
`//`	Butun bo'lish	`7 // 2`	`3`
`%`	Qoldiq	`7 % 2`	`1`
`**`	Daraja	`7 ** 2`	`49`

Unar operatorlar:

python

x = 5
print(-x)                   # -5   — inkor
print(+x)                   # 5    — kam ishlatiladi
print(-(-x))                # 5

3.3-darsda /, //, % ni batafsil ko'rdik. Qisqacha eslatma:

python

print(7 / 2)                # 3.5  — DOIM float
print(7 // 2)               # 3    — pastga yaxlitlash
print(-7 // 2)              # -4   — nolga emas, PASTGA
print(-7 % 3)               # 2    — bo'luvchi ishorasini oladi

2.2. Turlar aralashganda

Python kengroq turga aylantiradi:

text

bool → int → float → complex

python

print(1 + 2)                # 3         int
print(1 + 2.0)              # 3.0       float
print(True + 1)             # 2         int
print(True + 1.0)           # 2.0       float
print(1 + 2j)               # (1+2j)    complex
print(2 ** 0.5)             # 1.414...  float

Jadval:

Amal	`int` + `int`	`int` + `float`	`bool` + `int`
`+` `-` `*`	`int`	`float`	`int`
`/`	`float`	`float`	`float`
`//` `%`	`int`	`float`	`int`
`**`	`int` yoki `float`*	`float`	`int`

* 2 ** 3 → 8 (int), lekin 2 ** -1 → 0.5 (float)

// turni saqlaydi:

python

print(7 // 2)               # 3     int
print(7.0 // 2)             # 3.0   float!
print(type(7.0 // 2))       # <class 'float'>
print(int(7.0 // 2))        # 3     agar int kerak bo'lsa

Bu — 3.9-darsdagi mavzuning davomi.

2.3. `**` — daraja va uning nozikliklari

python

print(2 ** 10)              # 1024
print(2 ** 0.5)             # 1.4142135623730951  — kvadrat ildiz
print(8 ** (1/3))           # 2.0                 — kub ildiz
print(2 ** -1)              # 0.5
print((-8) ** (1/3))        # (1.0000000000000002+1.7320508075688772j) — kompleks!

Ikki muhim tuzoq:

1. ** — o'ngdan chapga:

python

print(2 ** 3 ** 2)          # 512  = 2 ** (3 ** 2) = 2 ** 9
print((2 ** 3) ** 2)        # 64

Deyarli barcha boshqa operator chapdan o'ngga hisoblanadi. ** — istisno.

2. Unar minus ** dan past prioritetli:

python

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

Bu — matematikadagi kelishuv bilan bir xil, lekin kutilmagan bo'lishi mumkin.

pow() — uch argumentli shakl:

python

print(pow(2, 10))           # 1024
print(pow(2, 10, 1000))     # 24  = (2**10) % 1000

3.3-darsda ko'rgandik: uchinchi argument bilan millionlab marta tez. Kriptografiyada asosiy vosita.

Manfiy asos va kasr daraja:

python

import math

print(math.sqrt(16))            # 4.0
# print(math.sqrt(-16))         # ❌ ValueError
print((-16) ** 0.5)             # (2.4492935982947064e-16+4j) — kompleks
print(math.isqrt(17))           # 4  — butun ildiz (3.3-dars)

2.4. Joyida o'zgartiruvchi operatorlar

python

x = 10
x += 5          # x = x + 5
x -= 3          # x = x - 3
x *= 2          # x = x * 2
x /= 4          # x = x / 4
x //= 2         # x = x // 2
x %= 3          # x = x % 3
x **= 2         # x = x ** 2

MUHIM: bu to'liq x = x + 5 bilan bir xil emas.

O'zgaruvchan obyektlar uchun += joyida o'zgartiradi:

python

a = [1, 2]
b = a
a += [3]                    # joyida o'zgartiradi
print(a)                    # [1, 2, 3]
print(b)                    # [1, 2, 3]  ← b ham o'zgardi!

python

a = [1, 2]
b = a
a = a + [3]                 # YANGI ro'yxat yaratadi
print(a)                    # [1, 2, 3]
print(b)                    # [1, 2]     ← b o'zgarmadi

Nima bo'lyapti?

a += [3] → a.__iadd__([3]) → a.extend([3]) → joyida
a = a + [3] → a.__add__([3]) → yangi obyekt

O'zgarmas turlar (int, str, tuple) uchun farq yo'q — ular joyida o'zgara olmaydi:

python

a = "abc"
b = a
a += "d"
print(a)                    # 'abcd'
print(b)                    # 'abc'  ← o'zgarmadi

Bu — 3.1-darsdagi yorliq modeli va 3.7-darsdagi o'zgarmaslikning davomi.

Juftlik bilan g'alati holat:

python

t = ([1, 2], 3)
t[0] += [4]

text

TypeError: 'tuple' object does not support item assignment

Lekin:

python

print(t)                    # ([1, 2, 4], 3)  ← O'ZGARDI!

Xato ham chiqdi, ro'yxat ham o'zgardi. Sabab: += avval extend ni bajardi (muvaffaqiyatli), keyin t[0] = natija ni urindi (muvaffaqiyatsiz). 6-qismda batafsil.

2.5. Satr va to'plamlar bilan arifmetika

Satrlar:

python

print("Salom" + ", " + "dunyo")     # 'Salom, dunyo'
print("ab" * 3)                     # 'ababab'
print(3 * "ab")                     # 'ababab' — tartib muhim emas
print("-" * 40)                     # chiziq chizish
# print("ab" - "b")                 # ❌ TypeError
# print("ab" / 2)                   # ❌ TypeError

Ro'yxat va juftlik:

python

print([1, 2] + [3, 4])              # [1, 2, 3, 4]
print([0] * 5)                      # [0, 0, 0, 0, 0]
print((1, 2) + (3,))                # (1, 2, 3)
print((1, 2) * 2)                   # (1, 2, 1, 2)

Ko'paytirish tuzog'i — ichma-ich ro'yxatlar:

python

jadval = [[0] * 3] * 3
print(jadval)                       # [[0,0,0], [0,0,0], [0,0,0]]

jadval[0][0] = 1
print(jadval)                       # [[1,0,0], [1,0,0], [1,0,0]]  ← hammasi!

Sabab: * 3 bitta ro'yxatga uchta yorliq yaratdi (3.1-dars).

To'g'ri usul:

python

jadval = [[0] * 3 for _ in range(3)]
jadval[0][0] = 1
print(jadval)                       # [[1,0,0], [0,0,0], [0,0,0]]  ✅

To'plamlar — maxsus operatorlar:

python

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

print(a | b)                # {1,2,3,4,5}  — birlashma
print(a & b)                # {3}          — kesishma
print(a - b)                # {1, 2}       — ayirma
print(a ^ b)                # {1,2,4,5}    — simmetrik ayirma
# print(a + b)              # ❌ TypeError

Lug'atlar (Python 3.9+):

python

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}

print(a | b)                # {'x': 1, 'y': 20, 'z': 3}  — o'ng ustun

6-qismda batafsil.

2.6. Ichki funksiyalar

python

print(abs(-5))              # 5
print(abs(-5.5))            # 5.5
print(abs(3 + 4j))          # 5.0   — kompleks modul

print(round(3.7))           # 4
print(round(3.14159, 2))    # 3.14
print(round(1234, -2))      # 1200

print(divmod(17, 5))        # (3, 2)  — (butun, qoldiq)
print(divmod(-17, 5))       # (-4, 3)

print(min(3, 7, 2))         # 2
print(max([3, 7, 2]))       # 7
print(sum([1, 2, 3]))       # 6
print(sum([1, 2, 3], 100))  # 106  — boshlang'ich qiymat

print(pow(2, 10))           # 1024
print(pow(2, 10, 1000))     # 24

divmod — bir amalda ikki natija:

python

soniyalar = 3725

soat, qoldiq = divmod(soniyalar, 3600)
daqiqa, soniya = divmod(qoldiq, 60)
print(f"{soat}:{daqiqa:02d}:{soniya:02d}")      # 1:02:05

Bu — vaqtni formatlashning eng toza usuli.

min/max key bilan:

python

sozlar = ["olma", "anor", "uzum", "shaftoli"]

print(max(sozlar))                  # 'uzum'      — alifbo bo'yicha
print(max(sozlar, key=len))         # 'shaftoli'  — uzunlik bo'yicha
print(min(sozlar, key=len))         # 'olma'

2.7. `math` moduli

python

import math

# Yaxlitlash
print(math.floor(3.7))          # 3
print(math.ceil(3.2))           # 4
print(math.trunc(-3.7))         # -3

# Ildiz va daraja
print(math.sqrt(16))            # 4.0
print(math.isqrt(17))           # 4      — butun (3.3-dars)
print(math.pow(2, 10))          # 1024.0 — DOIM float
print(math.exp(1))              # 2.718...
print(math.log(100, 10))        # 2.0
print(math.log10(1000))         # 3.0    — aniqroq
print(math.log2(1024))          # 10.0

# Butun sonlar
print(math.gcd(12, 18))         # 6
print(math.lcm(4, 6))           # 12
print(math.factorial(5))        # 120
print(math.comb(5, 2))          # 10
print(math.perm(5, 2))          # 20

# Aniqlik
print(math.fsum([0.1] * 10))    # 1.0   — aniq yig'indi (3.4-dars)
print(math.isclose(0.1+0.2, 0.3))  # True

# Doimiylar
print(math.pi)                  # 3.14159...
print(math.e)                   # 2.71828...
print(math.tau)                 # 6.28318... (2π)
print(math.inf, math.nan)

# Trigonometriya (RADIANDA)
print(math.sin(math.pi / 2))    # 1.0
print(math.degrees(math.pi))    # 180.0
print(math.radians(90))         # 1.5707963267948966
print(math.hypot(3, 4))         # 5.0   — gipotenuza

math.pow va ** farqi:

python

print(2 ** 10)                  # 1024    int
print(math.pow(2, 10))          # 1024.0  float
print(2 ** 1000)                # 302 raqamli son
# print(math.pow(2, 1000))      # ❌ OverflowError

math.pow float bilan ishlaydi va to'lib ketishi mumkin. ** esa cheksiz int bilan ishlaydi (3.3-dars).

Qoida: butun sonlar uchun **, kasr uchun math.pow yoki baribir **.

2.8. Operatorlar — obyektlar uchun

Pythonda operator — bu metod chaqiruvining qisqartmasi:

python

print(3 + 4)                    # 7
print((3).__add__(4))           # 7 — bir xil

print("a" + "b")                # 'ab'
print("a".__add__("b"))         # 'ab'

Har bir operator o'z metodiga mos keladi:

Operator	Metod
`+`	`__add__`
`-`	`__sub__`
`*`	`__mul__`
`/`	`__truediv__`
`//`	`__floordiv__`
`%`	`__mod__`
`**`	`__pow__`
`+=`	`__iadd__`
`-x`	`__neg__`
`abs(x)`	`__abs__`

O'z sinfingiz uchun:

python

class Pul:
    def __init__(self, summa: int):
        self.summa = summa

    def __add__(self, boshqa):
        return Pul(self.summa + boshqa.summa)

    def __mul__(self, son: int):
        return Pul(self.summa * son)

    def __str__(self):
        return f"{self.summa:,} so'm"


a = Pul(50_000)
b = Pul(30_000)

print(a + b)                # 80,000 so'm
print(a * 3)                # 150,000 so'm

8-qismda to'liq o'rganamiz.

Teskari metodlar (__radd__):

python

print(3 * "ab")             # 'ababab'

Bu qanday ishlaydi? Python avval (3).__mul__("ab") ni sinaydi — NotImplemented qaytadi. Keyin "ab".__rmul__(3) ni chaqiradi — ishlaydi.

2.9. Bo'lish xatolari

python

# print(1 / 0)              # ❌ ZeroDivisionError
# print(1 // 0)             # ❌ ZeroDivisionError
# print(1 % 0)              # ❌ ZeroDivisionError

Lekin float bilan:

python

print(1.0 / 0.0)            # ❌ ZeroDivisionError ham
print(float("inf") / 2)     # inf
print(1 / float("inf"))     # 0.0

Python C dan farqli o'laroq nolga bo'lishda xato ko'taradi, inf qaytarmaydi.

Himoya:

python

def xavfsiz_bolish(a, b, sukut=None):
    try:
        return a / b
    except ZeroDivisionError:
        return sukut


print(xavfsiz_bolish(10, 2))        # 5.0
print(xavfsiz_bolish(10, 0))        # None
print(xavfsiz_bolish(10, 0, 0))     # 0

Yoki qisqa tutashuv bilan (3.5-dars):

python

ortacha = jami / soni if soni else 0

3. Tez ma'lumotnoma

Operatorlar

python

+   -   *           odatiy
/                   DOIM float
//                  butun bo'lish (pastga yaxlitlash)
%                   qoldiq (bo'luvchi ishorasi)
**                  daraja (O'NGDAN chapga!)
-x  +x              unar

Joyida

python

+=  -=  *=  /=  //=  %=  **=

⚠️ O'zgaruvchan obyektlarda:
a += [3]        joyida o'zgartiradi
a = a + [3]     yangi obyekt

Tuzoqlar

python

2 ** 3 ** 2     → 512   (o'ngdan chapga)
-2 ** 2         → -4    (unar minus pastroq)
7.0 // 2        → 3.0   (float qoladi)
[[0]*3]*3       → bitta ro'yxatga 3 yorliq

Ichki funksiyalar

python

abs()  round()  divmod()  min()  max()  sum()  pow(a,b,m)

math

python

floor ceil trunc sqrt isqrt gcd lcm factorial
comb perm fsum isclose log log10 log2
pi e tau inf nan degrees radians hypot

4. Batafsil misollar

Misol 1 — Turlar aralashuvi jadvali

python

juftliklar = [
    (7, 2), (7, 2.0), (7.0, 2), (7.0, 2.0),
    (True, 2), (True, False), (-7, 2), (7, -2),
]

print(f"{'a':>6} {'b':>6} │ {'a+b':>8} {'a/b':>8} {'a//b':>7} {'a%b':>6} {'a**b':>8}")
print("─" * 60)

for a, b in juftliklar:
    try:
        qosh = repr(a + b)
        bol = repr(a / b)
        butun = repr(a // b)
        qoldiq = repr(a % b)
        daraja = repr(a ** b)
    except ZeroDivisionError:
        bol = butun = qoldiq = "ZeroDiv"
        qosh = repr(a + b)
        daraja = repr(a ** b)

    print(f"{a!r:>6} {b!r:>6} │ {qosh:>8} {bol:>8} {butun:>7} {qoldiq:>6} {daraja:>8}")

print("\n=== Natija turlari ===")
amallar = [
    ("7 + 2", 7 + 2),
    ("7 + 2.0", 7 + 2.0),
    ("7 / 2", 7 / 2),
    ("6 / 2", 6 / 2),
    ("7 // 2", 7 // 2),
    ("7.0 // 2", 7.0 // 2),
    ("2 ** 3", 2 ** 3),
    ("2 ** -1", 2 ** -1),
    ("True + True", True + True),
]

for ifoda, natija in amallar:
    print(f"  {ifoda:<14} = {natija!r:<10} {type(natija).__name__}")

text

     a      b │      a+b      a/b    a//b    a%b     a**b
────────────────────────────────────────────────────────────
     7      2 │        9      3.5       3      1       49
     7    2.0 │      9.0      3.5     3.0    1.0     49.0
   7.0      2 │      9.0      3.5     3.0    1.0     49.0
   7.0    2.0 │      9.0      3.5     3.0    1.0     49.0
  True      2 │        3      0.5       0      1        1
  True  False │        1  ZeroDiv ZeroDiv ZeroDiv        1
    -7      2 │       -5     -3.5      -4      1       49
     7     -2 │        5     -3.5      -4     -1     0.02

=== Natija turlari ===
  7 + 2          = 9          int
  7 + 2.0        = 9.0        float
  7 / 2          = 3.5        float
  6 / 2          = 3.0        float
  7 // 2         = 3          int
  7.0 // 2       = 3.0        float
  2 ** 3         = 8          int
  2 ** -1        = 0.5        float
  True + True    = 2          int

Eng muhim qatorlar:

6 / 2 → 3.0 (float), 3 emas
7.0 // 2 → 3.0 (float) — // turni saqlaydi
-7 // 2 → -4 va -7 % 2 → 1 (3.3-dars)
2 ** -1 → 0.5 (float)

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

Misol 2 — `+=` tuzog'i

python

"""O'zgaruvchan obyektlarda += joyida o'zgartiradi."""

print("=== 1. Ro'yxat: += va + farqi ===")
a = [1, 2]
b = a
print(f"  Boshlanish:  a={a}, b={b}, a is b: {a is b}")

a += [3]
print(f"  a += [3]:    a={a}, b={b}  ← b ham o'zgardi!")

a = [1, 2]
b = a
a = a + [3]
print(f"  a = a + [3]: a={a}, b={b}  ← b o'zgarmadi")

print("\n=== 2. Satr: farq yo'q (o'zgarmas) ===")
s = "ab"
t = s
s += "c"
print(f"  s += 'c': s={s!r}, t={t!r}")

print("\n=== 3. Funksiyaga uzatish ===")


def qoshish_iadd(royxat):
    royxat += [99]              # joyida — TASHQARIGA TA'SIR QILADI


def qoshish_add(royxat):
    royxat = royxat + [99]      # yangi — tashqariga ta'sir qilmaydi


asl = [1, 2]
qoshish_iadd(asl)
print(f"  += bilan:  {asl}   ← o'zgardi")

asl = [1, 2]
qoshish_add(asl)
print(f"  +  bilan:  {asl}   ← o'zgarmadi")

print("\n=== 4. Juftlik ichidagi ro'yxat ===")
t = ([1, 2], 3)
print(f"  Boshlanish: {t}")
try:
    t[0] += [4]
except TypeError as xato:
    print(f"  t[0] += [4] → TypeError: {xato}")
print(f"  Lekin natija: {t}  ← ro'yxat baribir o'zgardi!")

print("\n=== 5. Metodlar bilan solishtirish ===")
r = [1, 2]
r.extend([3])               # += bilan bir xil
print(f"  extend:  {r}")

r = [1, 2]
r.append([3])               # BOSHQA narsa!
print(f"  append:  {r}")

text

=== 1. Ro'yxat: += va + farqi ===
  Boshlanish:  a=[1, 2], b=[1, 2], a is b: True
  a += [3]:    a=[1, 2, 3], b=[1, 2, 3]  ← b ham o'zgardi!
  a = a + [3]: a=[1, 2, 3], b=[1, 2]  ← b o'zgarmadi

=== 2. Satr: farq yo'q (o'zgarmas) ===
  s += 'c': s='abc', t='ab'

=== 3. Funksiyaga uzatish ===
  += bilan:  [1, 2, 99]   ← o'zgardi
  +  bilan:  [1, 2]   ← o'zgarmadi

=== 4. Juftlik ichidagi ro'yxat ===
  Boshlanish: ([1, 2], 3)
  t[0] += [4] → TypeError: 'tuple' object does not support item assignment
  Lekin natija: ([1, 2, 4], 3)  ← ro'yxat baribir o'zgardi!

=== 5. Metodlar bilan solishtirish ===
  extend:  [1, 2, 3]
  append:  [1, 2, [3]]

Nima ko'rsatdi: 2.4-bo'lim va 3.1-darsdagi yorliq modeli. 3-bo'lim eng amaliy: funksiyaga ro'yxat berganingizda += uni tashqarida ham o'zgartiradi.

Misol 3 — Prioritet tuzoqlari

python

"""Kutilmagan natijalar va ularning sabablari."""

sinovlar = [
    ("2 ** 3 ** 2", 2 ** 3 ** 2, "(2 ** (3 ** 2)) — o'ngdan chapga"),
    ("(2 ** 3) ** 2", (2 ** 3) ** 2, "aniq qavs bilan"),
    ("-2 ** 2", -2 ** 2, "-(2 ** 2) — unar minus pastroq"),
    ("(-2) ** 2", (-2) ** 2, "aniq qavs bilan"),
    ("2 + 3 * 4", 2 + 3 * 4, "* oldin"),
    ("(2 + 3) * 4", (2 + 3) * 4, "qavs bilan"),
    ("10 - 3 - 2", 10 - 3 - 2, "chapdan o'ngga"),
    ("10 - (3 - 2)", 10 - (3 - 2), "qavs bilan"),
    ("2 * 3 ** 2", 2 * 3 ** 2, "** oldin"),
    ("100 / 10 / 2", 100 / 10 / 2, "chapdan o'ngga"),
    ("7 // 2 * 2", 7 // 2 * 2, "chapdan o'ngga"),
    ("7 * 2 // 2", 7 * 2 // 2, "chapdan o'ngga"),
]

print(f"{'Ifoda':<18} {'Natija':>10}   Sabab")
print("─" * 62)
for ifoda, natija, sabab in sinovlar:
    print(f"{ifoda:<18} {natija!r:>10}   {sabab}")

print("\n=== Assotsiativlik ===")
print(f"  ** o'ngdan chapga:  2**3**2 = 2**(3**2) = 2**9 = {2**3**2}")
print(f"  - chapdan o'ngga:   10-3-2 = (10-3)-2 = {10-3-2}")
print(f"  / chapdan o'ngga:   100/10/2 = (100/10)/2 = {100/10/2}")

print("\n=== Aniq qavs har doim yaxshiroq ===")
a, b, c = 10, 3, 2
print(f"  a - b - c        = {a - b - c}")
print(f"  (a - b) - c      = {(a - b) - c}")
print(f"  a - (b - c)      = {a - (b - c)}")

text

Ifoda                  Natija   Sabab
──────────────────────────────────────────────────────────────
2 ** 3 ** 2                512   (2 ** (3 ** 2)) — o'ngdan chapga
(2 ** 3) ** 2               64   aniq qavs bilan
-2 ** 2                     -4   -(2 ** 2) — unar minus pastroq
(-2) ** 2                    4   aniq qavs bilan
2 + 3 * 4                   14   * oldin
(2 + 3) * 4                 20   qavs bilan
10 - 3 - 2                   5   chapdan o'ngga
10 - (3 - 2)                 9   qavs bilan
2 * 3 ** 2                  18   ** oldin
100 / 10 / 2               5.0   chapdan o'ngga
7 // 2 * 2                   6   chapdan o'ngga
7 * 2 // 2                   7   chapdan o'ngga

Diqqat: 7 // 2 * 2 = 6, lekin 7 * 2 // 2 = 7. Tartib muhim!

Nima ko'rsatdi: 2.3-bo'lim. 3.12-darsda prioritet mavzusini to'liq ko'ramiz.

Misol 4 — Amaliy dastur: kredit kalkulyatori

python

"""Annuitet to'lov bo'yicha kredit kalkulyatori."""

import math


def annuitet_tolov(summa: float, yillik_foiz: float, oylar: int) -> float:
    """Oylik annuitet to'lovni hisoblaydi.

    Formula:  T = S × (i × (1+i)^n) / ((1+i)^n − 1)
    Bu yerda: i — oylik foiz stavkasi, n — oylar soni
    """
    if yillik_foiz == 0:
        return summa / oylar

    i = yillik_foiz / 100 / 12
    koeffitsiyent = (1 + i) ** oylar
    return summa * (i * koeffitsiyent) / (koeffitsiyent - 1)


def jadval(summa: float, yillik_foiz: float, oylar: int) -> None:
    tolov = annuitet_tolov(summa, yillik_foiz, oylar)
    i = yillik_foiz / 100 / 12
    qoldiq = summa
    jami_foiz = 0.0

    print(f"┌─ KREDIT: {summa:,.0f} so'm, {yillik_foiz}% yillik, {oylar} oy")
    print(f"│  Oylik to'lov: {tolov:,.2f} so'm")
    print("│")
    print(f"│  {'Oy':>3} {'Toʻlov':>12} {'Foiz':>12} {'Asosiy':>12} {'Qoldiq':>14}")
    print(f"│  {'─' * 57}")

    for oy in range(1, oylar + 1):
        foiz = qoldiq * i
        asosiy = tolov - foiz
        qoldiq -= asosiy
        jami_foiz += foiz

        # Faqat birinchi 3, oxirgi 2 va har 12-oyni ko'rsatamiz
        if oy <= 3 or oy > oylar - 2 or oy % 12 == 0:
            print(f"│  {oy:>3} {tolov:>12,.2f} {foiz:>12,.2f} "
                  f"{asosiy:>12,.2f} {max(qoldiq, 0):>14,.2f}")
        elif oy == 4:
            print(f"│  {'...':>3}")

    print(f"│  {'─' * 57}")
    print(f"│  Jami to'lov:   {tolov * oylar:>14,.2f} so'm")
    print(f"│  Jami foiz:     {jami_foiz:>14,.2f} so'm")
    print(f"│  Ortiqcha to'lov: {jami_foiz / summa:>12.1%}")
    print("└─")


jadval(summa=50_000_000, yillik_foiz=24, oylar=24)

print("\n=== Turli muddat solishtiruvi ===")
SUMMA = 50_000_000
FOIZ = 24

print(f"{'Muddat':>8} {'Oylik':>16} {'Jami':>18} {'Ortiqcha':>12}")
print("─" * 58)
for oylar in [6, 12, 24, 36, 48, 60]:
    t = annuitet_tolov(SUMMA, FOIZ, oylar)
    jami = t * oylar
    print(f"{oylar:>6} oy {t:>16,.0f} {jami:>18,.0f} {(jami - SUMMA) / SUMMA:>11.1%}")

text

┌─ KREDIT: 50,000,000 so'm, 24% yillik, 24 oy
│  Oylik to'lov: 2,645,000.31 so'm
│
│   Oy       To'lov         Foiz       Asosiy         Qoldiq
│  ─────────────────────────────────────────────────────────
│    1  2,645,000.31 1,000,000.00 1,645,000.31  48,354,999.69
│    2  2,645,000.31   967,099.99 1,677,900.32  46,677,099.37
│    3  2,645,000.31   933,541.99 1,711,458.32  44,965,641.05
│  ...
│   12  2,645,000.31   601,441.09 2,043,559.22  28,028,495.28
│   23  2,645,000.31   103,588.24 2,541,412.07   2,638,000.31
│   24  2,645,000.31    52,760.01 2,592,240.30           0.00
│  ─────────────────────────────────────────────────────────
│  Jami to'lov:    63,480,007.44 so'm
│  Jami foiz:      13,480,007.44 so'm
│  Ortiqcha to'lov:        27.0%
└─

=== Turli muddat solishtiruvi ===
  Muddat            Oylik               Jami     Ortiqcha
──────────────────────────────────────────────────────────
     6 oy        8,911,398         53,468,388         6.9%
    12 oy        4,724,437         56,693,244        13.4%
    24 oy        2,645,000         63,480,007        27.0%
    36 oy        1,961,377         70,609,572        41.2%
    48 oy        1,629,536         78,217,728        56.4%
    60 oy        1,437,290         86,237,400        72.5%

Kodda ko'rish kerak:

(1 + i) ** oylar — daraja operatori
yillik_foiz / 100 / 12 — chapdan o'ngga hisoblanadi
max(qoldiq, 0) — yaxlitlash xatosidan himoya
{tolov:>12,.2f} — formatlash (3.13-dars)
{foiz:.1%} — foiz formati

Diqqat: haqiqiy moliyaviy dasturda bu hisob Decimal bilan qilinishi kerak (3.4-dars). Bu yerda float faqat namoyish uchun.

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

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

Noto'g'ri fikr	To'g'risi
"`2 3 2` = `64`"	`512`. `**` o'ngdan chapga
"`-2 ** 2` = `4`"	`-4`. Unar minus `**` dan past
"`7.0 // 2` = `3`"	`3.0` — `float` qoladi
"`a += [1]` va `a = a + [1]` bir xil"	O'zgaruvchan obyektlarda farqli
"`6 / 2` = `3`"	`3.0` — `/` doim `float`
"`math.pow` `**` bilan bir xil"	`math.pow` doim `float` va to'lib ketadi
"`[[0]3]3` mustaqil qatorlar yaratadi"	Yo'q — bitta ro'yxatga uchta yorliq
"Operatorlar faqat sonlar uchun"	Har qanday obyekt uchun — `__add__` va h.k.
"`1/0` `inf` qaytaradi"	`ZeroDivisionError`. Bu — C emas

6. Keng tarqalgan xatolar va yechimlari

1. ZeroDivisionError

python

ortacha = jami / soni                       # ❌ soni 0 bo'lishi mumkin
ortacha = jami / soni if soni else 0        # ✅

2. TypeError: unsupported operand type(s)

python

"5" + 5                                     # ❌
int("5") + 5                                # ✅

3. Prioritet xatosi

python

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

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

4. += bilan kutilmagan o'zgarish

python

def qoshish(royxat):
    royxat += [1]                           # ❌ tashqaridagi ro'yxat o'zgaradi

def qoshish(royxat):
    return royxat + [1]                     # ✅

5. Ichma-ich ro'yxat ko'paytirish

python

jadval = [[0] * 3] * 3                      # ❌
jadval = [[0] * 3 for _ in range(3)]        # ✅

6. // natijasini int deb o'ylash

python

indeks = uzunlik / 2                        # ❌ float — indeks bo'la olmaydi
indeks = uzunlik // 2                       # ✅ int

7. math.sqrt manfiy son bilan

python

math.sqrt(-4)                               # ❌ ValueError
(-4) ** 0.5                                 # kompleks son
cmath.sqrt(-4)                              # ✅ 2j — kompleks kerak bo'lsa
abs(-4) ** 0.5                              # ✅ agar modul kerak bo'lsa

8. Kasr sonlarni solishtirish

python

if 0.1 + 0.2 == 0.3:                        # ❌ False (3.4-dars)
if math.isclose(0.1 + 0.2, 0.3):            # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

3.11-dars: taqqoslash operatorlari
3.12-dars: prioritet to'liq jadvali
5-qism: sikllarda hisoblagichlar, range qadamlari
6-qism: ro'yxat va lug'at operatorlari, kesim qadamlari
8-qism: operatorlarni qayta yuklash — __add__, __mul__ va boshqalar
31-qism: algoritmlar — //, %, ** juda ko'p ishlatiladi
24-qism: NumPy — massivlar bilan arifmetika
Har qanday hisob-kitobda: bu — poydevor

8. Eng yaxshi amaliyotlar

Qavs qo'yishdan qo'rqmang. (a + b) / 2 — a + b / 2 dan aniqroq. Qavs bepul.
Butun natija kerak bo'lsa // ishlating. int(a / b) — ikki amal va kasr aniqligi muammosi.
+= ni o'zgaruvchan obyektlarda ehtiyot bilan ishlating. Funksiya ichida return royxat + [x] xavfsizroq.
divmod ni ishlating. a // b va a % b ni alohida hisoblashdan tez va toza.
Ichma-ich ro'yxatlarni generatorlar bilan yarating. [[0]*n for _ in range(m)].
Nolga bo'lishdan himoyalang. if soni else 0 yoki try/except.
Moliyaviy hisobda Decimal ishlating. float — ilmiy hisob uchun (3.4-dars).
** prioritetini eslang. 2 ** 3 ** 2 = 512, -2 ** 2 = -4.

9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python

1.  7 / 2
2.  7 // 2
3.  7.0 // 2
4.  -7 // 2
5.  -7 % 3
6.  2 ** 3 ** 2
7.  -2 ** 2
8.  2 + 3 * 4 ** 2
9.  True + True + True
10. 10 - 3 - 2
11. 7 // 2 * 2
12. divmod(-17, 5)

Javoblar

3.5
3
3.0 — float!
-4 — pastga yaxlitlash
2 — bo'luvchi musbat
512 — o'ngdan chapga
-4 — -(2**2)
50 — 2 + (3 * 16)
3
5 — chapdan o'ngga
6 — (7//2) * 2
(-4, 3)

Vazifa 2: Vaqtni formatlash

Soniyalar berilgan. divmod bilan "1 kun 2 soat 3 daqiqa 4 soniya" formatiga aylantiring.

python

soniyalar = 93784

Yechim

python

def vaqt_formati(soniyalar: int) -> str:
    kun, qoldiq = divmod(soniyalar, 86400)
    soat, qoldiq = divmod(qoldiq, 3600)
    daqiqa, soniya = divmod(qoldiq, 60)

    qismlar = []
    if kun:
        qismlar.append(f"{kun} kun")
    if soat:
        qismlar.append(f"{soat} soat")
    if daqiqa:
        qismlar.append(f"{daqiqa} daqiqa")
    if soniya or not qismlar:
        qismlar.append(f"{soniya} soniya")

    return " ".join(qismlar)


for s in [0, 45, 90, 3600, 3725, 93784]:
    print(f"{s:>7} → {vaqt_formati(s)}")

Vazifa 3: += tajribasi

python

def sinov1(royxat):
    royxat += [99]

def sinov2(royxat):
    royxat = royxat + [99]

def sinov3(royxat):
    royxat.append(99)

for funksiya in [sinov1, sinov2, sinov3]:
    asl = [1, 2]
    funksiya(asl)
    print(f"{funksiya.__name__}: {asl}")

Natijani bashorat qiling. Nega uchtasi turlicha?

Javob

text

sinov1: [1, 2, 99]      ← += joyida o'zgartiradi
sinov2: [1, 2]          ← yangi obyekt yaratildi, mahalliy
sinov3: [1, 2, 99]      ← append joyida o'zgartiradi

sinov1 va sinov3 bir xil — += aslida extend() ni chaqiradi (2.4-bo'lim).

Vazifa 4: Kvadrat tenglama

ax² + bx + c = 0 ni yechadigan funksiya yozing:

Diskriminant > 0 → ikki ildiz
= 0 → bitta ildiz
< 0 → "haqiqiy ildiz yo'q"
a = 0 → chiziqli tenglama

Sinang: (1, -5, 6), (1, 2, 1), (1, 0, 1), (0, 2, -4).

Yechim

python

import math


def kvadrat_tenglama(a: float, b: float, c: float):
    if a == 0:
        if b == 0:
            return "Tenglama emas" if c else "Cheksiz ildiz"
        return (-c / b,)

    d = b**2 - 4*a*c

    if d > 0:
        ildiz = math.sqrt(d)
        return ((-b + ildiz) / (2*a), (-b - ildiz) / (2*a))
    if d == 0:
        return (-b / (2*a),)
    return ()


for koef in [(1, -5, 6), (1, 2, 1), (1, 0, 1), (0, 2, -4), (0, 0, 5)]:
    natija = kvadrat_tenglama(*koef)
    print(f"{koef} → {natija if natija else 'haqiqiy ildiz yo\\'q'}")

Vazifa 5: Kredit kalkulyatorini kengaytirish

4-misoldagi dasturga qo'shing:

Differensial to'lov varianti (har oy asosiy qarz teng bo'linadi)
Ikki usulni solishtirish jadvali
Muddatidan oldin to'lash imkoniyati

Vazifa 6: Prioritet mashqi

Qavslarni qo'ying, natija ko'rsatilgandek bo'lsin:

python

1.  2 + 3 * 4        = 20
2.  2 ** 3 ** 2      = 64
3.  10 - 3 - 2       = 9
4.  -2 ** 2          = 4
5.  100 / 10 / 2     = 20.0

Javoblar

python

1.  (2 + 3) * 4      = 20
2.  (2 ** 3) ** 2    = 64
3.  10 - (3 - 2)     = 9
4.  (-2) ** 2        = 4
5.  100 / (10 / 2)   = 20.0

Vazifa 7: O'z sinfingiz uchun operatorlar

Vaqt sinfini yarating (soat, daqiqa). + va - operatorlarini qo'llab-quvvatlasin:

python

a = Vaqt(2, 45)
b = Vaqt(1, 30)
print(a + b)        # 4:15
print(a - b)        # 1:15

Yechim

python

class Vaqt:
    def __init__(self, soat: int = 0, daqiqa: int = 0):
        jami = soat * 60 + daqiqa
        self.soat, self.daqiqa = divmod(jami, 60)

    def __add__(self, boshqa):
        return Vaqt(self.soat + boshqa.soat, self.daqiqa + boshqa.daqiqa)

    def __sub__(self, boshqa):
        jami = (self.soat * 60 + self.daqiqa) - (boshqa.soat * 60 + boshqa.daqiqa)
        return Vaqt(0, jami)

    def __str__(self):
        return f"{self.soat}:{self.daqiqa:02d}"


a, b = Vaqt(2, 45), Vaqt(1, 30)
print(a + b)        # 4:15
print(a - b)        # 1:15
print(Vaqt(0, 150)) # 2:30 — divmod avtomatik to'g'rilaydi

divmod konstruktorda daqiqalarni soatga aylantiradi (2.6, 2.8-bo'limlar).

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

Xulosa

Bu darsda arifmetik operatorlarni to'liq o'rgandik.

Eng muhim uch fikr:

Turlar aralashganda Python kengroq turga o'tadi, lekin / doim float beradi va // turni saqlaydi. 7.0 // 2 → 3.0, 3 emas.
** o'ngdan chapga hisoblanadi va unar minusdan yuqori prioritetli. 2 ** 3 ** 2 = 512, -2 ** 2 = -4. Bu ikki tuzoq eng ko'p uchraydi.
+= o'zgaruvchan obyektlarda joyida o'zgartiradi. a += [3] a ga ishora qiluvchi barcha yorliqni o'zgartiradi, a = a + [3] esa yo'q. Funksiyaga ro'yxat berganingizda bu farq muhim.

Keyingi darsda taqqoslash va mantiqiy operatorlarni o'rganamiz: ==, !=, <, >, in, is — va turli turlarni solishtirganda nima bo'lishi.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!

3.10-dars: Arifmetik operatorlar

1. Kirish va motivatsiya

2. Nazariya — chuqur tushuntirish

2.1. Asosiy operatorlar

2.2. Turlar aralashganda

2.3. ** — daraja va uning nozikliklari

2.4. Joyida o'zgartiruvchi operatorlar

2.5. Satr va to'plamlar bilan arifmetika

2.6. Ichki funksiyalar

2.7. math moduli

2.8. Operatorlar — obyektlar uchun

2.9. Bo'lish xatolari

3. Tez ma'lumotnoma

4. Batafsil misollar

Misol 1 — Turlar aralashuvi jadvali

Misol 2 — += tuzog'i

Misol 3 — Prioritet tuzoqlari

Misol 4 — Amaliy dastur: kredit kalkulyatori

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.3. `**` — daraja va uning nozikliklari

2.7. `math` moduli

Misol 2 — `+=` tuzog'i