Python kursi4.11-dars: Ko'p qatorli satrlar
Python kursi · Satrlar chuqur

4.11-dars: Ko'p qatorli satrlar

21 daqiqa11/12-dars

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:

python
matn = """Birinchi qator
Ikkinchi qator"""

Sodda ko'rinadi. Lekin chekinish muammosi darhol paydo bo'ladi:

python
def funksiya():
    matn = """Birinchi qator
    Ikkinchi qator"""
    print(matn)

funksiya()
text
Birinchi qator
    Ikkinchi qator

Ikkinchi qatorda ortiqcha bo'sh joy — chunki kod chekintirilgan.

Va yana:

python
matn = """
Salom
"""
print(repr(matn))       # '\nSalom\n' — boshida va oxirida yangi qator

Bu darsda:

  • Uch tirnoq — barcha nozikligi
  • Chekinish muammosi va uch yechim
  • textwrap moduli — dedent, indent, fill, shorten
  • Docstring formatlash
  • SQL, HTML, konfiguratsiya bilan ishlash

2. Nazariya — chuqur tushuntirish

2.1. Uch tirnoq — asoslar

python
matn1 = """Uch qo'shtirnoq"""
matn2 = '''Uch apostrof'''

print(matn1 == "Uch qo'shtirnoq")       # True

Ikkalasi bir xil. Farq — ichkarida qaysi tirnoq bo'lishi mumkinligida:

python
print("""U "salom" dedi""")             # ✅ ichkarida qo'shtirnoq
print('''U 'salom' dedi''')             # ✅ ichkarida apostrof

O'zbek tili uchun: """ afzal, chunki o', g' apostrof ishlatadi.

Yangi qator avtomatik saqlanadi:

python
matn = """Birinchi
Ikkinchi
Uchinchi"""

print(repr(matn))       # 'Birinchi\nIkkinchi\nUchinchi'
print(len(matn.splitlines()))   # 3

Oxirgi qator ajratgichi:

python
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:

python
matn = """
Birinchi
Ikkinchi
"""
print(repr(matn))       # '\nBirinchi\nIkkinchi\n'

Boshida va oxirida \n bor.

Uch yechim:

python
# 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:

python
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

python
def hisobot():
    matn = """
    HISOBOT
    =======
    Jami: 100
    """
    return matn


print(repr(hisobot()))
text
'\n    HISOBOT\n    =======\n    Jami: 100\n    '

Har qatorda 4 bo'sh joy — chunki kod chekintirilgan.

Uch yechim:

1. Chekinishsiz yozish (chirkin, lekin ishlaydi):

python
def hisobot():
    matn = """
HISOBOT
=======
Jami: 100
"""
    return matn

Kod tuzilishi buziladi, lekin natija to'g'ri.

2. textwrap.dedent (TAVSIYA ETILADI):

python
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:

python
def hisobot():
    return "\n".join([
        "HISOBOT",
        "=======",
        "Jami: 100",
    ])

Uzun matn uchun noqulay, lekin qisqa uchun toza.

2.4. textwrap.dedent — batafsil

python
import textwrap

matn = """
    Birinchi
    Ikkinchi
        Uchinchi (ko'proq chekingan)
    """

print(repr(textwrap.dedent(matn)))
text
'\nBirinchi\nIkkinchi\n    Uchinchi (ko\'proq chekingan)\n'

Qanday ishlaydi:

  1. Barcha bo'sh bo'lmagan qatorning umumiy prefiksini topadi
  2. Uni har qatordan olib tashlaydi
  3. Nisbiy chekinish saqlanadi

Tab va bo'sh joy aralashmasin:

python
matn = "\tBirinchi\n    Ikkinchi"
print(repr(textwrap.dedent(matn)))      # o'zgarmaydi

Tab va bo'sh joy — turli belgi, umumiy prefiks topilmaydi.

Birinchi qator chekintirilmagan bo'lsa:

python
matn = """Birinchi
    Ikkinchi
    Uchinchi"""

print(repr(textwrap.dedent(matn)))
# 'Birinchi\n    Ikkinchi\n    Uchinchi'  ← o'zgarmadi

Birinchi qatorda chekinish yo'q → umumiy prefiks bo'sh.

Yechim — \ bilan boshlash:

python
matn = """\
    Birinchi
    Ikkinchi"""

print(repr(textwrap.dedent(matn)))      # 'Birinchi\nIkkinchi' ✅

Bu — dedent bilan ishlashning standart naqshi.

Bo'sh qatorlar e'tiborsiz:

python
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:

python
import textwrap

matn = "Birinchi\nIkkinchi\nUchinchi"

print(textwrap.indent(matn, "    "))
print(textwrap.indent(matn, "> "))
print(textwrap.indent(matn, "│ "))
text
    Birinchi
    Ikkinchi
    Uchinchi
> Birinchi
> Ikkinchi
> Uchinchi
│ Birinchi
│ Ikkinchi
│ Uchinchi

Shartli chekinish:

python
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 qatorga

fill — matnni kenglikka moslash:

python
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))
text
Python — bu yuqori darajali dasturlash tili. U
1991-yilda Guido van Rossum tomonidan yaratilgan.
Python soddaligi bilan mashhur.

Parametrlar bilan:

python
print(textwrap.fill(
    uzun,
    width=50,
    initial_indent="  ",            # birinchi qator
    subsequent_indent="    ",       # qolgan qatorlar
))
text
  Python — bu yuqori darajali dasturlash tili. U
    1991-yilda Guido van Rossum tomonidan
    yaratilgan. Python soddaligi bilan mashhur.

wrap — ro'yxat qaytaradi:

python
print(textwrap.wrap(uzun, width=50))
# ['Python — bu yuqori darajali...', 'U 1991-yilda...', ...]

shorten — qisqartirish:

python
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:

python
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).

python
def funksiya():
    """Qisqacha tavsif.

    Batafsil tushuntirish.
    Bir necha qator.
    """
    pass


print(repr(funksiya.__doc__))
text
'Qisqacha tavsif.\n\n    Batafsil tushuntirish.\n    Bir necha qator.\n    '

Chekinish saqlanadi — lekin help() uni to'g'ri ko'rsatadi:

python
help(funksiya)
text
Help on function funksiya:

funksiya()
    Qisqacha tavsif.

    Batafsil tushuntirish.
    Bir necha qator.

Python help() va inspect.getdoc() da avtomatik dedent qiladi:

python
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:

python
def yordam():
    """\
    Foydalanish: dastur.py [parametrlar]

    Parametrlar:
      -h  Yordam
    """


print(yordam.__doc__)               # chekinish bilan
print(inspect.getdoc(yordam))       # ✅ toza

2.7. SQL so'rovlari

python
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:

python
import textwrap

SO_ROV = textwrap.dedent("""\
    SELECT id, ism
    FROM foydalanuvchilar
    WHERE faol = TRUE
""")

Parametrlarni f-satr bilan qo'shmang:

python
# ❌ 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):

python
matn = ("Birinchi qism "
        "ikkinchi qism "
        "uchinchi qism")

print(matn)     # 'Birinchi qism ikkinchi qism uchinchi qism'

Vergul qo'ymang:

python
matn = ("a", "b")           # juftlik!
matn = ("a" "b")            # 'ab'

Bu — juda ko'p uchraydigan xato, ayniqsa ro'yxatlarda:

python
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:

python
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:

python
uch_tirnoq = """Birinchi
Ikkinchi"""                 # yangi qator BOR

yonma_yon = ("Birinchi"
             "Ikkinchi")    # yangi qator YO'Q — 'BirinchiIkkinchi'

yonma_yon2 = ("Birinchi\n"
              "Ikkinchi")   # yangi qator qo'lda

2.9. Amaliy naqshlar

Yordam matni:

python
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:

python
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:

python
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:

python
ism, yosh, shahar = "Ali", 25, "Toshkent"

xabar = f"""\
    Ism:    {ism}
    Yosh:   {yosh}
    Shahar: {shahar}
"""
print(textwrap.dedent(xabar))

f-satr va dedent tartibi:

python
# ✅ 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 chekinishsiz

Agar qiymat ichida yangi qator bo'lishi mumkin bo'lsa, indent bilan alohida ishlang.


3. Tez ma'lumotnoma

Uch tirnoq

python
"""..."""  yoki  '''...'''

"""\           ← boshida ortiqcha \n bo'lmasin
matn
"""

"""matn"""     ← oxirida \n YO'Q
"""matn
"""            ← oxirida \n BOR

textwrap

python
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 uchun

Standart naqsh

python
matn = textwrap.dedent("""\
    Birinchi qator
    Ikkinchi qator
    """)

Docstring

python
import inspect
inspect.getdoc(f)       ✅ avtomatik dedent
f.__doc__               ⚠️ chekinish bilan

Yonma-yon satrlar

python
("a" "b")               → 'ab'    — birlashadi
("a", "b")              → juftlik — ⚠️ vergul!

4. Batafsil misollar

Misol 1 — Chekinish muammosi va yechimlari

python
"""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:

text
  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'zgarmadi

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

Misol 2 — textwrap ning barcha funksiyasi

python
"""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:

text
=== 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

python
"""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),
    "  "
))
text
=== 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 chiqish

Nima ko'rsatdi: 2.6, 2.9-bo'limlar.

Misol 4 — Hisobot generatori

python
"""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=" …"))
text
┌──────────────────────┤ 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

python
matn = """
Salom
"""                             # ❌ '\nSalom\n'

matn = """\
Salom
"""                             # ✅ 'Salom\n'

2. Chekinish qoladi

python
def f():
    return """
    Salom
    """                         # ❌ chekinish bilan

def f():
    return textwrap.dedent("""\
        Salom
        """)                    # ✅

3. dedent ishlamadi

python
matn = """Birinchi
    Ikkinchi"""
textwrap.dedent(matn)           # ❌ birinchi qator chekintirilmagan

matn = """\
    Birinchi
    Ikkinchi"""
textwrap.dedent(matn)           # ✅

4. Vergul unutildi

python
KENGAYTMALAR = [
    ".jpg",
    ".png"                      # ❌ vergul yo'q
    ".gif",
]                               # ['.jpg', '.png.gif']

Ruff: ISC001.

5. Tab va bo'sh joy aralashgan

python
# Muharrirda "Convert Indentation to Spaces" (2.7-dars)

6. __doc__ ni to'g'ridan-to'g'ri chiqarish

python
print(f.__doc__)                # ⚠️ chekinish bilan
print(inspect.getdoc(f))        # ✅

7. f-satr va ko'p qatorli qiymat

python
kop_qatorli = "a\nb"
textwrap.dedent(f"""\
    Qiymat: {kop_qatorli}
""")                            # ⚠️ ikkinchi qator chekinishsiz

Yechim: textwrap.indent(kop_qatorli, " ") ni alohida qo'llang.

8. SQL da f-satr

python
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

  1. """\ bilan boshlang. Ortiqcha yangi qator bo'lmaydi va dedent to'g'ri ishlaydi.

  2. textwrap.dedent ni odat qiling. Kod tuzilishi ham, natija ham toza bo'ladi.

  3. Docstring uchun inspect.getdoc(). Qo'lda dedent shart emas.

  4. Bo'sh joy ishlating, tab emas. dedent tab bilan ishlamaydi (3.14-dars).

  5. Uzun matn uchun textwrap.fill. Qo'lda qator bo'lish — o'zgarishga chidamsiz.

  6. Yonma-yon satrlarda vergulni tekshiring. Ruff ISC001 ni yoqing.

  7. SQL da parametrlangan so'rov. Ko'p qatorli satr — faqat so'rov shabloni uchun.

  8. shorten ni qo'lda kesish o'rniga. U so'zlarni buzmaydi.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
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
  1. "'a'"
  2. "'a\\n '"
  3. "' a\\n '" — birinchi qator chekintirilgan, dedent kerak
  4. 2 — juftlik
  5. 2 — 'ab' satri
  6. "'\\na\\nb\\n'"
  7. "'a\\n b'" — o'zgarmadi
  8. 'bir [...]' — 'bir ikki [...]' 14 belgi, 12 ga sig'maydi; [...] belgisi ham uzunlikka kiradi

Vazifa 2: Chekinishni tuzatish

python
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:

  1. Misollar bo'limini qo'shing
  2. Terminal kengligiga moslashsin (shutil.get_terminal_size())
  3. Parametrlarni guruhlarga bo'lsin

Vazifa 4: Matn qutisi

quti(matn, kenglik, uslub) funksiyasini yozing. uslub variantlari:

text
"oddiy":   +-----+     "ikki":    ╔═════╗     "yumaloq": ╭─────╮
           | matn|                ║ matn║                │ matn│
           +-----+                ╚═════╝                ╰─────╯

Uzun matn avtomatik bo'linsin (textwrap.wrap).

Vazifa 5: Markdown jadval

Lug'atlar ro'yxatidan Markdown jadval yarating:

python
malumot = [
    {"ism": "Ali", "yosh": 25, "shahar": "Toshkent"},
    {"ism": "Sarvarbek", "yosh": 30, "shahar": "Samarqand"},
]
text
| ism       | yosh | shahar    |
|-----------|------|-----------|
| Ali       | 25   | Toshkent  |
| Sarvarbek | 30   | Samarqand |

Vazifa 6: Hisobot generatori

4-misoldagi dasturni kengaytiring:

  1. Ustunlar kengligi ma'lumotga moslashsin
  2. Guruhlash qo'shing (kategoriya bo'yicha)
  3. 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:

  1. Qaysi chekinishni olib tashlash? Birinchi qatorniki? Umumiy prefiks? Bu — qaror talab qiladi.

  2. Boshqa satrlar bilan nomuvofiqlik. x = """...""" va docstring bir xil sintaksis — ularni turlicha qayta ishlash chalkash bo'lardi.

  3. 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:

python
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:

  1. """\ bilan boshlang. Bu bitta belgi ortiqcha yangi qatorni oldini oladi va dedent ning to'g'ri ishlashini ta'minlaydi — chunki birinchi qator ham chekintirilgan bo'ladi.

  2. textwrap.dedent — chekinish muammosining standart yechimi. U kod tuzilishini ham, natija tozaligini ham saqlaydi. Tab va bo'sh joy aralashmasin.

  3. Docstring uchun inspect.getdoc(). U avtomatik tozalaydi va barcha nozik holatni to'g'ri hal qiladi — qo'lda dedent shart emas.

Keyingi darsda — 4-qismning yakuni — o'zgarmaslikni chuqur o'rganamiz: nega satrlar o'zgarmas, internlash, xotira optimizatsiyalari va samarali satr qurish usullari.

Satrlar chuqur · 11-dars yakunlandi

4.11-dars: Ko'p qatorli satrlar

21 daqvaqt
0belgi
Keyingi dars: 4.12-dars: Immutability — satr nega o'zgarmaydi
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0