Python kursi4.7-dars: f-satr chuqur va format
Python kursi · Satrlar chuqur

4.7-dars: f-satr chuqur va __format__

22 daqiqa7/12-dars

4-QISM — SATRLAR CHUQUR · 7-dars


1. Kirish va motivatsiya

3.13-darsda f-satrlarning asosini o'rgandik. Bu darsda ichkariga kiramiz.

Nega? Chunki f-satr — shunchaki qulay sintaksis emas. U:

  • Kompilyatsiya paytida bytecode ga aylanadi (shuning uchun tez)
  • Har qanday ifodani o'z ichiga oladi
  • Obyektning __format__ metodini chaqiradi
  • Python 3.12 da jiddiy kengaytirildi

Va u bilan bog'liq nozik jihatlar bor:

python
print(f"{2+3=}")                # '2+3=5' — bo'shliqlar saqlanadi
print(f"{ 2 + 3 = }")           # ' 2 + 3 = 5'
python
lugat = {"ism": "Ali"}
print(f"{lugat['ism']}")        # ✅ tirnoq kerak
print("{0[ism]}".format(lugat)) # ✅ tirnoqsiz — teskari!
python
# Python 3.12 dan oldin ishlamasdi:
print(f"{lugat["ism"]}")        # 3.12+ da ✅
print(f"{"salom"}")             # 3.12+ da ✅

Bu darsda hammasini ko'ramiz — jumladan __format__ bilan o'z sinflaringizni f-satrga moslashtirish.


2. Nazariya — chuqur tushuntirish

2.1. f-satr qanday ishlaydi

f-satr — sintaksis shakli, funksiya chaqiruvi emas. Python uni kompilyatsiya paytida ochadi.

python
import dis

ism = "Ali"
dis.dis('f"Salom, {ism}!"')
text
  0           RESUME                   0
  1           LOAD_CONST               0 ('Salom, ')
              LOAD_NAME                0 (ism)
              FORMAT_VALUE             0
              LOAD_CONST               1 ('!')
              BUILD_STRING             3
              RETURN_VALUE

Nima bo'ldi:

  1. Doimiy qismlar ('Salom, ', '!') — kompilyatsiya paytida tayyor
  2. LOAD_NAME ism — o'zgaruvchi yuklanadi
  3. FORMAT_VALUE — formatlanadi
  4. BUILD_STRING 3 — uch qism birlashtiriladi

Solishtiring .format() bilan:

python
dis.dis('"Salom, {}!".format(ism)')
text
              LOAD_CONST     ('Salom, {}!')
              LOAD_METHOD    (format)        ← metod qidiruvi
              LOAD_NAME      (ism)
              CALL_METHOD                    ← funksiya chaqiruvi

.format() da:

  • Shablon ishlash paytida tahlil qilinadi
  • Metod qidiriladi
  • Funksiya chaqiriladi

f-satrda bularning hech biri yo'q — shuning uchun 2-3 barobar tez.

Muhim natija: f-satr kechiktirilishi mumkin emas.

python
SHABLON = f"Salom, {ism}!"      # DARHOL hisoblanadi
ism = "Vali"
print(SHABLON)                  # 'Salom, Ali!' — eski qiymat

Kechiktirilgan shablon kerak bo'lsa — .format() yoki Template (4.6-dars).

2.2. Ichidagi ifodalar

f-satr ichida deyarli har qanday ifoda bo'lishi mumkin:

python
a, b = 5, 10
ism = "ali"
sonlar = [3, 1, 2]
malumot = {"ism": "Ali", "yosh": 25}

print(f"{a + b}")                       # 15
print(f"{a * b - 3}")                   # 47
print(f"{ism.upper()}")                 # ALI
print(f"{len(ism)}")                    # 3
print(f"{sorted(sonlar)}")              # [1, 2, 3]
print(f"{sonlar[0]}")                   # 3
print(f"{malumot['ism']}")              # Ali
print(f"{'katta' if a > 3 else 'kichik'}")   # katta
print(f"{[x * 2 for x in sonlar]}")     # [6, 2, 4]
print(f"{sum(x for x in sonlar)}")      # 6

Nima MUMKIN EMAS:

python
# print(f"{x = 5}")             # ❌ o'zlashtirish
# print(f"{import os}")         # ❌ buyruq
# print(f"{return x}")          # ❌ buyruq

f-satr ichida faqat ifoda bo'ladi, buyruq emas (3.5-dars).

Morj operatori — istisno:

python
sonlar = [1, 2, 3, 4, 5]
print(f"{(n := len(sonlar))} ta element")   # '5 ta element'
print(n)                                    # 5 — o'zgaruvchi yaratildi

:= — ifoda, shuning uchun ishlaydi (3.12-dars).

Ko'p qatorli ifodalar:

python
natija = f"""
Ism:   {malumot['ism']}
Yosh:  {malumot['yosh']}
Katta: {'ha' if malumot['yosh'] > 18 else "yo'q"}
"""
print(natija)

2.3. Tirnoq muammosi va Python 3.12

Python 3.12 dan oldin:

python
lugat = {"ism": "Ali"}

print(f"{lugat['ism']}")        # ✅ ichkarida boshqa tirnoq
print(f'{lugat["ism"]}')        # ✅
# print(f"{lugat["ism"]}")      # ❌ SyntaxError — bir xil tirnoq

Sabab: f-satr oddiy satr sifatida tahlil qilinardi, shuning uchun ichkaridagi bir xil tirnoq uni tugatardi.

Python 3.12+ (PEP 701):

python
print(f"{lugat["ism"]}")        # ✅ endi ishlaydi
print(f"{"salom"}")             # ✅
print(f"{f"{f"ichma-ich"}"}")   # ✅ cheksiz ichma-ich

3.12 da f-satr alohida grammatika bilan tahlil qilinadi.

Boshqa 3.12 yangiliklari:

python
# 1. Teskari chiziq (3.12+)
print(f"{'\n'.join(['a', 'b'])}")       # 3.12 gacha ❌

# 2. Ko'p qatorli ifoda (3.12+)
print(f"{
    sum([1, 2, 3])
}")

# 3. Izohlar (3.12+)
print(f"{sum([1, 2])  # izoh
}")

3.12 gacha bo'lgan yechimlar:

python
# Teskari chiziq uchun
YANGI_QATOR = "\n"
print(f"{YANGI_QATOR.join(['a', 'b'])}")

# yoki
qismlar = "\n".join(["a", "b"])
print(f"{qismlar}")

Amaliy maslahat: kodingiz eski Pythonda ham ishlashi kerak bo'lsa, 3.12 yangiliklariga tayanmang. pyproject.toml da target-version ni to'g'ri sozlang (2.7-dars).

2.4. = — nosozlik izlash

Python 3.8+ da qo'shilgan va juda foydali.

python
a, b = 5, 10
ism = "Ali"

print(f"{a=}")                  # a=5
print(f"{b=}")                  # b=10
print(f"{a + b=}")              # a + b=15
print(f"{ism=}")                # ism='Ali'   ← repr!
print(f"{ism.upper()=}")        # ism.upper()='ALI'
print(f"{len(ism)=}")           # len(ism)=3

Muhim: = sukut bo'yicha repr() ishlatadi — shuning uchun satr tirnoqlar bilan chiqadi. Bu — nosozlik izlash uchun aynan kerak.

Bo'shliqlar saqlanadi:

python
print(f"{a=}")                  # 'a=5'
print(f"{a = }")                # 'a = 5'
print(f"{ a = }")               # ' a = 5'
print(f"{a+b=}")                # 'a+b=15'
print(f"{a + b = }")            # 'a + b = 15'

Bu — ataylab: ifodaning matni so'zma-so'z ko'chiriladi.

Format bilan birga:

python
narx = 1234.5678
print(f"{narx=}")               # narx=1234.5678
print(f"{narx=:.2f}")           # narx=1234.57   ← str() ga o'tadi
print(f"{narx=!r}")             # narx=1234.5678 ← aniq repr
print(f"{narx=!s}")             # narx=1234.5678 ← str

Diqqat: format spetsifikatori berilsa, = repr() dan str() ga o'tadi.

Amaliy foydalanish:

python
def hisobla(narx, soni, chegirma):
    summa = narx * soni
    print(f"DEBUG: {narx=}, {soni=}, {summa=}")

    chegirma_summasi = summa * chegirma
    print(f"DEBUG: {chegirma=}, {chegirma_summasi=:.2f}")

    return summa - chegirma_summasi

Nega bu print("narx =", narx) dan yaxshi?

O'zgaruvchi nomini o'zgartirganingizda {narx=} avtomatik yangilanadi. Qo'lda yozilgan matn esa eskirib qoladi.

2.5. Format spetsifikatorlari — takrorlash

Bular .format() bilan umumiy (4.6-dars):

python
son = 1234567.891

print(f"{son:.2f}")             # 1234567.89
print(f"{son:,.2f}")            # 1,234,567.89
print(f"{son:>20,.2f}")         # '        1,234,567.89'
print(f"{son:e}")               # 1.234568e+06
print(f"{0.156:.1%}")           # 15.6%
print(f"{42:08b}")              # 00101010
print(f"{255:#x}")              # 0xff
print(f"{-42:+}")               # -42
print(f"{'abc':*^11}")          # ****abc****

Ichma-ich spetsifikatorlar — f-satrda ayniqsa qulay:

python
kenglik = 15
aniqlik = 2

print(f"{son:>{kenglik}.{aniqlik}f}")
print(f"{son:{'>'}{kenglik}.{aniqlik}f}")       # tekislash ham dinamik

Amaliy misol — jadval:

python
malumot = [
    ("Sarvarbek", 88.456, 1_250_000),
    ("Ali", 92.1, 850_000),
    ("Guli", 79.99, 2_100_000),
]

# Ustun kengliklarini avtomatik hisoblash
w_ism = max(len(x[0]) for x in malumot)
w_summa = max(len(f"{x[2]:,}") for x in malumot)

for ism, ball, summa in malumot:
    print(f"  {ism:<{w_ism}}  {ball:>6.1f}  {summa:>{w_summa},}")
text
  Sarvarbek    88.5  1,250,000
  Ali          92.1    850,000
  Guli         80.0  2,100,000

2.6. __format__ — o'z sinflaringiz uchun

f-satr {obyekt:spec} ni ko'rganda type(obyekt).__format__(obyekt, spec) ni chaqiradi.

python
class Harorat:
    def __init__(self, selsiy: float):
        self.selsiy = selsiy

    def __str__(self):
        return f"{self.selsiy:.1f}°C"

    def __repr__(self):
        return f"Harorat({self.selsiy})"

    def __format__(self, spec: str) -> str:
        if not spec:
            return str(self)

        # Birlik qo'shimchasi
        if spec.endswith("F"):
            qiymat = self.selsiy * 9 / 5 + 32
            birlik = "°F"
            spec = spec[:-1]
        elif spec.endswith("K"):
            qiymat = self.selsiy + 273.15
            birlik = "K"
            spec = spec[:-1]
        elif spec.endswith("C"):
            qiymat = self.selsiy
            birlik = "°C"
            spec = spec[:-1]
        else:
            qiymat = self.selsiy
            birlik = "°C"

        sonli = f"{qiymat:{spec or '.1f'}}"
        return f"{sonli}{birlik}"


h = Harorat(25.5)

print(f"{h}")                   # 25.5°C
print(f"{h:C}")                 # 25.5°C
print(f"{h:F}")                 # 77.9°F
print(f"{h:K}")                 # 298.6K
print(f"{h:.0f}")               # 26°C
print(f"{h:.2fF}")              # 77.90°F
print(f"{h!r}")                 # Harorat(25.5)
print("{:F}".format(h))         # 77.9°F — .format da ham ishlaydi

__format__ ning sukut amalga oshiruvi:

python
class Oddiy:
    def __str__(self):
        return "oddiy obyekt"


o = Oddiy()
print(f"{o}")                   # 'oddiy obyekt' — object.__format__ str() ni chaqiradi
# print(f"{o:>20}")             # ❌ TypeError — bo'sh bo'lmagan spec qo'llab-quvvatlanmaydi

object.__format__ faqat bo'sh spetsifikatorni qabul qiladi. Boshqasi kerak bo'lsa — o'zingiz yozing.

Eng oddiy amalga oshiruv — satrga o'tkazish:

python
class Sodda:
    def __init__(self, qiymat):
        self.qiymat = qiymat

    def __str__(self):
        return str(self.qiymat)

    def __format__(self, spec):
        return format(str(self), spec)      # satr formatlashiga topshirish


s = Sodda("abc")
print(f"{s:>10}")               # '       abc'
print(f"{s:*^11}")              # '****abc****'

format() ichki funksiyasi:

python
print(format(3.14159, ".2f"))           # '3.14'
print(format(42, "08b"))                # '00101010'
print(format("abc", ">10"))             # '       abc'
print(format(h, "F"))                   # '77.9°F'

# f-satr bilan bir xil
print(f"{3.14159:.2f}")

format(x, spec) ≡ f"{x:{spec}}" ≡ type(x).__format__(x, spec).

2.7. Standart kutubxonadagi __format__

datetime — strftime ga topshiradi:

python
from datetime import datetime, date, timedelta

hozir = datetime(2026, 9, 8, 14, 30, 45)

print(f"{hozir:%d.%m.%Y}")              # 08.09.2026
print(f"{hozir:%H:%M:%S}")              # 14:30:45
print(f"{hozir:%Y-%m-%dT%H:%M:%S}")     # ISO
print(f"{hozir:%A}")                    # Tuesday
print(f"{hozir}")                       # 2026-09-08 14:30:45

Decimal:

python
from decimal import Decimal

narx = Decimal("1234.5678")
print(f"{narx:,.2f}")                   # 1,234.57
print(f"{narx:e}")                      # 1.2345678E+3

Fraction:

python
from fractions import Fraction

f = Fraction(3, 4)
print(f"{f}")                           # 3/4
print(f"{float(f):.2f}")                # 0.75

Enum (8-qism):

python
from enum import Enum

class Rang(Enum):
    QIZIL = 1
    YASHIL = 2

print(f"{Rang.QIZIL}")                  # Rang.QIZIL
print(f"{Rang.QIZIL.name}")             # QIZIL
print(f"{Rang.QIZIL.value}")            # 1

IntEnum — sonli formatlash ishlaydi:

python
from enum import IntEnum

class Holat(IntEnum):
    FAOL = 1
    NOFAOL = 0

print(f"{Holat.FAOL:d}")                # 1
print(f"{Holat.FAOL:03d}")              # 001

2.8. Tezlik va optimizatsiya

python
import timeit

ism, yosh = "Ali", 25

usullar = {
    "f-satr":       lambda: f"Salom, {ism}! Yosh: {yosh}",
    "f-satr format": lambda: f"Salom, {ism}! Yosh: {yosh:d}",
    ".format()":    lambda: "Salom, {}! Yosh: {}".format(ism, yosh),
    "%":            lambda: "Salom, %s! Yosh: %d" % (ism, yosh),
    "+ bilan":      lambda: "Salom, " + ism + "! Yosh: " + str(yosh),
    "join":         lambda: "".join(["Salom, ", ism, "! Yosh: ", str(yosh)]),
}

for nom, f in sorted(usullar.items(), key=lambda x: timeit.timeit(x[1], number=100_000)):
    vaqt = timeit.timeit(f, number=500_000)
    print(f"  {nom:<16} {vaqt:.3f} s")

Nima uchun f-satr tez:

  1. Shablon kompilyatsiya paytida tahlil qilinadi
  2. Metod qidiruvi yo'q
  3. Funksiya chaqiruvi yo'q
  4. BUILD_STRING — optimallashtirilgan bytecode buyrug'i

Lekin siklda ehtiyot bo'ling:

python
# ❌ Har iteratsiyada yangi satr
natija = ""
for x in katta_royxat:
    natija += f"{x}\n"

# ✅ join bilan (4.5-dars)
natija = "\n".join(f"{x}" for x in katta_royxat)

# ✅ Yoki soddaroq
natija = "\n".join(map(str, katta_royxat))

Formatlash kerak bo'lmasa str() tezroq:

python
f"{x}"          # FORMAT_VALUE chaqiradi
str(x)          # to'g'ridan-to'g'ri

Farq juda kichik, lekin millionlab iteratsiyada seziladi.

2.9. Xavfsizlik

f-satr kod bajaradi — bu kuch, lekin xavf ham.

python
# ✅ Xavfsiz — shablon kodda
ism = foydalanuvchi_kiritmasi
print(f"Salom, {ism}")          # ism faqat qiymat sifatida ishlatiladi
python
# ❌ XAVFLI — shablon foydalanuvchidan
shablon = input("Shablon: ")
print(eval(f'f"{shablon}"'))    # ❌ HECH QACHON

Nega xavfli?

python
shablon = "{__import__('os').system('rm -rf /')}"

Qoida:

f-satr shabloni doim kodda bo'lsin. Foydalanuvchi faqat qiymat bersin. Foydalanuvchi shabloni kerak bo'lsa — string.Template (4.6-dars).

SQL in'yeksiyasi — o'xshash muammo:

python
# ❌ XAVFLI
kursor.execute(f"SELECT * FROM users WHERE id = {user_id}")

# ✅ Parametrlangan so'rov
kursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))

23-qismda batafsil.

Shell buyruqlari:

python
import subprocess

# ❌ XAVFLI
subprocess.run(f"cat {fayl}", shell=True)

# ✅ Ro'yxat bilan
subprocess.run(["cat", fayl])

HTML:

python
import html

# ❌ XSS zaifligi
javob = f"<p>Salom, {ism}</p>"

# ✅ Ekranlash bilan
javob = f"<p>Salom, {html.escape(ism)}</p>"

20-qismda batafsil.


3. Tez ma'lumotnoma

Asosiy

python
f"{ifoda}"                  har qanday IFODA (buyruq emas)
f"{a + b}"  f"{f(x)}"  f"{x[0]}"  f"{d['k']}"
f"{'ha' if x else 'yo'q'}"
f"{(n := len(x))}"          morj ishlaydi

Nosozlik izlash

python
f"{x=}"                     x=qiymat  (repr!)
f"{x = }"                   bo'shliqlar saqlanadi
f"{x=:.2f}"                 format bilan (str ga o'tadi)
f"{x=!r}"                   aniq repr

Format (.format() bilan umumiy)

python
f"{x:<10}"  f"{x:>10}"  f"{x:^10}"  f"{x:*^10}"
f"{x:.2f}"  f"{x:,.2f}"  f"{x:e}"  f"{x:.1%}"
f"{x:b}"  f"{x:x}"  f"{x:#x}"  f"{x:08b}"
f"{x:+}"  f"{x!r}"  f"{x!s}"  f"{x!a}"
f"{x:>{kenglik}.{aniqlik}f}"    ichma-ich

__format__

python
def __format__(self, spec: str) -> str:
    if not spec:
        return str(self)
    return format(qiymat, spec)

format(x, spec) ≡ f"{x:{spec}}" ≡ type(x).__format__(x, spec)

Python 3.12+ (PEP 701)

python
f"{d["kalit"]}"             bir xil tirnoq
f"{'\n'.join(x)}"           teskari chiziq
f"{                         ko'p qatorli
    sum(x)
}"

Xavfsizlik

text
Shablon DOIM kodda bo'lsin
Foydalanuvchi shabloni → string.Template
SQL → parametrlangan so'rov
HTML → html.escape()
Shell → ro'yxat argumentlari

4. Batafsil misollar

Misol 1 — f-satr ichkarisi

python
"""f-satr qanday ishlaydi."""

import dis
import timeit

ism, yosh = "Ali", 25

print("=== 1. Bytecode ===")
print("  f-satr:")
dis.dis('f"Salom, {ism}!"')

print("\n  .format():")
dis.dis('"Salom, {}!".format(ism)')

print("\n=== 2. Kechiktirilishi mumkin emas ===")
ism = "Ali"
SHABLON = f"Salom, {ism}!"
print(f"  Yaratilganda ism='Ali': {SHABLON!r}")

ism = "Vali"
print(f"  ism='Vali' bo'lgach:    {SHABLON!r}  ← o'zgarmadi")

SHABLON_FORMAT = "Salom, {ism}!"
print(f"  .format bilan:          {SHABLON_FORMAT.format(ism=ism)!r}  ← yangi qiymat")

print("\n=== 3. Ifodalar ===")
a, b = 5, 10
sonlar = [3, 1, 2]
malumot = {"ism": "Ali", "yosh": 25}

ifodalar = [
    ("f'{a + b}'",                      f"{a + b}"),
    ("f'{a * b - 3}'",                  f"{a * b - 3}"),
    ("f'{ism.upper()}'",                f"{ism.upper()}"),
    ("f'{len(ism)}'",                   f"{len(ism)}"),
    ("f'{sorted(sonlar)}'",             f"{sorted(sonlar)}"),
    ("f'{sonlar[0]}'",                  f"{sonlar[0]}"),
    ("f'{malumot[chr(39)+\"ism\"+chr(39)]}'", f"{malumot['ism']}"),
    ("f'{\"katta\" if a > 3 else \"kichik\"}'", f"{'katta' if a > 3 else 'kichik'}"),
    ("f'{[x * 2 for x in sonlar]}'",    f"{[x * 2 for x in sonlar]}"),
    ("f'{sum(sonlar)}'",                f"{sum(sonlar)}"),
]

for kod, natija in ifodalar:
    print(f"  {kod:<44} → {natija!r}")

print("\n=== 4. Morj operatori ===")
sonlar = [1, 2, 3, 4, 5]
print(f"  {(n := len(sonlar))} ta element, o'rtacha {sum(sonlar) / n:.1f}")
print(f"  n endi mavjud: {n}")

print("\n=== 5. Tezlik ===")
usullar = {
    "f-satr":    lambda: f"Salom, {ism}! Yosh: {yosh}",
    "%":         lambda: "Salom, %s! Yosh: %d" % (ism, yosh),
    "+ bilan":   lambda: "Salom, " + ism + "! Yosh: " + str(yosh),
    "join":      lambda: "".join(["Salom, ", ism, "! Yosh: ", str(yosh)]),
    ".format()": lambda: "Salom, {}! Yosh: {}".format(ism, yosh),
}

natijalar = {nom: timeit.timeit(f, number=300_000) for nom, f in usullar.items()}
eng_tez = min(natijalar.values())

for nom, vaqt in sorted(natijalar.items(), key=lambda x: x[1]):
    nisbat = vaqt / eng_tez
    print(f"  {nom:<12} {vaqt:.3f} s  {nisbat:>4.1f}x  {'█' * int(nisbat * 15)}")

Natijaning muhim qismi:

text
=== 2. Kechiktirilishi mumkin emas ===
  Yaratilganda ism='Ali': 'Salom, Ali!'
  ism='Vali' bo'lgach:    'Salom, Ali!'  ← o'zgarmadi
  .format bilan:          'Salom, Vali!'  ← yangi qiymat

=== 5. Tezlik ===
  f-satr       0.052 s   1.0x  ███████████████
  ...

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

Misol 2 — = bilan nosozlik izlash

python
"""f-satr = spetsifikatori — nosozlik izlashning eng tez usuli."""

from datetime import date


def eski_usul(narx, soni, chegirma):
    """print bilan qo'lda yozish."""
    print("  narx =", narx, ", soni =", soni, ", chegirma =", chegirma)
    summa = narx * soni
    print("  summa =", summa)
    return summa * (1 - chegirma)


def yangi_usul(narx, soni, chegirma):
    """f-satr = bilan."""
    print(f"  {narx=}, {soni=}, {chegirma=}")
    summa = narx * soni
    print(f"  {summa=}")
    return summa * (1 - chegirma)


print("=== Eski usul ===")
eski_usul(250_000, 4, 0.1)

print("\n=== Yangi usul ===")
yangi_usul(250_000, 4, 0.1)

print("\n=== Farqlar ===")
matn = "salom"
son = 42
kasr = 1234.5678
royxat = [1, 2, 3]
lugat = {"a": 1}
hech = None
sana = date(2026, 9, 8)

namunalar = [
    ("{matn=}",         f"{matn=}"),
    ("{son=}",          f"{son=}"),
    ("{kasr=}",         f"{kasr=}"),
    ("{royxat=}",       f"{royxat=}"),
    ("{lugat=}",        f"{lugat=}"),
    ("{hech=}",         f"{hech=}"),
    ("{sana=}",         f"{sana=}"),
]
for kod, natija in namunalar:
    print(f"  f'{kod}'".ljust(22) + f"→ {natija}")

print("\n=== ⭐ repr vs str ===")
print(f"  {matn=}       ← repr: tirnoq bilan")
print(f"  {matn=!s}     ← str:  tirnoqsiz")
print(f"  {matn}        ← oddiy")

print("\n=== Format bilan ===")
print(f"  {kasr=}")
print(f"  {kasr=:.2f}      ← format berilsa str() ga o'tadi")
print(f"  {kasr=:>15,.2f}")
print(f"  {sana=:%d.%m.%Y}")

print("\n=== Bo'shliqlar saqlanadi ===")
a, b = 5, 10
print(f"  {a=}")
print(f"  {a = }")
print(f"  { a = }")
print(f"  {a+b=}")
print(f"  {a + b = }")

print("\n=== Ifodalar ===")
print(f"  {len(matn)=}")
print(f"  {matn.upper()=}")
print(f"  {sum(royxat)=}")
print(f"  {[x*2 for x in royxat]=}")
print(f"  {(son > 40)=}")

print("\n=== ⭐ Nima uchun bu yaxshi ===")
print("""
  O'zgaruvchi nomini o'zgartirganingizda:

    print("narx =", narx)       ← qo'lda tuzatish kerak
    print(f"{narx=}")           ← avtomatik yangilanadi

  Bu — refaktoring paytida vaqt tejaydi va xatolarni oldini oladi.
""")
text
=== Eski usul ===
  narx = 250000 , soni = 4 , chegirma = 0.1
  summa = 1000000

=== Yangi usul ===
  narx=250000, soni=4, chegirma=0.1
  summa=1000000

=== Farqlar ===
  f'{matn=}'          → matn='salom'
  f'{son=}'           → son=42
  f'{kasr=}'          → kasr=1234.5678
  f'{royxat=}'        → royxat=[1, 2, 3]
  f'{lugat=}'         → lugat={'a': 1}
  f'{hech=}'          → hech=None
  f'{sana=}'          → sana=datetime.date(2026, 9, 8)

=== ⭐ repr vs str ===
  matn='salom'       ← repr: tirnoq bilan
  matn=salom     ← str:  tirnoqsiz
  salom        ← oddiy

=== Bo'shliqlar saqlanadi ===
  a=5
  a = 5
   a = 5
  a+b=15
  a + b = 15

Nima ko'rsatdi: 2.4-bo'lim.

Misol 3 — __format__ bilan o'z sinf

python
"""Sinfni f-satrga to'liq moslashtirish."""

from dataclasses import dataclass
from decimal import Decimal


@dataclass(frozen=True)
class Pul:
    """Pul miqdori — valyuta bilan."""

    summa: Decimal
    valyuta: str = "UZS"

    BELGILAR = {"UZS": "so'm", "USD": "$", "EUR": "€", "RUB": "₽"}

    def __str__(self) -> str:
        return f"{self.summa:,.2f} {self.BELGILAR.get(self.valyuta, self.valyuta)}"

    def __format__(self, spec: str) -> str:
        """Format spetsifikatorlarini qo'llab-quvvatlaydi.

        Maxsus qo'shimchalar:
          k  — qisqartirilgan (1.2M)
          b  — belgi bilan (1,250,000 so'm)
          s  — faqat son 1250000.00-bob
        """
        if not spec:
            return str(self)

        # Maxsus qo'shimchani ajratish
        rejim = ""
        if spec and spec[-1] in "kbs":
            rejim = spec[-1]
            spec = spec[:-1]

        if rejim == "k":
            qiymat = float(self.summa)
            for bolvchi, belgi in [(1e9, "B"), (1e6, "M"), (1e3, "K")]:
                if abs(qiymat) >= bolvchi:
                    return f"{qiymat / bolvchi:{spec or '.1f'}}{belgi}"
            return f"{qiymat:{spec or '.0f'}}"

        if rejim == "s":
            return f"{self.summa:{spec or ',.2f'}}"

        # b yoki sukut — belgi bilan
        belgi = self.BELGILAR.get(self.valyuta, self.valyuta)
        return f"{self.summa:{spec or ',.2f'}} {belgi}"


print("=== Asosiy ===")
narx = Pul(Decimal("1250000.50"))
print(f"  {narx}")                      # str()
print(f"  {narx!r}")                    # repr()
print(f"  {narx:}")                     # bo'sh spec

print("\n=== Maxsus rejimlar ===")
print(f"  {narx:k}       qisqartirilgan")
print(f"  {narx:.2k}     qisqartirilgan, 2 xona")
print(f"  {narx:s}       faqat son")
print(f"  {narx:b}       belgi bilan")

print("\n=== Standart spetsifikatorlar ===")
print(f"  {narx:,.0f}")
print(f"  {narx:>25,.2f}")
print(f"  {narx:e}")

print("\n=== Turli summalar ===")
summalar = [
    Pul(Decimal("125.50")),
    Pul(Decimal("12500")),
    Pul(Decimal("1250000")),
    Pul(Decimal("1250000000")),
    Pul(Decimal("1250.50"), "USD"),
    Pul(Decimal("999.99"), "EUR"),
]

print(f"  {'Oddiy':<24} {'Qisqa':<10} {'Faqat son':>16}")
print("  " + "─" * 52)
for p in summalar:
    # ⚠️ {p:k:<10} YOZMANG: butun "k:<10" __format__ ga bitta spec bo'lib
    #    boradi. Avval formatlab, keyin tekislang:
    print(f"  {p!s:<24} {format(p, 'k'):<10} {format(p, 's'):>16}")

print("\n=== .format() da ham ishlaydi ===")
print(f"  {'{:k}'.format(narx)}")
print(f"  {format(narx, 'k')}")

print("\n=== Jadval ===")
xarajatlar = [
    ("Ijara", Pul(Decimal("5000000"))),
    ("Kommunal", Pul(Decimal("750000"))),
    ("Internet", Pul(Decimal("150000"))),
    ("Maosh", Pul(Decimal("25000000"))),
]

w = max(len(nom) for nom, _ in xarajatlar)
jami = Pul(sum(p.summa for _, p in xarajatlar))

print(f"  ┌{'─' * (w + 22)}┐")
for nom, summa in xarajatlar:
    print(f"  │ {nom:<{w}}  {summa:>18,.0f} │")
print(f"  ├{'─' * (w + 22)}┤")
print(f"  │ {'JAMI':<{w}}  {jami:>18,.0f} │")
print(f"  │ {'':<{w}}  {jami:>18k} │")
print(f"  └{'─' * (w + 22)}┘")
text
=== Asosiy ===
  1,250,000.50 so'm
  Pul(summa=Decimal('1250000.50'), valyuta='UZS')
  1,250,000.50 so'm

=== Maxsus rejimlar ===
  1.2M       qisqartirilgan
  1.25M      qisqartirilgan, 2 xona
  1,250,000.50       faqat son
  1,250,000.50 so'm       belgi bilan

=== Turli summalar ===
  Oddiy                    Qisqa           Faqat son
  ────────────────────────────────────────────────────
  125.50 so'm              125.5              125.50
  12,500.00 so'm           12.5K           12,500.00
  1,250,000.00 so'm        1.2M         1,250,000.00
  1,250,000,000.00 so'm    1.2B     1,250,000,000.00
  1,250.50 $               1.3K            1,250.50
  999.99 €                 1000.0            999.99

=== Jadval ===
  ┌──────────────────────────────────┐
  │ Ijara            5,000,000 so'm │
  │ Kommunal           750,000 so'm │
  │ Internet           150,000 so'm │
  │ Maosh           25,000,000 so'm │
  ├──────────────────────────────────┤
  │ JAMI            30,900,000 so'm │
  │                          30.9M │
  └──────────────────────────────────┘

Nima ko'rsatdi: 2.5, 2.6-bo'limlar. __format__ bilan sinf f-satrga to'liq integratsiya qilinadi.

Misol 4 — Xavfsizlik

python
"""f-satr va xavfsizlik — nima mumkin, nima mumkin emas."""

import html
import shlex
from string import Template


class Sozlamalar:
    def __init__(self):
        self.ochiq = "Wisar"
        self.maxfiy_kalit = "sk_live_ABC123"


sozlamalar = Sozlamalar()


print("=== ✅ XAVFSIZ: shablon kodda ===")
foydalanuvchi_ismi = "Ali"
print(f"  Salom, {foydalanuvchi_ismi}!")

zararli_kirish = "{sozlamalar.maxfiy_kalit}"
print(f"  Salom, {zararli_kirish}!")
print("  ← shablon kodda, kirish faqat QIYMAT sifatida ishlatildi")


print("\n=== ❌ XAVFLI: foydalanuvchi shabloni ===")
print("  Agar shunday yozsangiz:")
print("    shablon = input()")
print("    print(eval(f'f\"{shablon}\"'))")
print("  Foydalanuvchi shunday kiritishi mumkin:")
print("    {__import__('os').system('rm -rf /')}")
print("  ← HECH QACHON eval bilan f-satr yaratmang")


print("\n=== ✅ Foydalanuvchi shabloni uchun Template ===")
foydalanuvchi_shabloni = "Salom, $ism! $maxfiy_kalit"
t = Template(foydalanuvchi_shabloni)
print(f"  {t.safe_substitute(ism='Ali')!r}")
print("  ← $maxfiy_kalit almashtirilmadi, chunki berilmagan")


print("\n=== HTML — XSS himoyasi ===")
izohlar = [
    "Yaxshi kurs!",
    "<script>alert('XSS')</script>",
    "Narx < 100 & sifat > 90",
]

print("  ❌ Ekranlashsiz:")
for izoh in izohlar:
    print(f"    <p>{izoh}</p>")

print("\n  ✅ html.escape bilan:")
for izoh in izohlar:
    print(f"    <p>{html.escape(izoh)}</p>")


print("\n=== SQL — in'yeksiya himoyasi ===")
user_id = "1 OR 1=1"

print(f"  ❌ f-satr bilan:")
print(f"     SELECT * FROM users WHERE id = {user_id}")
print(f"     ← barcha foydalanuvchi qaytadi!")

print(f"\n  ✅ Parametrlangan so'rov:")
print(f"     kursor.execute('SELECT * FROM users WHERE id = ?', (user_id,))")
print(f"     ← ma'lumotlar bazasi drayveri o'zi ekranlaydi")


print("\n=== Shell buyruqlari ===")
fayl = "hujjat.txt; rm -rf /"

print(f"  ❌ shell=True bilan:")
print(f"     subprocess.run(f'cat {{fayl}}', shell=True)")
print(f"     → cat {fayl}")
print(f"     ← ikkinchi buyruq ham bajariladi!")

print(f"\n  ✅ Ro'yxat argumentlari:")
print(f"     subprocess.run(['cat', fayl])")
print(f"     ← fayl nomi bitta argument sifatida uzatiladi")

print(f"\n  ✅ Agar shell kerak bo'lsa — shlex.quote:")
print(f"     {shlex.quote(fayl)}")


print("\n=== Umumiy qoidalar ===")
print("""
  1. f-satr shabloni DOIM kodda bo'lsin
  2. Foydalanuvchi faqat QIYMAT bersin
  3. Foydalanuvchi shabloni kerak bo'lsa → string.Template
  4. HTML → html.escape()
  5. SQL → parametrlangan so'rov
  6. Shell → ro'yxat argumentlari yoki shlex.quote()
  7. eval/exec bilan f-satr yaratmang — HECH QACHON
""")
text
=== ✅ XAVFSIZ: shablon kodda ===
  Salom, Ali!
  Salom, {sozlamalar.maxfiy_kalit}!
  ← shablon kodda, kirish faqat QIYMAT sifatida ishlatildi

=== ✅ Foydalanuvchi shabloni uchun Template ===
  'Salom, Ali! $maxfiy_kalit'
  ← $maxfiy_kalit almashtirilmadi, chunki berilmagan

=== HTML — XSS himoyasi ===
  ❌ Ekranlashsiz:
    <p>Yaxshi kurs!</p>
    <p><script>alert('XSS')</script></p>
    <p>Narx < 100 & sifat > 90</p>

  ✅ html.escape bilan:
    <p>Yaxshi kurs!</p>
    <p>&lt;script&gt;alert(&#x27;XSS&#x27;)&lt;/script&gt;</p>
    <p>Narx &lt; 100 &amp; sifat &gt; 90</p>

Nima ko'rsatdi: 2.9-bo'lim.


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

Noto'g'ri fikr To'g'risi
"f-satr — funksiya chaqiruvi" Sintaksis shakli. Kompilyatsiya paytida bytecode ga aylanadi
"f-satrni shablon sifatida saqlash mumkin" Yo'q — darhol hisoblanadi. .format() kerak
"f-satrda buyruq yozish mumkin" Faqat ifoda. x = 5 ishlamaydi (:= istisno)
"{x=} str() beradi" repr(). Format berilsa str() ga o'tadi
"f-satr .format() dan sekin" 2-3 barobar tez
"3.12 dagi tirnoq o'zgarishi hamma joyda ishlaydi" Faqat 3.12+ da. Eski versiyada SyntaxError
"__format__ yozmasam ham {x:>10} ishlaydi" Yo'q — object.__format__ faqat bo'sh spec
"f-satr xavfsiz" Shablon foydalanuvchidan kelsa — xavfli

6. Keng tarqalgan xatolar va yechimlari

1. f harfini unutish

python
print("Salom, {ism}")           # ❌ 'Salom, {ism}'
print(f"Salom, {ism}")          # ✅

Ruff topadi: F541.

2. Tirnoq to'qnashuvi (3.12 gacha)

python
f"{lugat["kalit"]}"             # ❌ 3.12 gacha SyntaxError
f"{lugat['kalit']}"             # ✅ hamma versiyada

3. Teskari chiziq (3.12 gacha)

python
f"{'\n'.join(x)}"               # ❌ 3.12 gacha SyntaxError

YANGI = "\n"                    # ✅
f"{YANGI.join(x)}"

4. Qavslarni chiqarish

python
f"{{}}"                         # '{}'
f"{{{x}}}"                      # '{qiymat}'
f"{ {'a': 1} }"                 # lug'at — bo'sh joy kerak

5. Shablonni saqlashga urinish

python
SHABLON = f"Salom, {ism}"       # ❌ darhol hisoblanadi
SHABLON = "Salom, {ism}"        # ✅ keyin .format(ism=...)

6. object.__format__ cheklovi

python
class A:
    def __str__(self): return "a"

f"{A()}"                        # ✅ 'a'
f"{A():>10}"                    # ❌ TypeError

# Yechim:
class A:
    def __str__(self): return "a"
    def __format__(self, spec): return format(str(self), spec)

7. Siklda f-satr bilan yig'ish

python
natija = ""
for x in katta:
    natija += f"{x}\n"          # ❌ O(n²)

natija = "\n".join(f"{x}" for x in katta)   # ✅

8. Foydalanuvchi shabloni

python
eval(f'f"{foydalanuvchi_shabloni}"')        # ❌ HECH QACHON
Template(foydalanuvchi_shabloni).safe_substitute(**malumot)   # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 3.13-dars (o'tilgan): f-satr asoslari
  • 4.6-dars (o'tilgan): format mini-tili, .format()
  • 13-qism: tur ishoralari va __format__ imzosi
  • 8-qism: __str__, __repr__, __format__ uchligi
  • 15-qism: logging — f-satr nima uchun ishlatilmaydi
  • 22-qism: veb — XSS, shablon injektsiyasi
  • 23-qism: SQL in'yeksiyasi
  • Har kuni: eng ko'p ishlatiladigan sintaksis

8. Eng yaxshi amaliyotlar

  1. f-satrni sukut tanlov qiling. Eng tez va eng o'qiladigan.

  2. Nosozlik izlashda {x=} ishlating. Refaktoring paytida avtomatik yangilanadi.

  3. __format__ yozing. O'z sinflaringiz f-satrda to'liq ishlasin.

  4. Ichma-ich spetsifikatorlardan foydalaning. f"{x:>{kenglik}}" — dinamik jadvallar uchun.

  5. Shablonni doim kodda saqlang. Foydalanuvchi faqat qiymat bersin.

  6. 3.12 yangiliklariga tayanmang — kodingiz eski versiyada ham ishlashi kerak bo'lsa.

  7. Siklda join ishlating. f-satr bilan += — O(n²).

  8. logging da f-satr ishlatmang. % uslubi — dangasa hisoblash va guruhlash uchun (4.6-dars).


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
a, b = 5, 10
matn = "salom"

1.  f"{a + b}"
2.  f"{a=}"
3.  f"{a + b = }"
4.  f"{matn=}"
5.  f"{matn=!s}"
6.  f"{matn!r}"
7.  f"{{}}"
8.  f"{1234.5678:>12,.2f}"
9.  f"{0.156:.1%}"
10. f"{42:#06x}"
11. f"{(n := a * b)}"
12. f"{matn:*^11}"
Javoblar
  1. '15'
  2. 'a=5'
  3. 'a + b = 15'
  4. "matn='salom'"
  5. 'matn=salom'
  6. "'salom'"
  7. '{}'
  8. ' 1,234.57'
  9. '15.6%'
  10. '0x002a'
  11. '50' (va n = 50)
  12. '***salom***'

Vazifa 2: __format__ yozish

Foiz sinfini yarating. Ichkarida ulush (0.156) saqlansin.

python
p = Foiz(0.15678)
f"{p}"          # '15.7%'
f"{p:.2}"       # '15.68%'
f"{p:.0}"       # '16%'
f"{p:u}"        # '0.1568'      — ulush ko'rinishida
f"{p:>10}"      # '     15.7%'
Yechim
python
class Foiz:
    def __init__(self, ulush: float):
        self.ulush = ulush

    def __str__(self) -> str:
        return f"{self.ulush:.1%}"

    def __repr__(self) -> str:
        return f"Foiz({self.ulush})"

    def __format__(self, spec: str) -> str:
        if spec.endswith("u"):
            return f"{self.ulush:{spec[:-1] or '.4f'}}"
        if not spec:
            return str(self)
        # Faqat aniqlik berilgan bo'lsa
        if spec.startswith("."):
            return f"{self.ulush:{spec}%}"
        return format(str(self), spec)

Vazifa 3: Dinamik jadval

Funksiya yozing: lug'atlar ro'yxatidan avtomatik jadval chizsin. Ustun kengliklari eng uzun qiymatga moslashsin, sonlar o'ngga tekislansin.

python
jadval([
    {"ism": "Sarvarbek", "ball": 88.456, "summa": 1250000},
    {"ism": "Ali", "ball": 92.1, "summa": 850000},
])

Vazifa 4: Nosozlik izlash yordamchisi

debug(**kwargs) funksiyasini yozing — barcha argumentni {nom=} uslubida chiqarsin:

python
a, b = 5, 10
debug(a=a, b=b, jami=a+b)
text
  DEBUG  a=5  b=10  jami=15

Vazifa 5: Xavfsizlik tekshiruvi

Quyidagi kodlarning qaysi biri xavfli? Nega? Qanday tuzatish kerak?

python
1.  print(f"Salom, {input('Ism: ')}")
2.  eval(f'f"{shablon}"')
3.  kursor.execute(f"SELECT * FROM t WHERE id={uid}")
4.  javob = f"<p>{izoh}</p>"
5.  subprocess.run(f"ls {papka}", shell=True)
6.  logging.info(f"Foydalanuvchi {ism}")
Javoblar
  1. Xavfsiz — kirish faqat qiymat sifatida ishlatiladi
  2. Juda xavfli — ixtiyoriy kod bajarish. Template ishlating
  3. SQL in'yeksiyasi — parametrlangan so'rov
  4. XSS — html.escape(izoh)
  5. Buyruq in'yeksiyasi — subprocess.run(["ls", papka])
  6. Xavfsiz, lekin noto'g'ri uslub — logging.info("Foydalanuvchi %s", ism)

Vazifa 6: Versiyalar mosligi

Quyidagi kod Python 3.12+ da ishlaydi. 3.9 uchun qayta yozing:

python
lugat = {"ism": "Ali", "teglar": ["a", "b"]}
print(f"{lugat["ism"]}: {"\n".join(lugat["teglar"])}")
Yechim
python
lugat = {"ism": "Ali", "teglar": ["a", "b"]}

teglar = "\n".join(lugat["teglar"])
print(f"{lugat['ism']}: {teglar}")

Ikki o'zgarish:

  1. Ichkaridagi tirnoqni ' ga o'zgartirish
  2. Teskari chiziqli ifodani tashqariga chiqarish

Vazifa 7: O'ylash

Nega f-satr .format() dan tezroq?

Javob

Uch sabab (bytecode darajasida):

1. Shablon kompilyatsiya paytida tahlil qilinadi.

.format() da "{} {}" satri har chaqiruvda tahlil qilinadi: qavslar qidiriladi, spetsifikatorlar ajratiladi. f-satrda bu ish bir marta, kompilyatsiya paytida bajariladi.

2. Metod qidiruvi yo'q.

.format() — LOAD_METHOD bilan str sinfidan format metodini topish kerak. f-satrda FORMAT_VALUE — to'g'ridan-to'g'ri bytecode buyrug'i.

3. Funksiya chaqiruvi yo'q.

CALL_METHOD — stek kadri yaratish, argumentlarni uzatish, qaytish. f-satrda bu xarajat yo'q.

Bytecode solishtiruvi:

text
f-satr:              .format():
  LOAD_CONST           LOAD_CONST
  LOAD_NAME            LOAD_METHOD    ← qidiruv
  FORMAT_VALUE         LOAD_NAME
  LOAD_CONST           CALL_METHOD    ← chaqiruv
  BUILD_STRING

Natija: odatda 2-3 barobar farq.

Lekin: bu farq faqat millionlab chaqiruvda seziladi. Kod o'qilishi tezlikdan muhimroq — va bu yerda ham f-satr yutadi.

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


Xulosa

Bu darsda f-satrni chuqur o'rgandik.

Eng muhim uch fikr:

  1. f-satr — sintaksis, funksiya emas. U kompilyatsiya paytida bytecode ga aylanadi, shuning uchun eng tez. Lekin shuning uchun ham uni kechiktirilgan shablon sifatida saqlab bo'lmaydi.

  2. {x=} — nosozlik izlashning eng tez usuli. U ifodaning matnini ham, qiymatini ham (repr bilan) chiqaradi va refaktoring paytida avtomatik yangilanadi.

  3. __format__ bilan sinflaringizni moslashtiring. object.__format__ faqat bo'sh spetsifikatorni qabul qiladi — f"{obyekt:>10}" ishlashi uchun metodni o'zingiz yozing.

Keyingi darsda Unicode ni to'liq o'rganamiz: kod nuqtalari, tekisliklar, kategoriyalar, normalizatsiya va nima uchun bu o'zbek tili uchun ayniqsa muhim.

Satrlar chuqur · 7-dars yakunlandi

4.7-dars: f-satr chuqur va format

22 daqvaqt
0belgi
Keyingi dars: 4.8-dars: Unicode nima va nega muhim
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0