4.11-dars: Ko'p qatorli satrlar
4-QISM — SATRLAR CHUQUR · 11-dars
1. Kirish va motivatsiya
Ko'p qatorli matn — kundalik ehtiyoj: docstring, SQL so'rov, HTML shablon, yordam matni, konfiguratsiya.
Pythonda buning uchun uch tirnoq bor:
matn = """Birinchi qator
Ikkinchi qator"""Sodda ko'rinadi. Lekin chekinish muammosi darhol paydo bo'ladi:
def funksiya():
matn = """Birinchi qator
Ikkinchi qator"""
print(matn)
funksiya()Birinchi qator
Ikkinchi qatorIkkinchi qatorda ortiqcha bo'sh joy — chunki kod chekintirilgan.
Va yana:
matn = """
Salom
"""
print(repr(matn)) # '\nSalom\n' — boshida va oxirida yangi qatorBu darsda:
- Uch tirnoq — barcha nozikligi
- Chekinish muammosi va uch yechim
textwrapmoduli —dedent,indent,fill,shorten- Docstring formatlash
- SQL, HTML, konfiguratsiya bilan ishlash
2. Nazariya — chuqur tushuntirish
2.1. Uch tirnoq — asoslar
matn1 = """Uch qo'shtirnoq"""
matn2 = '''Uch apostrof'''
print(matn1 == "Uch qo'shtirnoq") # TrueIkkalasi bir xil. Farq — ichkarida qaysi tirnoq bo'lishi mumkinligida:
print("""U "salom" dedi""") # ✅ ichkarida qo'shtirnoq
print('''U 'salom' dedi''') # ✅ ichkarida apostrofO'zbek tili uchun:
"""afzal, chunkio',g'apostrof ishlatadi.
Yangi qator avtomatik saqlanadi:
matn = """Birinchi
Ikkinchi
Uchinchi"""
print(repr(matn)) # 'Birinchi\nIkkinchi\nUchinchi'
print(len(matn.splitlines())) # 3Oxirgi qator ajratgichi:
a = """Salom"""
b = """Salom
"""
print(repr(a)) # 'Salom'
print(repr(b)) # 'Salom\n'Yopilish tirnog'i yangi qatorda bo'lsa, oxirida \n qoladi.
2.2. Boshlanish va oxirgi yangi qator
Klassik muammo:
matn = """
Birinchi
Ikkinchi
"""
print(repr(matn)) # '\nBirinchi\nIkkinchi\n'Boshida va oxirida \n bor.
Uch yechim:
# 1. Teskari chiziq bilan qatorni davom ettirish
matn = """\
Birinchi
Ikkinchi
"""
print(repr(matn)) # 'Birinchi\nIkkinchi\n'
# 2. strip()
matn = """
Birinchi
Ikkinchi
""".strip()
print(repr(matn)) # 'Birinchi\nIkkinchi'
# 3. Birinchi qatorda boshlash
matn = """Birinchi
Ikkinchi"""
print(repr(matn)) # 'Birinchi\nIkkinchi'\ usuli — eng ko'p ishlatiladigan:
YORDAM = """\
Foydalanish: dastur.py [parametrlar] fayl
Parametrlar:
-h, --help Yordam
-v, --verbose Batafsil chiqish
"""Kod chiroyli ko'rinadi va ortiqcha \n yo'q.
2.3. Chekinish muammosi
def hisobot():
matn = """
HISOBOT
=======
Jami: 100
"""
return matn
print(repr(hisobot()))'\n HISOBOT\n =======\n Jami: 100\n 'Har qatorda 4 bo'sh joy — chunki kod chekintirilgan.
Uch yechim:
1. Chekinishsiz yozish (chirkin, lekin ishlaydi):
def hisobot():
matn = """
HISOBOT
=======
Jami: 100
"""
return matnKod tuzilishi buziladi, lekin natija to'g'ri.
2. textwrap.dedent (TAVSIYA ETILADI):
import textwrap
def hisobot():
matn = textwrap.dedent("""\
HISOBOT
=======
Jami: 100
""")
return matn
print(repr(hisobot())) # 'HISOBOT\n=======\nJami: 100\n'dedent umumiy chekinishni olib tashlaydi.
3. Qo'lda birlashtirish:
def hisobot():
return "\n".join([
"HISOBOT",
"=======",
"Jami: 100",
])Uzun matn uchun noqulay, lekin qisqa uchun toza.
2.4. textwrap.dedent — batafsil
import textwrap
matn = """
Birinchi
Ikkinchi
Uchinchi (ko'proq chekingan)
"""
print(repr(textwrap.dedent(matn)))'\nBirinchi\nIkkinchi\n Uchinchi (ko\'proq chekingan)\n'Qanday ishlaydi:
- Barcha bo'sh bo'lmagan qatorning umumiy prefiksini topadi
- Uni har qatordan olib tashlaydi
- Nisbiy chekinish saqlanadi
Tab va bo'sh joy aralashmasin:
matn = "\tBirinchi\n Ikkinchi"
print(repr(textwrap.dedent(matn))) # o'zgarmaydiTab va bo'sh joy — turli belgi, umumiy prefiks topilmaydi.
Birinchi qator chekintirilmagan bo'lsa:
matn = """Birinchi
Ikkinchi
Uchinchi"""
print(repr(textwrap.dedent(matn)))
# 'Birinchi\n Ikkinchi\n Uchinchi' ← o'zgarmadiBirinchi qatorda chekinish yo'q → umumiy prefiks bo'sh.
Yechim — \ bilan boshlash:
matn = """\
Birinchi
Ikkinchi"""
print(repr(textwrap.dedent(matn))) # 'Birinchi\nIkkinchi' ✅Bu — dedent bilan ishlashning standart naqshi.
Bo'sh qatorlar e'tiborsiz:
matn = """\
Birinchi
Ikkinchi"""
print(repr(textwrap.dedent(matn))) # 'Birinchi\n\nIkkinchi' ✅Bo'sh qatorlar prefiks hisobiga kirmaydi.
2.5. textwrap ning boshqa funksiyalari
indent — chekinish qo'shish:
import textwrap
matn = "Birinchi\nIkkinchi\nUchinchi"
print(textwrap.indent(matn, " "))
print(textwrap.indent(matn, "> "))
print(textwrap.indent(matn, "│ ")) Birinchi
Ikkinchi
Uchinchi
> Birinchi
> Ikkinchi
> Uchinchi
│ Birinchi
│ Ikkinchi
│ UchinchiShartli chekinish:
matn = "a\n\nb\n\nc"
print(repr(textwrap.indent(matn, "> ")))
# '> a\n\n> b\n\n> c' — bo'sh qatorlarga qo'shilmaydi
print(repr(textwrap.indent(matn, "> ", lambda q: True)))
# '> a\n> \n> b\n> \n> c' — hamma qatorgafill — matnni kenglikka moslash:
uzun = ("Python — bu yuqori darajali dasturlash tili. "
"U 1991-yilda Guido van Rossum tomonidan yaratilgan. "
"Python soddaligi bilan mashhur.")
print(textwrap.fill(uzun, width=50))Python — bu yuqori darajali dasturlash tili. U
1991-yilda Guido van Rossum tomonidan yaratilgan.
Python soddaligi bilan mashhur.Parametrlar bilan:
print(textwrap.fill(
uzun,
width=50,
initial_indent=" ", # birinchi qator
subsequent_indent=" ", # qolgan qatorlar
)) Python — bu yuqori darajali dasturlash tili. U
1991-yilda Guido van Rossum tomonidan
yaratilgan. Python soddaligi bilan mashhur.wrap — ro'yxat qaytaradi:
print(textwrap.wrap(uzun, width=50))
# ['Python — bu yuqori darajali...', 'U 1991-yilda...', ...]shorten — qisqartirish:
print(textwrap.shorten(uzun, width=50))
# 'Python — bu yuqori darajali dasturlash [...]'
print(textwrap.shorten(uzun, width=50, placeholder=" …"))
# 'Python — bu yuqori darajali dasturlash tili. …'shorten so'z o'rtasida kesmaydi — bu 4.2-darsdagi qo'lda yozilgan yechimning tayyor varianti.
TextWrapper sinfi — qayta ishlatish uchun:
wrapper = textwrap.TextWrapper(
width=60,
initial_indent="│ ",
subsequent_indent="│ ",
break_long_words=False,
break_on_hyphens=False,
)
for xatboshi in matn.split("\n\n"):
print(wrapper.fill(xatboshi))2.6. Docstring va chekinish
Docstring — ko'p qatorli satrning eng keng tarqalgan ishlatilishi (3.14-dars).
def funksiya():
"""Qisqacha tavsif.
Batafsil tushuntirish.
Bir necha qator.
"""
pass
print(repr(funksiya.__doc__))'Qisqacha tavsif.\n\n Batafsil tushuntirish.\n Bir necha qator.\n 'Chekinish saqlanadi — lekin help() uni to'g'ri ko'rsatadi:
help(funksiya)Help on function funksiya:
funksiya()
Qisqacha tavsif.
Batafsil tushuntirish.
Bir necha qator.Python help() va inspect.getdoc() da avtomatik dedent qiladi:
import inspect
print(repr(inspect.getdoc(funksiya)))
# 'Qisqacha tavsif.\n\nBatafsil tushuntirish.\nBir necha qator.' Amaliy natija: docstringni qo'lda dedent qilish shart emas — inspect.getdoc() ishlating.
__doc__ ni to'g'ridan-to'g'ri ishlatishda ehtiyot bo'ling:
def yordam():
"""\
Foydalanish: dastur.py [parametrlar]
Parametrlar:
-h Yordam
"""
print(yordam.__doc__) # chekinish bilan
print(inspect.getdoc(yordam)) # ✅ toza2.7. SQL so'rovlari
SO_ROV = """
SELECT
f.id,
f.ism,
COUNT(b.id) AS buyurtmalar
FROM foydalanuvchilar f
LEFT JOIN buyurtmalar b ON b.foydalanuvchi_id = f.id
WHERE f.faol = TRUE
AND f.royxat_sanasi >= %s
GROUP BY f.id, f.ism
HAVING COUNT(b.id) > 0
ORDER BY buyurtmalar DESC
LIMIT %s
"""SQL uchun chekinish muhim emas — ma'lumotlar bazasi bo'shliqlarni e'tiborsiz qoldiradi. Lekin loglarda chiroyli ko'rinishi uchun dedent foydali:
import textwrap
SO_ROV = textwrap.dedent("""\
SELECT id, ism
FROM foydalanuvchilar
WHERE faol = TRUE
""")Parametrlarni f-satr bilan qo'shmang:
# ❌ SQL in'yeksiyasi
so_rov = f"SELECT * FROM t WHERE id = {user_id}"
# ✅ Parametrlangan
kursor.execute("SELECT * FROM t WHERE id = %s", (user_id,))23-qismda batafsil.
2.8. Yonma-yon satrlar
Python yonma-yon yozilgan satr literallarini avtomatik birlashtiradi (4.1-dars):
matn = ("Birinchi qism "
"ikkinchi qism "
"uchinchi qism")
print(matn) # 'Birinchi qism ikkinchi qism uchinchi qism'Vergul qo'ymang:
matn = ("a", "b") # juftlik!
matn = ("a" "b") # 'ab'Bu — juda ko'p uchraydigan xato, ayniqsa ro'yxatlarda:
KENGAYTMALAR = [
".jpg",
".png" # ❌ vergul unutildi
".gif",
]
print(KENGAYTMALAR) # ['.jpg', '.png.gif'] ← ikkitasi birlashdi!Ruff topadi: ISC001 ("implicitly concatenated string literals on one line").
Foydali qo'llanish:
XABAR = (
"Hurmatli foydalanuvchi, sizning buyurtmangiz qabul qilindi. "
"Yetkazib berish 2-3 ish kunida amalga oshiriladi. "
"Savollar bo'lsa qo'llab-quvvatlash xizmatiga murojaat qiling."
)Bir uzun qator o'rniga bir necha qisqa — o'qish oson va PEP 8 ga mos (3.14-dars).
Farqi uch tirnoqdan:
uch_tirnoq = """Birinchi
Ikkinchi""" # yangi qator BOR
yonma_yon = ("Birinchi"
"Ikkinchi") # yangi qator YO'Q — 'BirinchiIkkinchi'
yonma_yon2 = ("Birinchi\n"
"Ikkinchi") # yangi qator qo'lda2.9. Amaliy naqshlar
Yordam matni:
import sys
import textwrap
YORDAM = textwrap.dedent("""\
Foydalanish: hisobot.py [parametrlar] <fayl>
Hisobot yaratish dasturi.
Parametrlar:
-h, --help Ushbu yordamni ko'rsatish
-o, --output FAYL Natijani FAYL ga yozish
-f, --format FMT Format: csv, json, html (sukut: csv)
-v, --verbose Batafsil chiqish
Misollar:
hisobot.py malumot.csv
hisobot.py -f json -o natija.json malumot.csv
""")
if "--help" in sys.argv:
print(YORDAM)Jadval chizish:
def quti(sarlavha: str, qatorlar: list[str], kenglik: int = 50) -> str:
"""Matnni chiroyli qutiga oladi."""
natija = ["┌" + "─" * (kenglik - 2) + "┐"]
natija.append("│" + sarlavha.center(kenglik - 2) + "│")
natija.append("├" + "─" * (kenglik - 2) + "┤")
for qator in qatorlar:
for wrapped in textwrap.wrap(qator, kenglik - 4) or [""]:
natija.append("│ " + wrapped.ljust(kenglik - 4) + " │")
natija.append("└" + "─" * (kenglik - 2) + "┘")
return "\n".join(natija)
print(quti("HISOBOT", [
"Jami savdo: 12,500,000 so'm",
"Bu juda uzun qator bo'lib, u avtomatik ravishda bir necha qatorga bo'linadi.",
]))Konfiguratsiya shabloni:
KONFIG_SHABLONI = textwrap.dedent("""\
# Avtomatik yaratilgan konfiguratsiya
# Yaratilgan: {sana}
[server]
host = {host}
port = {port}
[malumotlar_bazasi]
url = {db_url}
""")
print(KONFIG_SHABLONI.format(
sana="08.09.2026",
host="localhost",
port=8000,
db_url="postgresql://localhost/wisar",
))Ko'p qatorli f-satr:
ism, yosh, shahar = "Ali", 25, "Toshkent"
xabar = f"""\
Ism: {ism}
Yosh: {yosh}
Shahar: {shahar}
"""
print(textwrap.dedent(xabar)) f-satr va dedent tartibi:
# ✅ To'g'ri — dedent f-satr natijasiga
print(textwrap.dedent(f"""\
Ism: {ism}
"""))
# ⚠️ Ehtiyot — qiymat ichida yangi qator bo'lsa
kop_qatorli = "a\nb"
print(textwrap.dedent(f"""\
Qiymat: {kop_qatorli}
"""))
# 'Qiymat: a\nb\n' — ikkinchi qator chekinishsizAgar qiymat ichida yangi qator bo'lishi mumkin bo'lsa, indent bilan alohida ishlang.
3. Tez ma'lumotnoma
Uch tirnoq
"""...""" yoki '''...'''
"""\ ← boshida ortiqcha \n bo'lmasin
matn
"""
"""matn""" ← oxirida \n YO'Q
"""matn
""" ← oxirida \n BORtextwrap
import textwrap
textwrap.dedent(matn) umumiy chekinishni olib tashlash
textwrap.indent(matn, " ") chekinish qo'shish
textwrap.fill(matn, width=70) kenglikka moslash
textwrap.wrap(matn, width=70) ro'yxat qaytaradi
textwrap.shorten(matn, width=50) qisqartirish (so'z buzilmaydi)
textwrap.TextWrapper(...) qayta ishlatish uchunStandart naqsh
matn = textwrap.dedent("""\
Birinchi qator
Ikkinchi qator
""")Docstring
import inspect
inspect.getdoc(f) ✅ avtomatik dedent
f.__doc__ ⚠️ chekinish bilanYonma-yon satrlar
("a" "b") → 'ab' — birlashadi
("a", "b") → juftlik — ⚠️ vergul!4. Batafsil misollar
Misol 1 — Chekinish muammosi va yechimlari
"""Ko'p qatorli satrlarda chekinish."""
import textwrap
def usul_1_chekinishsiz():
"""Chekinishsiz yozish — chirkin, lekin ishlaydi."""
return """
HISOBOT
=======
Jami: 100
"""
def usul_2_dedent():
"""textwrap.dedent — TAVSIYA ETILADI."""
return textwrap.dedent("""\
HISOBOT
=======
Jami: 100
""")
def usul_3_join():
"""Qo'lda birlashtirish."""
return "\n".join([
"HISOBOT",
"=======",
"Jami: 100",
"",
])
def usul_4_notogri():
"""❌ Chekinish qoladi."""
return """
HISOBOT
=======
Jami: 100
"""
print("=== Solishtirish ===")
usullar = [
("1. Chekinishsiz", usul_1_chekinishsiz),
("2. dedent", usul_2_dedent),
("3. join", usul_3_join),
("4. ❌ Noto'g'ri", usul_4_notogri),
]
for nom, f in usullar:
natija = f()
print(f"\n {nom}:")
print(f" repr: {natija!r}")
print(f" Chiqish:")
for qator in natija.splitlines():
print(f" |{qator}|")
print("\n\n=== dedent ichkarisi ===")
namunalar = [
("Birinchi qator chekintirilgan", "\n a\n b\n"),
("Birinchi qator chekintirilmagan", "a\n b\n c"),
("Turli chuqurlik", "\n a\n b\n c\n"),
("Bo'sh qator bilan", "\n a\n\n b\n"),
("Tab va bo'sh joy", "\ta\n b"),
]
for izoh, matn in namunalar:
natija = textwrap.dedent(matn)
ozgardi = "✅ o'zgardi" if natija != matn else "❌ o'zgarmadi"
print(f"\n {izoh}:")
print(f" Kirish: {matn!r}")
print(f" Natija: {natija!r} {ozgardi}")
print("\n\n=== ⭐ Standart naqsh ===")
print(textwrap.dedent('''\
matn = textwrap.dedent("""\\
Birinchi qator
Ikkinchi qator
""")
Uch element:
1. `\\` — boshida ortiqcha \\n bo'lmasin
2. Bir xil chekinish — dedent uni topadi
3. Yopilish tirnog'i alohida qatorda — oxirida \\n
'''))Natijaning muhim qismi:
2. dedent:
repr: 'HISOBOT\n=======\nJami: 100\n'
Chiqish:
|HISOBOT|
|=======|
|Jami: 100|
4. ❌ Noto'g'ri:
repr: '\n HISOBOT\n =======\n Jami: 100\n '
Chiqish:
||
| HISOBOT|
| =======|
| Jami: 100|
=== dedent ichkarisi ===
Birinchi qator chekintirilmagan:
Kirish: 'a\n b\n c'
Natija: 'a\n b\n c' ❌ o'zgarmadi
Tab va bo'sh joy:
Kirish: '\ta\n b'
Natija: '\ta\n b' ❌ o'zgarmadiNima ko'rsatdi: 2.3, 2.4-bo'limlar.
Misol 2 — textwrap ning barcha funksiyasi
"""textwrap moduli — to'liq ma'lumotnoma."""
import textwrap
MATN = ("Python — bu yuqori darajali, umumiy maqsadli dasturlash tili. "
"U 1991-yilda Guido van Rossum tomonidan yaratilgan va soddaligi, "
"o'qilishi oson kodi bilan mashhur bo'lgan. Bugungi kunda Python "
"veb-dasturlash, ma'lumot tahlili va sun'iy intellekt sohalarida "
"keng qo'llaniladi.")
print("=== 1. fill — kenglikka moslash ===")
for kenglik in [40, 60, 80]:
print(f"\n width={kenglik}:")
for qator in textwrap.fill(MATN, width=kenglik).splitlines():
print(f" {qator}")
print("\n\n=== 2. Chekinish bilan ===")
print(textwrap.fill(
MATN,
width=56,
initial_indent=" ▸ ",
subsequent_indent=" ",
))
print("\n\n=== 3. wrap — ro'yxat ===")
qatorlar = textwrap.wrap(MATN, width=50)
print(f" Qatorlar soni: {len(qatorlar)}")
for i, q in enumerate(qatorlar[:3], 1):
print(f" {i}. {q}")
print(f" ...")
print("\n\n=== 4. shorten — qisqartirish ===")
for kenglik in [30, 50, 80]:
natija = textwrap.shorten(MATN, width=kenglik)
print(f" width={kenglik:>3}: {natija}")
print("\n Turli placeholder:")
for p in ["[...]", " …", " (davomi bor)"]:
print(f" {p!r:<16} → {textwrap.shorten(MATN, 50, placeholder=p)}")
print("\n\n=== 5. indent — chekinish qo'shish ===")
qisqa = "Birinchi\nIkkinchi\n\nUchinchi"
for prefiks in [" ", "> ", "│ ", "# "]:
print(f"\n prefiks={prefiks!r}:")
for q in textwrap.indent(qisqa, prefiks).splitlines():
print(f" |{q}|")
print("\n Bo'sh qatorlarga ham:")
for q in textwrap.indent(qisqa, "> ", lambda _: True).splitlines():
print(f" |{q}|")
print("\n\n=== 6. TextWrapper — qayta ishlatish ===")
wrapper = textwrap.TextWrapper(
width=56,
initial_indent="│ ",
subsequent_indent="│ ",
break_long_words=False,
break_on_hyphens=False,
)
XATBOSHILAR = MATN.split(". ")
print(" ┌" + "─" * 56 + "┐")
for x in XATBOSHILAR[:2]:
for q in wrapper.wrap(x + "."):
print(f" {q.ljust(58)}│")
print(" │" + " " * 56 + "│")
print(" └" + "─" * 56 + "┘")
print("\n\n=== 7. Parametrlar ===")
uzun_soz = "Bu juda-juda-juda-uzun-birlashtirilgan-so'z va oddiy matn"
print(" break_long_words=True (sukut):")
for q in textwrap.wrap(uzun_soz, width=20):
print(f" |{q}|")
print("\n break_long_words=False:")
for q in textwrap.wrap(uzun_soz, width=20, break_long_words=False):
print(f" |{q}|")
print("\n break_on_hyphens=False:")
for q in textwrap.wrap(uzun_soz, width=20, break_on_hyphens=False,
break_long_words=False):
print(f" |{q}|")Natijaning muhim qismi:
=== 4. shorten — qisqartirish ===
width= 30: Python — bu yuqori [...]
width= 50: Python — bu yuqori darajali, umumiy maqsadli [...]
width= 80: Python — bu yuqori darajali, umumiy maqsadli dasturlash tili. U 1991-yilda [...]
=== 5. indent — chekinish qo'shish ===
prefiks='> ':
|> Birinchi|
|> Ikkinchi|
||
|> Uchinchi|
Bo'sh qatorlarga ham:
|> Birinchi|
|> Ikkinchi|
|> |
|> Uchinchi|
=== 7. Parametrlar ===
break_long_words=True (sukut):
|Bu juda-juda-juda-|
|uzun-|
|birlashtirilgan-so'z|
|va oddiy matn|
break_long_words=False:
|Bu juda-juda-juda-|
|uzun-|
|birlashtirilgan-so'z|
|va oddiy matn|Nima ko'rsatdi: 2.5-bo'lim.
Misol 3 — Docstring va yordam matni
"""Ko'p qatorli satrlarning eng keng tarqalgan ishlatilishi."""
import inspect
import sys
import textwrap
def hisobla(narx: float, soni: int, chegirma: float = 0.0) -> float:
"""Xarid summasini chegirma bilan hisoblaydi.
Args:
narx: Bir dona mahsulot narxi.
soni: Mahsulotlar soni.
chegirma: Chegirma ulushi (0.1 = 10%). Sukut: 0.
Returns:
Chegirma qo'llangandan keyingi jami summa.
Raises:
ValueError: narx yoki soni manfiy bo'lsa.
Example:
>>> hisobla(1000, 3)
3000.0
>>> hisobla(1000, 3, 0.1)
2700.0
"""
if narx < 0 or soni < 0:
raise ValueError("Narx va soni manfiy bo'lishi mumkin emas")
return narx * soni * (1 - chegirma)
print("=== 1. __doc__ — xom holat ===")
print(repr(hisobla.__doc__)[:100] + "...")
print("\n Chiqish:")
for q in hisobla.__doc__.splitlines()[:6]:
print(f" |{q}|")
print("\n\n=== 2. inspect.getdoc() — avtomatik dedent ===")
toza = inspect.getdoc(hisobla)
print(repr(toza)[:100] + "...")
print("\n Chiqish:")
for q in toza.splitlines()[:6]:
print(f" |{q}|")
print("\n\n=== 3. Birinchi qatorni olish ===")
print(f" Qisqacha: {inspect.getdoc(hisobla).splitlines()[0]}")
print("\n\n=== 4. Yordam matni (CLI) ===")
YORDAM = textwrap.dedent("""\
Foydalanish: hisobot.py [PARAMETRLAR] <FAYL>
Savdo hisobotini yaratadi.
Parametrlar:
-h, --help Ushbu yordamni ko'rsatish va chiqish
-o, --output FAYL Natijani FAYL ga yozish (sukut: stdout)
-f, --format FORMAT Chiqish formati: csv, json, html
(sukut: csv)
-d, --date SANA Faqat SANA dan keyingi ma'lumot
(format: kk.oo.yyyy)
-v, --verbose Batafsil chiqish
--version Versiyani ko'rsatish
Misollar:
hisobot.py savdo.csv
hisobot.py -f json -o natija.json savdo.csv
hisobot.py -d 01.01.2026 -v savdo.csv
Xatolar haqida: https://wisar.uz/yordam
""")
print(textwrap.indent(YORDAM, " "))
print("\n=== 5. Dinamik yordam ===")
PARAMETRLAR = [
("-h, --help", "Ushbu yordamni ko'rsatish"),
("-o, --output FAYL", "Natijani FAYL ga yozish"),
("-f, --format FORMAT", "Chiqish formati: csv, json, html"),
("-v, --verbose", "Batafsil chiqish"),
]
def yordam_yarat(dastur: str, tavsif: str, parametrlar: list) -> str:
"""Parametrlar ro'yxatidan yordam matnini yaratadi."""
w = max(len(p) for p, _ in parametrlar)
qatorlar = [
f"Foydalanish: {dastur} [PARAMETRLAR] <FAYL>",
"",
textwrap.fill(tavsif, width=70),
"",
"Parametrlar:",
]
for parametr, izoh in parametrlar:
wrapped = textwrap.wrap(izoh, width=70 - w - 4)
qatorlar.append(f" {parametr.ljust(w)} {wrapped[0]}")
for davomi in wrapped[1:]:
qatorlar.append(" " * (w + 4) + davomi)
return "\n".join(qatorlar)
print(textwrap.indent(
yordam_yarat("hisobot.py",
"Savdo ma'lumotlaridan hisobot yaratadi va turli formatlarda "
"eksport qiladi.",
PARAMETRLAR),
" "
))=== 2. inspect.getdoc() — avtomatik dedent ===
'Xarid summasini chegirma bilan hisoblaydi.\n\nArgs:\n narx: Bir dona ...
Chiqish:
|Xarid summasini chegirma bilan hisoblaydi.|
||
|Args:|
| narx: Bir dona mahsulot narxi.|
| soni: Mahsulotlar soni.|
| chegirma: Chegirma ulushi (0.1 = 10%). Sukut: 0.|
=== 5. Dinamik yordam ===
Foydalanish: hisobot.py [PARAMETRLAR] <FAYL>
Savdo ma'lumotlaridan hisobot yaratadi va turli formatlarda eksport
qiladi.
Parametrlar:
-h, --help Ushbu yordamni ko'rsatish
-o, --output FAYL Natijani FAYL ga yozish
-f, --format FORMAT Chiqish formati: csv, json, html
-v, --verbose Batafsil chiqishNima ko'rsatdi: 2.6, 2.9-bo'limlar.
Misol 4 — Hisobot generatori
"""Ko'p qatorli satrlar bilan chiroyli hisobot."""
import textwrap
from dataclasses import dataclass
from datetime import date
@dataclass
class Mahsulot:
nom: str
narx: int
soni: int
izoh: str = ""
@property
def summa(self) -> int:
return self.narx * self.soni
KENGLIK = 64
def quti_yuqori(sarlavha: str = "") -> str:
if sarlavha:
chap = (KENGLIK - len(sarlavha) - 4) // 2
ong = KENGLIK - len(sarlavha) - 4 - chap
return f"┌{'─' * chap}┤ {sarlavha} ├{'─' * ong}┐"
return "┌" + "─" * (KENGLIK - 2) + "┐"
def quti_ajratgich() -> str:
return "├" + "─" * (KENGLIK - 2) + "┤"
def quti_past() -> str:
return "└" + "─" * (KENGLIK - 2) + "┘"
def quti_qator(matn: str = "", tekislash: str = "<") -> str:
ich = KENGLIK - 4
if tekislash == "^":
matn = matn.center(ich)
elif tekislash == ">":
matn = matn.rjust(ich)
else:
matn = matn.ljust(ich)
return f"│ {matn} │"
def hisobot(mahsulotlar: list[Mahsulot], sana: date) -> str:
qatorlar = [quti_yuqori("SAVDO HISOBOTI")]
qatorlar.append(quti_qator())
qatorlar.append(quti_qator(f"Sana: {sana:%d.%m.%Y}", "^"))
qatorlar.append(quti_qator())
qatorlar.append(quti_ajratgich())
# Sarlavha
qatorlar.append(quti_qator(
f"{'Mahsulot':<22}{'Narx':>10}{'Soni':>6}{'Summa':>14}"
))
qatorlar.append(quti_ajratgich())
# Mahsulotlar
for m in mahsulotlar:
qatorlar.append(quti_qator(
f"{m.nom[:22]:<22}{m.narx:>10,}{m.soni:>6}{m.summa:>14,}"
))
# Uzun izohni bo'lish
if m.izoh:
for wrapped in textwrap.wrap(m.izoh, KENGLIK - 8):
qatorlar.append(quti_qator(f" {wrapped}"))
# Jami
jami = sum(m.summa for m in mahsulotlar)
qatorlar.append(quti_ajratgich())
qatorlar.append(quti_qator(f"{'JAMI:':<38}{jami:>14,} so'm"))
qatorlar.append(quti_past())
return "\n".join(qatorlar)
MAHSULOTLAR = [
Mahsulot("Klaviatura", 250_000, 3),
Mahsulot("Sichqoncha", 120_000, 5, "Simsiz, USB qabul qilgich bilan"),
Mahsulot("Monitor 24 dyuym", 2_500_000, 2,
"IPS matritsa, 1920x1080, 75 Gts yangilanish chastotasi bilan"),
Mahsulot("Kabel HDMI", 45_000, 10),
]
print(hisobot(MAHSULOTLAR, date(2026, 9, 8)))
print("\n\n=== Matnli hisobot (fill bilan) ===")
XULOSA = ("Ushbu hisobot davomida jami to'rt turdagi mahsulot sotildi. "
"Eng ko'p daromad monitor savdosidan olindi. Kelgusi oyda "
"monitorlar zaxirasini oshirish tavsiya etiladi, chunki talab "
"barqaror o'sish tendensiyasini ko'rsatmoqda.")
print(textwrap.fill(
XULOSA,
width=KENGLIK,
initial_indent=" ",
subsequent_indent=" ",
))
print("\n\n=== Qisqa versiya (shorten) ===")
print(" " + textwrap.shorten(XULOSA, width=KENGLIK - 2, placeholder=" …"))┌──────────────────────┤ SAVDO HISOBOTI ├──────────────────────┐
│ │
│ Sana: 08.09.2026 │
│ │
├──────────────────────────────────────────────────────────────┤
│ Mahsulot Narx Soni Summa │
├──────────────────────────────────────────────────────────────┤
│ Klaviatura 250,000 3 750,000 │
│ Sichqoncha 120,000 5 600,000 │
│ Simsiz, USB qabul qilgich bilan │
│ Monitor 24 dyuym 2,500,000 2 5,000,000 │
│ IPS matritsa, 1920x1080, 75 Gts yangilanish │
│ chastotasi bilan │
│ Kabel HDMI 45,000 10 450,000 │
├──────────────────────────────────────────────────────────────┤
│ JAMI: 6,800,000 so'm │
└──────────────────────────────────────────────────────────────┘
=== Matnli hisobot (fill bilan) ===
Ushbu hisobot davomida jami to'rt turdagi mahsulot sotildi.
Eng ko'p daromad monitor savdosidan olindi. Kelgusi oyda
monitorlar zaxirasini oshirish tavsiya etiladi, chunki talab
barqaror o'sish tendensiyasini ko'rsatmoqda.
=== Qisqa versiya (shorten) ===
Ushbu hisobot davomida jami to'rt turdagi mahsulot sotildi. …Nima ko'rsatdi: 2.5, 2.9-bo'limlar amaliyotda.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
"""" va ''' farq qiladi" |
Bir xil. Farq — ichkaridagi tirnoqda |
| "Uch tirnoq chekinishni o'zi olib tashlaydi" | Yo'q — textwrap.dedent kerak |
"dedent har doim ishlaydi" |
Birinchi qator chekintirilmagan bo'lsa — yo'q. \ bilan boshlang |
"Tab va bo'sh joy dedent uchun bir xil" |
Turli belgi — umumiy prefiks topilmaydi |
"Docstringni qo'lda dedent qilish kerak" |
inspect.getdoc() avtomatik qiladi |
"("a", "b") — satr" |
Juftlik! Vergulsiz ("a" "b") — satr |
"shorten so'z o'rtasida kesadi" |
Yo'q — oxirgi to'liq so'zgacha qisqartiradi |
"indent bo'sh qatorlarga ham qo'shadi" |
Sukut bo'yicha yo'q |
6. Keng tarqalgan xatolar va yechimlari
1. Ortiqcha yangi qator
matn = """
Salom
""" # ❌ '\nSalom\n'
matn = """\
Salom
""" # ✅ 'Salom\n'2. Chekinish qoladi
def f():
return """
Salom
""" # ❌ chekinish bilan
def f():
return textwrap.dedent("""\
Salom
""") # ✅3. dedent ishlamadi
matn = """Birinchi
Ikkinchi"""
textwrap.dedent(matn) # ❌ birinchi qator chekintirilmagan
matn = """\
Birinchi
Ikkinchi"""
textwrap.dedent(matn) # ✅4. Vergul unutildi
KENGAYTMALAR = [
".jpg",
".png" # ❌ vergul yo'q
".gif",
] # ['.jpg', '.png.gif']Ruff: ISC001.
5. Tab va bo'sh joy aralashgan
# Muharrirda "Convert Indentation to Spaces" (2.7-dars)6. __doc__ ni to'g'ridan-to'g'ri chiqarish
print(f.__doc__) # ⚠️ chekinish bilan
print(inspect.getdoc(f)) # ✅7. f-satr va ko'p qatorli qiymat
kop_qatorli = "a\nb"
textwrap.dedent(f"""\
Qiymat: {kop_qatorli}
""") # ⚠️ ikkinchi qator chekinishsizYechim: textwrap.indent(kop_qatorli, " ") ni alohida qo'llang.
8. SQL da f-satr
f"SELECT * FROM t WHERE id = {uid}" # ❌ in'yeksiya
kursor.execute("... WHERE id = %s", (uid,)) # ✅7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 3.14-dars (o'tilgan): docstring formatlash
- 4.10-dars (o'tilgan):
\bilan qatorni davom ettirish - 7-qism: funksiya docstringlari
- 15-qism:
textwrap,inspect,argparse - 16-qism: konfiguratsiya fayllari, shablonlar
- 22-qism: HTML shablonlar, Jinja2
- 23-qism: SQL so'rovlari
- CLI dasturlarda: yordam matni, hisobotlar
8. Eng yaxshi amaliyotlar
"""\bilan boshlang. Ortiqcha yangi qator bo'lmaydi vadedentto'g'ri ishlaydi.textwrap.dedentni odat qiling. Kod tuzilishi ham, natija ham toza bo'ladi.Docstring uchun
inspect.getdoc(). Qo'ldadedentshart emas.Bo'sh joy ishlating, tab emas.
dedenttab bilan ishlamaydi (3.14-dars).Uzun matn uchun
textwrap.fill. Qo'lda qator bo'lish — o'zgarishga chidamsiz.Yonma-yon satrlarda vergulni tekshiring. Ruff
ISC001ni yoqing.SQL da parametrlangan so'rov. Ko'p qatorli satr — faqat so'rov shabloni uchun.
shortenni qo'lda kesish o'rniga. U so'zlarni buzmaydi.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
1. repr("""a""")
2. repr("""a
""")
3. repr("""\
a
""")
4. len(("a", "b"))
5. len(("a" "b"))
6. repr(textwrap.dedent("\n a\n b\n"))
7. repr(textwrap.dedent("a\n b"))
8. textwrap.shorten("bir ikki uch to'rt", 12)Javoblar
"'a'""'a\\n '""' a\\n '"— birinchi qator chekintirilgan,dedentkerak2— juftlik2—'ab'satri"'\\na\\nb\\n'""'a\\n b'"— o'zgarmadi'bir [...]'—'bir ikki [...]'14 belgi, 12 ga sig'maydi;[...]belgisi ham uzunlikka kiradi
Vazifa 2: Chekinishni tuzatish
def sertifikat(ism, kurs, sana):
return """
╔════════════════════════╗
║ SERTIFIKAT ║
╚════════════════════════╝
Ushbu sertifikat {} ga
"{}" kursini muvaffaqiyatli
tugatgani uchun berildi.
Sana: {}
""".format(ism, kurs, sana)Ikki usulda tuzating: dedent bilan va chekinishsiz yozib.
Vazifa 3: Yordam matni generatori
3-misoldagi yordam_yarat() ni kengaytiring:
- Misollar bo'limini qo'shing
- Terminal kengligiga moslashsin (
shutil.get_terminal_size()) - Parametrlarni guruhlarga bo'lsin
Vazifa 4: Matn qutisi
quti(matn, kenglik, uslub) funksiyasini yozing. uslub variantlari:
"oddiy": +-----+ "ikki": ╔═════╗ "yumaloq": ╭─────╮
| matn| ║ matn║ │ matn│
+-----+ ╚═════╝ ╰─────╯Uzun matn avtomatik bo'linsin (textwrap.wrap).
Vazifa 5: Markdown jadval
Lug'atlar ro'yxatidan Markdown jadval yarating:
malumot = [
{"ism": "Ali", "yosh": 25, "shahar": "Toshkent"},
{"ism": "Sarvarbek", "yosh": 30, "shahar": "Samarqand"},
]| ism | yosh | shahar |
|-----------|------|-----------|
| Ali | 25 | Toshkent |
| Sarvarbek | 30 | Samarqand |Vazifa 6: Hisobot generatori
4-misoldagi dasturni kengaytiring:
- Ustunlar kengligi ma'lumotga moslashsin
- Guruhlash qo'shing (kategoriya bo'yicha)
- Grafik qo'shing (
█belgilari bilan ulushni ko'rsatish)
Vazifa 7: O'ylash
Nega Python docstringlarni avtomatik dedent qilmaydi?
Javob
Chunki docstring — oddiy satr.
Python uchun docstring — funksiya tanasidagi birinchi ifoda bo'lgan satr literali. Uni maxsus qayta ishlash tilning sintaksisiga qo'shimcha qoida kiritish bo'lardi.
Muammolar:
Qaysi chekinishni olib tashlash? Birinchi qatorniki? Umumiy prefiks? Bu — qaror talab qiladi.
Boshqa satrlar bilan nomuvofiqlik.
x = """..."""va docstring bir xil sintaksis — ularni turlicha qayta ishlash chalkash bo'lardi.Ba'zan chekinish MUHIM. Docstring ichida kod misoli bo'lsa (doctest), chekinish saqlanishi kerak.
Yechim — vositalar darajasida:
help(), inspect.getdoc(), pydoc, Sphinx — hammasi inspect.cleandoc() ishlatadi:
import inspect
print(inspect.cleandoc.__doc__)cleandoc dedent dan biroz farq qiladi: u birinchi qatorni alohida qayta ishlaydi (u odatda chekintirilmagan bo'ladi).
Amaliy xulosa: docstringni o'zingiz dedent qilmang — inspect.getdoc() ishlating. U barcha nozik holatni to'g'ri hal qiladi.
Nimani mustahkamlaydi: 2.2, 2.3, 2.4, 2.5, 2.6-bo'limlar.
Xulosa
Bu darsda ko'p qatorli satrlarni o'rgandik.
Eng muhim uch fikr:
"""\bilan boshlang. Bu bitta belgi ortiqcha yangi qatorni oldini oladi vadedentning to'g'ri ishlashini ta'minlaydi — chunki birinchi qator ham chekintirilgan bo'ladi.textwrap.dedent— chekinish muammosining standart yechimi. U kod tuzilishini ham, natija tozaligini ham saqlaydi. Tab va bo'sh joy aralashmasin.Docstring uchun
inspect.getdoc(). U avtomatik tozalaydi va barcha nozik holatni to'g'ri hal qiladi — qo'ldadedentshart emas.
Keyingi darsda — 4-qismning yakuni — o'zgarmaslikni chuqur o'rganamiz: nega satrlar o'zgarmas, internlash, xotira optimizatsiyalari va samarali satr qurish usullari.
Izohlar · 0
Izoh yozish uchun kiring.