4.7-dars: f-satr chuqur va __format__
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:
print(f"{2+3=}") # '2+3=5' — bo'shliqlar saqlanadi
print(f"{ 2 + 3 = }") # ' 2 + 3 = 5'lugat = {"ism": "Ali"}
print(f"{lugat['ism']}") # ✅ tirnoq kerak
print("{0[ism]}".format(lugat)) # ✅ tirnoqsiz — teskari!# 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.
import dis
ism = "Ali"
dis.dis('f"Salom, {ism}!"') 0 RESUME 0
1 LOAD_CONST 0 ('Salom, ')
LOAD_NAME 0 (ism)
FORMAT_VALUE 0
LOAD_CONST 1 ('!')
BUILD_STRING 3
RETURN_VALUENima bo'ldi:
- Doimiy qismlar (
'Salom, ','!') — kompilyatsiya paytida tayyor LOAD_NAME ism— o'zgaruvchi yuklanadiFORMAT_VALUE— formatlanadiBUILD_STRING 3— uch qism birlashtiriladi
Solishtiring .format() bilan:
dis.dis('"Salom, {}!".format(ism)') 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.
SHABLON = f"Salom, {ism}!" # DARHOL hisoblanadi
ism = "Vali"
print(SHABLON) # 'Salom, Ali!' — eski qiymatKechiktirilgan shablon kerak bo'lsa — .format() yoki Template (4.6-dars).
2.2. Ichidagi ifodalar
f-satr ichida deyarli har qanday ifoda bo'lishi mumkin:
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)}") # 6Nima MUMKIN EMAS:
# print(f"{x = 5}") # ❌ o'zlashtirish
# print(f"{import os}") # ❌ buyruq
# print(f"{return x}") # ❌ buyruqf-satr ichida faqat ifoda bo'ladi, buyruq emas (3.5-dars).
Morj operatori — istisno:
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:
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:
lugat = {"ism": "Ali"}
print(f"{lugat['ism']}") # ✅ ichkarida boshqa tirnoq
print(f'{lugat["ism"]}') # ✅
# print(f"{lugat["ism"]}") # ❌ SyntaxError — bir xil tirnoqSabab: f-satr oddiy satr sifatida tahlil qilinardi, shuning uchun ichkaridagi bir xil tirnoq uni tugatardi.
Python 3.12+ (PEP 701):
print(f"{lugat["ism"]}") # ✅ endi ishlaydi
print(f"{"salom"}") # ✅
print(f"{f"{f"ichma-ich"}"}") # ✅ cheksiz ichma-ich3.12 da f-satr alohida grammatika bilan tahlil qilinadi.
Boshqa 3.12 yangiliklari:
# 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:
# 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.tomldatarget-versionni to'g'ri sozlang (2.7-dars).
2.4. = — nosozlik izlash
Python 3.8+ da qo'shilgan va juda foydali.
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)=3Muhim: = sukut bo'yicha repr() ishlatadi — shuning uchun satr tirnoqlar bilan chiqadi. Bu — nosozlik izlash uchun aynan kerak.
Bo'shliqlar saqlanadi:
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:
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 ← strDiqqat: format spetsifikatori berilsa, = repr() dan str() ga o'tadi.
Amaliy foydalanish:
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_summasiNega 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):
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:
kenglik = 15
aniqlik = 2
print(f"{son:>{kenglik}.{aniqlik}f}")
print(f"{son:{'>'}{kenglik}.{aniqlik}f}") # tekislash ham dinamikAmaliy misol — jadval:
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},}") Sarvarbek 88.5 1,250,000
Ali 92.1 850,000
Guli 80.0 2,100,0002.6. __format__ — o'z sinflaringiz uchun
f-satr {obyekt:spec} ni ko'rganda type(obyekt).__format__(obyekt, spec) ni chaqiradi.
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:
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-quvvatlanmaydiobject.__format__ faqat bo'sh spetsifikatorni qabul qiladi. Boshqasi kerak bo'lsa — o'zingiz yozing.
Eng oddiy amalga oshiruv — satrga o'tkazish:
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:
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:
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:45Decimal:
from decimal import Decimal
narx = Decimal("1234.5678")
print(f"{narx:,.2f}") # 1,234.57
print(f"{narx:e}") # 1.2345678E+3Fraction:
from fractions import Fraction
f = Fraction(3, 4)
print(f"{f}") # 3/4
print(f"{float(f):.2f}") # 0.75Enum (8-qism):
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}") # 1IntEnum — sonli formatlash ishlaydi:
from enum import IntEnum
class Holat(IntEnum):
FAOL = 1
NOFAOL = 0
print(f"{Holat.FAOL:d}") # 1
print(f"{Holat.FAOL:03d}") # 0012.8. Tezlik va optimizatsiya
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:
- Shablon kompilyatsiya paytida tahlil qilinadi
- Metod qidiruvi yo'q
- Funksiya chaqiruvi yo'q
BUILD_STRING— optimallashtirilgan bytecode buyrug'i
Lekin siklda ehtiyot bo'ling:
# ❌ 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:
f"{x}" # FORMAT_VALUE chaqiradi
str(x) # to'g'ridan-to'g'riFarq juda kichik, lekin millionlab iteratsiyada seziladi.
2.9. Xavfsizlik
f-satr kod bajaradi — bu kuch, lekin xavf ham.
# ✅ Xavfsiz — shablon kodda
ism = foydalanuvchi_kiritmasi
print(f"Salom, {ism}") # ism faqat qiymat sifatida ishlatiladi# ❌ XAVFLI — shablon foydalanuvchidan
shablon = input("Shablon: ")
print(eval(f'f"{shablon}"')) # ❌ HECH QACHONNega xavfli?
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:
# ❌ 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:
import subprocess
# ❌ XAVFLI
subprocess.run(f"cat {fayl}", shell=True)
# ✅ Ro'yxat bilan
subprocess.run(["cat", fayl])HTML:
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
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 ishlaydiNosozlik izlash
f"{x=}" x=qiymat (repr!)
f"{x = }" bo'shliqlar saqlanadi
f"{x=:.2f}" format bilan (str ga o'tadi)
f"{x=!r}" aniq reprFormat (.format() bilan umumiy)
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__
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)
f"{d["kalit"]}" bir xil tirnoq
f"{'\n'.join(x)}" teskari chiziq
f"{ ko'p qatorli
sum(x)
}"Xavfsizlik
Shablon DOIM kodda bo'lsin
Foydalanuvchi shabloni → string.Template
SQL → parametrlangan so'rov
HTML → html.escape()
Shell → ro'yxat argumentlari4. Batafsil misollar
Misol 1 — f-satr ichkarisi
"""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:
=== 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
"""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.
""")=== 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 = 15Nima ko'rsatdi: 2.4-bo'lim.
Misol 3 — __format__ bilan o'z sinf
"""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)}┘")=== 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
"""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
""")=== ✅ 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><script>alert('XSS')</script></p>
<p>Narx < 100 & sifat > 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
print("Salom, {ism}") # ❌ 'Salom, {ism}'
print(f"Salom, {ism}") # ✅Ruff topadi: F541.
2. Tirnoq to'qnashuvi (3.12 gacha)
f"{lugat["kalit"]}" # ❌ 3.12 gacha SyntaxError
f"{lugat['kalit']}" # ✅ hamma versiyada3. Teskari chiziq (3.12 gacha)
f"{'\n'.join(x)}" # ❌ 3.12 gacha SyntaxError
YANGI = "\n" # ✅
f"{YANGI.join(x)}"4. Qavslarni chiqarish
f"{{}}" # '{}'
f"{{{x}}}" # '{qiymat}'
f"{ {'a': 1} }" # lug'at — bo'sh joy kerak5. Shablonni saqlashga urinish
SHABLON = f"Salom, {ism}" # ❌ darhol hisoblanadi
SHABLON = "Salom, {ism}" # ✅ keyin .format(ism=...)6. object.__format__ cheklovi
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
natija = ""
for x in katta:
natija += f"{x}\n" # ❌ O(n²)
natija = "\n".join(f"{x}" for x in katta) # ✅8. Foydalanuvchi shabloni
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
f-satrni sukut tanlov qiling. Eng tez va eng o'qiladigan.
Nosozlik izlashda
{x=}ishlating. Refaktoring paytida avtomatik yangilanadi.__format__yozing. O'z sinflaringiz f-satrda to'liq ishlasin.Ichma-ich spetsifikatorlardan foydalaning.
f"{x:>{kenglik}}"— dinamik jadvallar uchun.Shablonni doim kodda saqlang. Foydalanuvchi faqat qiymat bersin.
3.12 yangiliklariga tayanmang — kodingiz eski versiyada ham ishlashi kerak bo'lsa.
Siklda
joinishlating. f-satr bilan+=— O(n²).loggingda f-satr ishlatmang.%uslubi — dangasa hisoblash va guruhlash uchun (4.6-dars).
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
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
'15''a=5''a + b = 15'"matn='salom'"'matn=salom'"'salom'"'{}'' 1,234.57''15.6%''0x002a''50'(van = 50)'***salom***'
Vazifa 2: __format__ yozish
Foiz sinfini yarating. Ichkarida ulush (0.156) saqlansin.
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
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.
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:
a, b = 5, 10
debug(a=a, b=b, jami=a+b) DEBUG a=5 b=10 jami=15Vazifa 5: Xavfsizlik tekshiruvi
Quyidagi kodlarning qaysi biri xavfli? Nega? Qanday tuzatish kerak?
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
- Xavfsiz — kirish faqat qiymat sifatida ishlatiladi
- Juda xavfli — ixtiyoriy kod bajarish.
Templateishlating - SQL in'yeksiyasi — parametrlangan so'rov
- XSS —
html.escape(izoh) - Buyruq in'yeksiyasi —
subprocess.run(["ls", papka]) - 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:
lugat = {"ism": "Ali", "teglar": ["a", "b"]}
print(f"{lugat["ism"]}: {"\n".join(lugat["teglar"])}")Yechim
lugat = {"ism": "Ali", "teglar": ["a", "b"]}
teglar = "\n".join(lugat["teglar"])
print(f"{lugat['ism']}: {teglar}")Ikki o'zgarish:
- Ichkaridagi tirnoqni
'ga o'zgartirish - 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:
f-satr: .format():
LOAD_CONST LOAD_CONST
LOAD_NAME LOAD_METHOD ← qidiruv
FORMAT_VALUE LOAD_NAME
LOAD_CONST CALL_METHOD ← chaqiruv
BUILD_STRINGNatija: 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:
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.
{x=}— nosozlik izlashning eng tez usuli. U ifodaning matnini ham, qiymatini ham (reprbilan) chiqaradi va refaktoring paytida avtomatik yangilanadi.__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.
Izohlar · 0
Izoh yozish uchun kiring.