Python kursi/Asoslar7/14-dars20 daqiqa

Mundarija (23)

3.7-dars: `str` bilan tanishuv

3-QISM — ASOSLAR · 7-dars

1. Kirish va motivatsiya

Satrlar — dasturlashda eng ko'p ishlatiladigan tur. Foydalanuvchi kiritgan matn, fayl mazmuni, tarmoqdan kelgan ma'lumot, veb-sahifa, log yozuvi — hammasi satr.

Va Pythonda satrlar juda kuchli. Boshqa ko'p tilda satr bilan ishlash og'riqli — Pythonda esa bir zavq.

Lekin ikkita muhim tushuncha bor, ularsiz keyinroq chalkashasiz:

Birinchisi — satrlar o'zgarmas:

python

matn = "salom"
matn[0] = "S"           # TypeError!

Ikkinchisi — satr belgilar ketma-ketligi, baytlar emas:

python

matn = "salom"
print(len(matn))        # 5

matn = "салом"          # kirilcha
print(len(matn))        # 5 — belgilar soni

print(len(matn.encode("utf-8")))    # 10 — baytlar soni!

Bu farq o'zbek, rus, xitoy tillari bilan ishlaganda hal qiluvchi ahamiyatga ega.

Bu dars — kirish. To'liq satr mavzusi 4-qismga bag'ishlangan (12 dars). Bu yerda asosini qo'yamiz: yaratish, indekslash, asosiy metodlar va o'zgarmaslik.

2. Nazariya — chuqur tushuntirish

2.1. Satr yaratish

Pythonda tirnoq turi farq qilmaydi:

python

a = 'bitta tirnoq'
b = "qo'shtirnoq"
print(a == "bitta tirnoq")      # True

Nega ikki xil? Ichkarida tirnoq bo'lganda qulay:

python

print("O'zbekiston")                # ✅ apostrof ichkarida
print('U "salom" dedi')             # ✅ qo'shtirnoq ichkarida
print('It\'s ok')                   # ekranlash bilan
print("U \"salom\" dedi")           # ekranlash bilan

O'zbek tili uchun muhim: o', g' harflari apostrof ishlatadi. Shuning uchun o'zbekcha matnlarni qo'shtirnoqda yozing:
python
print("Bo'lim")     # ✅
print('Bo'lim')     # ❌ SyntaxError

Ko'p qatorli satr — uch tirnoq:

python

matn = """Birinchi qator
Ikkinchi qator
Uchinchi qator"""

print(matn)

text

Birinchi qator
Ikkinchi qator
Uchinchi qator

Uch tirnoq docstring uchun ham ishlatiladi (2.8-dars):

python

def funksiya():
    """Bu — docstring."""

Yonma-yon satrlar avtomatik birlashadi:

python

matn = "Birinchi qism " "ikkinchi qism"
print(matn)                     # Birinchi qism ikkinchi qism

uzun = (
    "Bu juda uzun matn bo'lib, "
    "u bir necha qatorga bo'lingan "
    "lekin bitta satr hisoblanadi."
)

Bu — uzun matnlarni chiroyli yozish usuli. Diqqat: vergul qo'ymang, aks holda juftlik (tuple) bo'ladi:

python

xato = ("a", "b")       # tuple, satr emas!
togri = ("a" "b")       # 'ab'

2.2. Ekranlash ketma-ketliklari

python

print("Birinchi\nIkkinchi")     # \n — yangi qator
print("Ustun1\tUstun2")         # \t — tabulyatsiya
print("Yo'l: C:\\Users")        # \\ — teskari chiziq
print("U \"salom\" dedi")       # \" — qo'shtirnoq
print("It\'s ok")               # \' — apostrof

To'liq ro'yxat:

Belgi	Ma'nosi
`\n`	Yangi qator
`\t`	Tabulyatsiya
`\r`	Karetkani qaytarish (Windows: `\r\n`)
`\\`	Teskari chiziq
`\'` `\"`	Tirnoqlar
`\0`	Nol belgi
`\uXXXX`	Unicode (4 raqam)
`\U0001F600`	Unicode (8 raqam)
`\N{name}`	Unicode nom bo'yicha

python

print("\u00e9")                 # é
print("\U0001F60A")             # 😊
print("\N{GREEK SMALL LETTER ALPHA}")   # α

Xom satrlar (r"...") — ekranlash o'chiriladi:

python

print("C:\new\table")           # ❌ \n va \t sifatida talqin qilinadi
print(r"C:\new\table")          # ✅ C:\new\table

Xom satrlar qayerda kerak:

Windows yo'llari: r"C:\Users\Documents"
Muntazam ifodalar: r"\d+\.\d+" (15-qism)
LaTeX, regex naqshlari

Diqqat: xom satr teskari chiziq bilan tugay olmaydi: r"C:\" — SyntaxError.

2.3. Satr — belgilar ketma-ketligi

Pythonda satr — Unicode kod nuqtalari ketma-ketligi. Har bir element — bitta belgi.

python

matn = "salom"

print(len(matn))            # 5
print(matn[0])              # 's'
print(matn[4])              # 'm'
print(matn[-1])             # 'm' — oxirgi
print(matn[-2])             # 'o'

Indekslash sxemasi:

text

        s   a   l   o   m
        0   1   2   3   4      ← musbat indeks
       -5  -4  -3  -2  -1      ← manfiy indeks

Chegaradan chiqish — xato:

python

print(matn[10])             # IndexError: string index out of range

Belgi ham satr:

python

print(type(matn[0]))        # <class 'str'>
print(len(matn[0]))         # 1

Pythonda alohida "belgi" (char) turi yo'q — bitta belgi ham satr.

Iteratsiya:

python

for harf in "salom":
    print(harf, end=" ")

text

s a l o m

Unicode kod nuqtalari:

python

print(ord("A"))             # 65
print(ord("a"))             # 97
print(ord("o'"[0]))         # 111 — 'o'
print(chr(65))              # 'A'
print(chr(0x1F600))         # 😀

ord — belgidan raqamga, chr — raqamdan belgiga. Bu — 1.1-darsdagi "kompyuter faqat sonlar bilan ishlaydi" tushunchasining amaliy ko'rinishi.

2.4. Kesimlar (slicing)

Satrning bir qismini olish:

python

matn = "Python dasturlash"

print(matn[0:6])            # 'Python'
print(matn[7:])             # 'dasturlash'
print(matn[:6])             # 'Python'
print(matn[:])              # butun satr (nusxa)
print(matn[-10:])           # 'dasturlash'
print(matn[::2])            # 'Pto atrah' — har ikkinchisi
print(matn[::-1])           # 'halrutsad nohtyP' — teskari

Sintaksis: matn[boshi:oxiri:qadam]

Qism	Ma'nosi	Sukut
`boshi`	Qaysi indeksdan	`0`
`oxiri`	Qaysi indeksgacha (kirmaydi)	oxirigacha
`qadam`	Har nechanchisi	`1`

Muhim: oxiri kirmaydi:

python

print(matn[0:6])            # indeks 0,1,2,3,4,5 — 6 kirmaydi

Nega shunday? Chunki bu qulay:

python

print(len(matn[a:b]) == b - a)      # uzunlik = b - a
print(matn[:3] + matn[3:] == matn)  # True — bo'lish va birlashtirish

Kesim chegaradan chiqmaydi:

python

print(matn[0:100])          # butun satr — xato yo'q!
print(matn[50:60])          # '' — bo'sh satr

Indekslashdan farqli o'laroq, kesim xavfsiz.

Teskarilash idiomasi:

python

print("salom"[::-1])        # 'molas'

Bu — Pythonda satrni teskarilashning standart usuli.

2.5. Satrlar o'zgarmas (immutable)

Bu — eng muhim tushuncha.

python

matn = "salom"
matn[0] = "S"

text

TypeError: 'str' object does not support item assignment

Satrni o'zgartirib bo'lmaydi. Faqat yangi satr yaratish mumkin:

python

matn = "salom"
yangi = "S" + matn[1:]
print(yangi)                # 'Salom'
print(matn)                 # 'salom' — o'zgarmadi

Barcha satr metodlari yangi satr qaytaradi:

python

matn = "salom"

print(matn.upper())         # 'SALOM' — yangi satr
print(matn)                 # 'salom' — asl o'zgarmadi

matn = matn.upper()         # o'zgartirmoqchi bo'lsangiz — qayta o'zlashtiring
print(matn)                 # 'SALOM'

Nega o'zgarmas?

Xavfsizlik — satr lug'at kaliti bo'la oladi (o'zgaruvchan obyekt bo'la olmaydi)
Tezlik — Python bir xil satrlarni birlashtirib (internlash) xotira tejaydi
Bashorat qilinadigan — satrni funksiyaga bersangiz, u o'zgartira olmaydi

Yorliq modeli bilan bog'lash (3.1-dars):

python

a = "salom"
b = a
b = b.upper()               # b YANGI obyektga ko'chdi
print(a)                    # 'salom' — o'zgarmadi
print(b)                    # 'SALOM'

Ro'yxatlar bilan solishtiring:

python

a = [1, 2]
b = a
b.append(3)                 # OBYEKTNI o'zgartirdi
print(a)                    # [1, 2, 3] — o'zgardi!

Amaliy natija — siklda satr qo'shish sekin:

python

# ❌ Sekin — har qo'shishda YANGI satr yaratiladi
natija = ""
for i in range(10000):
    natija += str(i)

# ✅ Tez — ro'yxat yig'ib, oxirida birlashtirish
qismlar = []
for i in range(10000):
    qismlar.append(str(i))
natija = "".join(qismlar)

Farq katta hajmda yuzlab marta. Bu — 4-qismning muhim mavzusi.

2.6. Asosiy amallar

Birlashtirish va takrorlash:

python

print("Salom" + ", " + "dunyo!")    # 'Salom, dunyo!'
print("ha" * 3)                     # 'hahaha'
print("-" * 20)                     # '--------------------'

Diqqat: satr va sonni qo'shib bo'lmaydi:

python

print("Yosh: " + 25)        # ❌ TypeError
print("Yosh: " + str(25))   # ✅
print(f"Yosh: {25}")        # ✅ eng yaxshi

Tekshirish — in:

python

matn = "Python dasturlash"

print("Python" in matn)         # True
print("java" in matn)           # False
print("python" in matn)         # False — katta-kichik harf muhim
print("python" in matn.lower()) # True

Solishtirish:

python

print("a" < "b")            # True — alifbo tartibi
print("A" < "a")            # True — 65 < 97 (Unicode kodi)
print("abc" == "abc")       # True
print("abc" < "abd")        # True
print("10" < "9")           # True! — satr solishtiruvi, son emas

Oxirgisi tuzoq: satrlar belgi-belgi solishtiriladi. "1" < "9" shuning uchun "10" < "9".

2.7. Eng ko'p ishlatiladigan metodlar

Satrda 47 ta metod bor. Eng muhimlari:

Registr:

python

matn = "salom Dunyo"

print(matn.upper())         # 'SALOM DUNYO'
print(matn.lower())         # 'salom dunyo'
print(matn.title())         # 'Salom Dunyo'
print(matn.capitalize())    # 'Salom dunyo'
print(matn.swapcase())      # 'SALOM dUNYO'

Tozalash:

python

matn = "  salom  \n"

print(repr(matn.strip()))       # 'salom'      — ikki tomondan
print(repr(matn.lstrip()))      # 'salom  \n'  — chapdan
print(repr(matn.rstrip()))      # '  salom'    — o'ngdan
print("xxsalomxx".strip("x"))   # 'salom'      — belgi ko'rsatib

strip() argumentsiz bo'sh joy, tab, yangi qatorni olib tashlaydi. Foydalanuvchi kiritmasini tozalashda majburiy.

Qidirish:

python

matn = "Python dasturlash"

print(matn.find("dastur"))      # 7  — indeks
print(matn.find("java"))        # -1 — topilmadi
print(matn.index("dastur"))     # 7
# matn.index("java")            # ValueError!
print(matn.count("a"))          # 3
print(matn.startswith("Py"))    # True
print(matn.endswith("lash"))    # True

find topilmasa -1, index esa ValueError beradi. Ikkalasi ham foydali — tanlov sizniki.

Almashtirish:

python

matn = "salom dunyo"

print(matn.replace("dunyo", "olam"))    # 'salom olam'
print(matn.replace("o", "0"))           # 'sal0m dune0'
print(matn.replace("o", "0", 1))        # 'sal0m dunyo' — faqat 1 marta

Bo'lish va birlashtirish:

python

matn = "olma,anor,uzum"

print(matn.split(","))              # ['olma', 'anor', 'uzum']
print("a b  c".split())             # ['a', 'b', 'c'] — bo'sh joy bo'yicha
print("a-b-c".split("-", 1))        # ['a', 'b-c'] — faqat 1 marta

qismlar = ["olma", "anor", "uzum"]
print(", ".join(qismlar))           # 'olma, anor, uzum'
print("".join(qismlar))             # 'olmaanoruzum'
print("\n".join(qismlar))           # har biri yangi qatorda

join — ajratgich ustida chaqiriladi, ro'yxat ustida emas. Bu boshida g'alati tuyuladi, lekin mantiqiy.

Tekshirish:

python

print("abc".isalpha())          # True  — faqat harflar
print("123".isdigit())          # True  — faqat raqamlar
print("abc123".isalnum())       # True  — harf yoki raqam
print("   ".isspace())          # True  — faqat bo'sh joy
print("Salom".istitle())        # True  — Har So'z Bosh Harfda
print("ABC".isupper())          # True
print("abc".islower())          # True

Bular foydalanuvchi kiritmasini tekshirishda juda foydali.

2.8. f-satrlar bilan tanishuv

Satrlarni formatlashning zamonaviy usuli (Python 3.6+):

python

ism = "Ali"
yosh = 25

print(f"Salom, {ism}! Siz {yosh} yoshdasiz.")
print(f"Keyingi yil: {yosh + 1}")
print(f"Katta harfda: {ism.upper()}")

Ichida istalgan ifoda bo'lishi mumkin.

Foydali imkoniyatlar:

python

narx = 1234567.891

print(f"{narx:,.2f}")           # 1,234,567.89
print(f"{narx:>15,.2f}")        # o'ngga tekislash
print(f"{0.156:.1%}")           # 15.6%
print(f"{42:05d}")              # 00042
print(f"{ism!r}")               # 'Ali' — tirnoqlar bilan
print(f"{ism=}")                # ism='Ali' — nosozlik izlash uchun!

{ism=} — Python 3.8+ da qo'shilgan va nosozlik izlashda juda qulay:

python

a, b = 5, 10
print(f"{a=}, {b=}, {a + b=}")

text

a=5, b=10, a + b=15

Eski usullar (ko'rasiz, lekin ishlatmang):

python

print("Salom, %s! Siz %d yoshdasiz." % (ism, yosh))     # eski, C uslubi
print("Salom, {}! Siz {} yoshdasiz.".format(ism, yosh)) # .format
print(f"Salom, {ism}! Siz {yosh} yoshdasiz.")           # ✅ zamonaviy

3.13-darsda to'liq o'rganamiz.

2.9. Unicode va o'zbek tili

Python 3 da satr — Unicode. Bu o'zbek tili uchun juda muhim.

python

matn = "O'zbekiston"
print(len(matn))                # 11
print(matn.upper())             # "O'ZBEKISTON"

Kirilcha ham ishlaydi:

python

matn = "Ўзбекистон"
print(len(matn))                # 10
print(matn.upper())             # 'ЎЗБЕКИСТОН'

Baytlarga aylantirish:

python

matn = "salom"
print(matn.encode("utf-8"))         # b'salom' — 5 bayt

matn = "салом"
print(matn.encode("utf-8"))         # b'\xd1\x81\xd0\xb0\xd0\xbb\xd0\xbe\xd0\xbc'
print(len(matn))                    # 5  — belgilar
print(len(matn.encode("utf-8")))    # 10 — baytlar

Kirilcha harflar UTF-8 da 2 bayt egallaydi. Lotin harflari — 1 bayt.

Bu farq nima uchun muhim?

Ma'lumotlar bazasida maydon uzunligi (baytlarda yoki belgilardami?)
Tarmoq orqali yuborish
Fayl hajmi

Teskari aylantirish:

python

baytlar = b"salom"
print(baytlar.decode("utf-8"))      # 'salom'

4-qismda batafsil.

Tuzoq — o'xshash harflar:

python

a = "a"                 # lotincha
b = "а"                 # kirilcha
print(a == b)           # False!
print(ord(a), ord(b))   # 97 1072

Ular bir xil ko'rinadi, lekin turli belgi. Bu — qidiruvda tushunarsiz muammolar manbai.

3. Tez ma'lumotnoma

Yaratish

python

'bitta'   "qo'shtirnoq"   """ko'p
qatorli"""
r"xom\satr"    f"format {qiymat}"

Indekslash va kesim

python

matn[0]         birinchi
matn[-1]        oxirgi
matn[0:5]       kesim (5 KIRMAYDI)
matn[:5]        boshidan
matn[5:]        oxirigacha
matn[::-1]      teskari
matn[::2]       har ikkinchisi

Asosiy metodlar

python

.upper() .lower() .title() .capitalize()
.strip() .lstrip() .rstrip()
.find() .index() .count() .replace()
.split() .join() .startswith() .endswith()
.isdigit() .isalpha() .isalnum() .isspace()

Muhim

text

Satrlar O'ZGARMAS — barcha metod YANGI satr qaytaradi
matn.upper()          asl o'zgarmaydi
matn = matn.upper()   o'zgartirish shunday

Tezlik

python

❌ natija += qism        siklda sekin
✅ "".join(qismlar)      tez

4. Batafsil misollar

Misol 1 — Indekslash va kesimlar

python

matn = "Python dasturlash"

print(f"Satr:     {matn!r}")
print(f"Uzunlik:  {len(matn)}")
print()

print("=== Indekslash ===")
print(f"matn[0]    = {matn[0]!r}")
print(f"matn[5]    = {matn[5]!r}")
print(f"matn[-1]   = {matn[-1]!r}")
print(f"matn[-4]   = {matn[-4]!r}")
print()

print("=== Kesimlar ===")
print(f"matn[0:6]  = {matn[0:6]!r}")
print(f"matn[:6]   = {matn[:6]!r}")
print(f"matn[7:]   = {matn[7:]!r}")
print(f"matn[-10:] = {matn[-10:]!r}")
print(f"matn[::2]  = {matn[::2]!r}")
print(f"matn[::-1] = {matn[::-1]!r}")
print(f"matn[2:12:3] = {matn[2:12:3]!r}")
print()

print("=== Kesim xavfsiz, indeks emas ===")
print(f"matn[0:100] = {matn[0:100]!r}")
print(f"matn[50:60] = {matn[50:60]!r}")
try:
    matn[100]
except IndexError as xato:
    print(f"matn[100]   → IndexError: {xato}")
print()

print("=== Xususiyat: bo'lish va birlashtirish ===")
n = 6
print(f"matn[:{n}] + matn[{n}:] == matn  →  {matn[:n] + matn[n:] == matn}")

text

Satr:     'Python dasturlash'
Uzunlik:  17

=== Indekslash ===
matn[0]    = 'P'
matn[5]    = 'n'
matn[-1]   = 'h'
matn[-4]   = 'l'

=== Kesimlar ===
matn[0:6]  = 'Python'
matn[:6]   = 'Python'
matn[7:]   = 'dasturlash'
matn[-10:] = 'dasturlash'
matn[::2]  = 'Pto atrah'
matn[::-1] = 'halrutsad nohtyP'
matn[2:12:3] = 'to s'

=== Kesim xavfsiz, indeks emas ===
matn[0:100] = 'Python dasturlash'
matn[50:60] = ''
matn[100]   → IndexError: string index out of range

=== Xususiyat: bo'lish va birlashtirish ===
matn[:6] + matn[6:] == matn  →  True

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

Misol 2 — O'zgarmaslikni ko'rish

python

matn = "salom"

print(f"Boshlang'ich: {matn!r}, id = {id(matn)}")

print("\n=== Metodlar YANGI satr qaytaradi ===")
katta = matn.upper()
print(f"matn.upper() → {katta!r}, id = {id(katta)}")
print(f"matn hali:     {matn!r}, id = {id(matn)}")

print("\n=== Qayta o'zlashtirish yorliqni ko'chiradi ===")
matn = matn.upper()
print(f"matn = matn.upper() → {matn!r}, id = {id(matn)}")

print("\n=== O'zgartirishga urinish ===")
try:
    matn[0] = "X"
except TypeError as xato:
    print(f"matn[0] = 'X'  →  TypeError: {xato}")

print("\n=== To'g'ri usul: yangi satr qurish ===")
asl = "salom"
yangi = "S" + asl[1:]
print(f"'S' + asl[1:] → {yangi!r}")
print(f"asl hali:       {asl!r}")

print("\n=== Ro'yxat bilan solishtirish ===")
r1 = [1, 2, 3]
r2 = r1
r2.append(4)
print(f"Ro'yxat: r1 = {r1}  ← r2 orqali o'zgardi")

s1 = "abc"
s2 = s1
s2 = s2 + "d"
print(f"Satr:    s1 = {s1!r}  ← o'zgarmadi")

print("\n=== Tezlik farqi ===")
import time

N = 20_000

boshlandi = time.perf_counter()
natija = ""
for i in range(N):
    natija += "x"
vaqt_qoshish = time.perf_counter() - boshlandi

boshlandi = time.perf_counter()
qismlar = []
for i in range(N):
    qismlar.append("x")
natija = "".join(qismlar)
vaqt_join = time.perf_counter() - boshlandi

print(f"  += bilan:   {vaqt_qoshish * 1000:.2f} ms")
print(f"  join bilan: {vaqt_join * 1000:.2f} ms")
print(f"  Farq:       {vaqt_qoshish / vaqt_join:.1f}x")

Natijaning muhim qismi:

text

=== Metodlar YANGI satr qaytaradi ===
matn.upper() → 'SALOM', id = ...
matn hali:     'salom', id = ...

=== O'zgartirishga urinish ===
matn[0] = 'X'  →  TypeError: 'str' object does not support item assignment

=== Ro'yxat bilan solishtirish ===
Ro'yxat: r1 = [1, 2, 3, 4]  ← r2 orqali o'zgardi
Satr:    s1 = 'abc'  ← o'zgarmadi

=== Tezlik farqi ===
  += bilan:   3.21 ms
  join bilan: 1.84 ms
  Farq:       1.7x

Eslatma: CPython += ni ba'zi holatlarda optimallashtiradi, shuning uchun farq kutilganidan kichik bo'lishi mumkin. Lekin bu optimizatsiya kafolatlanmagan — boshqa amalga oshiruvda (PyPy) yoki murakkabroq kodda u ishlamaydi. join — doim to'g'ri tanlov.

Nima ko'rsatdi: 2.5-bo'lim va 3.1-darsdagi yorliq modeli.

Misol 3 — Metodlar bilan matn tozalash

python

"""Foydalanuvchi kiritmasini tozalash va tekshirish."""


def tozalash(matn: str) -> str:
    """Ortiqcha bo'sh joylarni olib tashlaydi."""
    return " ".join(matn.split())


def ism_tekshir(ism: str) -> tuple[bool, str]:
    """Ismni tekshiradi va (natija, xabar) qaytaradi."""
    toza = tozalash(ism)

    if not toza:
        return False, "Ism bo'sh"
    if len(toza) < 2:
        return False, "Ism juda qisqa"
    if len(toza) > 50:
        return False, "Ism juda uzun"
    if any(h.isdigit() for h in toza):
        return False, "Ismda raqam bo'lmasligi kerak"

    return True, toza.title()


sinovlar = [
    "  ali   valiyev  ",
    "a",
    "",
    "   ",
    "Ali123",
    "sarvarbek     abdullayev",
    "O'ktam Karimov",
]

print(f"{'Kirish':<28} {'Natija':<10} {'Javob'}")
print("-" * 60)

for kirish in sinovlar:
    tekshirildi, xabar = ism_tekshir(kirish)
    belgi = "✅" if tekshirildi else "❌"
    print(f"{repr(kirish):<28} {belgi:<10} {xabar}")

text

Kirish                       Natija     Javob
------------------------------------------------------------
'  ali   valiyev  '          ✅         Ali Valiyev
'a'                          ❌         Ism juda qisqa
''                           ❌         Ism bo'sh
'   '                        ❌         Ism bo'sh
'Ali123'                     ❌         Ismda raqam bo'lmasligi kerak
'sarvarbek     abdullayev'   ✅         Sarvarbek Abdullayev
"O'ktam Karimov"             ✅         O'ktam Karimov

" ".join(matn.split()) idiomasi:

python

"  a   b    c  ".split()        # ['a', 'b', 'c'] — bo'sh joylar tashlanadi
" ".join(['a', 'b', 'c'])       # 'a b c'

Ikki qadam birgalikda barcha ortiqcha bo'sh joyni bitta bo'sh joyga aylantiradi. Bu — matn tozalashning standart usuli.

Nima ko'rsatdi: 2.7-bo'lim va 3.5-darsdagi any().

Misol 4 — Amaliy dastur: matn statistikasi

python

"""Matn haqida to'liq statistika."""

MATN = """Python — bu yuqori darajali dasturlash tili.
U 1991-yilda Guido van Rossum tomonidan yaratilgan.
Python soddaligi va o'qilishi oson kodi bilan mashhur.
Bugungi kunda u dunyodagi eng ko'p ishlatiladigan tillardan biri."""


def statistika(matn: str) -> dict:
    qatorlar = matn.splitlines()
    sozlar = matn.split()
    harflar = [h for h in matn if h.isalpha()]

    return {
        "Belgilar (jami)": len(matn),
        "Belgilar (bo'sh joysiz)": len(matn.replace(" ", "").replace("\n", "")),
        "Harflar": len(harflar),
        "Raqamlar": sum(h.isdigit() for h in matn),
        "So'zlar": len(sozlar),
        "Qatorlar": len(qatorlar),
        "Gaplar": matn.count(".") + matn.count("!") + matn.count("?"),
        "Baytlar (UTF-8)": len(matn.encode("utf-8")),
    }


def eng_uzun_soz(matn: str) -> str:
    sozlar = [s.strip(".,!?;:") for s in matn.split()]
    return max(sozlar, key=len)


def harf_chastotasi(matn: str, nechta: int = 5) -> list[tuple[str, int]]:
    harflar = [h.lower() for h in matn if h.isalpha()]
    noyob = set(harflar)
    hisob = [(h, harflar.count(h)) for h in noyob]
    return sorted(hisob, key=lambda x: -x[1])[:nechta]


print("┌─ MATN STATISTIKASI")
print("│")
for nom, qiymat in statistika(MATN).items():
    print(f"│  {nom:<26} {qiymat:>6}")
print("│")
print(f"│  Eng uzun so'z: {eng_uzun_soz(MATN)!r}")
print("│")
print("│  Eng ko'p uchraydigan harflar:")
for harf, soni in harf_chastotasi(MATN):
    chiziq = "█" * soni
    print(f"│    {harf!r} {soni:>3}  {chiziq}")
print("└─")

text

┌─ MATN STATISTIKASI
│
│  Belgilar (jami)              238
│  Belgilar (bo'sh joysiz)      205
│  Harflar                      196
│  Raqamlar                       4
│  So'zlar                       34
│  Qatorlar                       4
│  Gaplar                         4
│  Baytlar (UTF-8)              240
│
│  Eng uzun so'z: 'ishlatiladigan'
│
│  Eng ko'p uchraydigan harflar:
│    'a'  24  ████████████████████████
│    'i'  22  ██████████████████████
│    'n'  16  ████████████████
│    'd'  15  ███████████████
│    'l'  15  ███████████████
└─

Diqqat: "Belgilar" 238, "Baytlar" 240. Farq — o' va boshqa maxsus belgilar UTF-8 da ko'proq joy egallaydi (2.9-bo'lim).

Kodda ko'rish kerak:

.splitlines() — qatorlarga bo'lish
.split() — so'zlarga bo'lish
.strip(".,!?;:") — tinish belgilarini tozalash
max(sozlar, key=len) — eng uzunini topish
sum(h.isdigit() for h in matn) — bool sanash (3.5-dars)
sorted(..., key=lambda x: -x[1]) — kamayish tartibida (7-qism)

Nima ko'rsatdi: 2.7 va 2.9-bo'limlar.

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

Noto'g'ri fikr	To'g'risi
"`matn[0] = 'X'` ishlaydi"	Satrlar o'zgarmas. Yangi satr yarating
"`matn.upper()` satrni o'zgartiradi"	Yo'q — yangi satr qaytaradi
"`'` va `"` farq qiladi"	Yo'q, bir xil. Faqat ichkaridagi tirnoq uchun tanlanadi
"`len(matn)` baytlar sonini beradi"	Belgilar sonini. Baytlar uchun `.encode()`
"Satrni siklda `+=` bilan qurish normal"	Sekin. `"".join()` ishlating
"`matn[10]` bo'sh satr qaytaradi"	`IndexError`. Kesim esa xavfsiz
"`"10" > "9"`"	`False`! Satrlar belgi-belgi solishtiriladi
"Alohida `char` turi bor"	Yo'q — bitta belgi ham `str`
"`join` ro'yxatda chaqiriladi"	Ajratgichda: `", ".join(royxat)`
"`find` topilmasa xato beradi"	`-1` qaytaradi. `index` esa `ValueError`

6. Keng tarqalgan xatolar va yechimlari

1. TypeError: 'str' object does not support item assignment

python

matn[0] = "X"                       # ❌
matn = "X" + matn[1:]               # ✅

2. TypeError: can only concatenate str (not "int") to str

python

print("Yosh: " + 25)                # ❌
print("Yosh: " + str(25))           # ✅
print(f"Yosh: {25}")                # ✅ eng yaxshi

3. SyntaxError — o'zbekcha apostrof

python

print('Bo'lim')                     # ❌
print("Bo'lim")                     # ✅
print('Bo\'lim')                    # ✅ ekranlash bilan

4. IndexError: string index out of range

python

matn = "abc"
print(matn[5])                      # ❌
print(matn[5:6])                    # ✅ '' — kesim xavfsiz
if len(matn) > 5:                   # ✅ tekshirish
    print(matn[5])

5. Metod natijasini saqlashni unutish

python

matn = "  salom  "
matn.strip()                        # ❌ natija yo'qoladi
print(repr(matn))                   # '  salom  '

matn = matn.strip()                 # ✅

6. \ bilan Windows yo'llari

python

yol = "C:\Users\new"                # ❌ \U va \n talqin qilinadi
yol = r"C:\Users\new"               # ✅ xom satr
yol = "C:/Users/new"                # ✅ Pythonda / ham ishlaydi
from pathlib import Path
yol = Path("C:/Users/new")          # ✅ eng yaxshi (15-qism)

7. split() va split(" ") farqi

python

matn = "a  b   c"
print(matn.split())                 # ['a', 'b', 'c']    ✅
print(matn.split(" "))              # ['a', '', 'b', '', '', 'c']  ⚠️

Argumentsiz split() ketma-ket bo'sh joylarni birlashtiradi.

8. Katta-kichik harf bilan solishtirish

python

if kiritilgan == "ha":              # ❌ "HA", "Ha" ishlamaydi
if kiritilgan.lower() == "ha":      # ✅
if kiritilgan.strip().lower() == "ha":  # ✅ eng ishonchli

7. Integratsiya — bu bilim qayerda kerak bo'ladi

3.9-dars: turlarni aylantirish — str(), int()
3.13-dars: print() va input(), formatlash to'liq
4-QISM (12 dars): satrlar chuqur — barcha metod, formatlash, Unicode, regex asoslari
5-qism: satr bo'yicha iteratsiya
6-qism: ro'yxat va satr o'rtasidagi aylantirish
16-qism: fayllar, kodlash, baytlar
15-qism: muntazam ifodalar
Deyarli har bir dasturda: satr — eng ko'p ishlatiladigan tur

8. Eng yaxshi amaliyotlar

O'zbekcha matnlarni qo'shtirnoqda yozing. "Bo'lim" — apostrof muammosi bo'lmaydi.
f-satrlarni ishlating. % va .format() — eskirgan.
Siklda += o'rniga join. Katta hajmda farq sezilarli.
Foydalanuvchi kiritmasini .strip() qiling. Har doim, istisnosiz.
Solishtirishda .lower() ishlating. kiritilgan.strip().lower() == "ha".
Metod natijasini saqlang. Satrlar o'zgarmas — matn.strip() o'zi hech narsa qilmaydi.
Windows yo'llari uchun r"..." yoki pathlib. Teskari chiziq muammosi yo'qoladi.
Indeks o'rniga kesim ishlating. Kesim chegaradan chiqmaydi.

9. Amaliy topshiriq

Vazifa 1: Kesimlar

python

matn = "Dasturlash"

Yozing (kesim bilan):

Birinchi 6 harf
Oxirgi 4 harf
Teskari
Har uchinchi harf
2-indeksdan 8-gacha
Birinchi va oxirgi harfsiz

Javoblar

python

matn[:6]        # 'Dastur'
matn[-4:]       # 'lash'
matn[::-1]      # 'halrutsaD'
matn[::3]       # 'Dtla'
matn[2:8]       # 'sturla'
matn[1:-1]      # 'asturlas'

Vazifa 2: O'zgarmaslik

python

matn = "salom"
matn.upper()
print(matn)

Nima chiqadi va nega?
'SALOM' chiqishi uchun nima o'zgartirish kerak?
matn[0] = "S" nima qiladi?

Vazifa 3: Metodlar mashqi

python

kirish = "   Salom, DUNYO!   "

Bosqichma-bosqich hosil qiling:

"Salom, DUNYO!" — bo'sh joysiz
"salom, dunyo!" — kichik harfda
"Salom, Dunyo!" — har so'z bosh harfda
"Salom, OLAM!" — DUNYO ni almashtiring
['Salom', 'DUNYO!'] — so'zlarga bo'ling

Javoblar

python

kirish.strip()
kirish.strip().lower()
kirish.strip().title()
kirish.strip().replace("DUNYO", "OLAM")
kirish.strip().split(", ")

Vazifa 4: Palindrom

palindrommi(matn) funksiyasini yozing. Palindrom — teskari o'qiganda ham bir xil.

Talablar:

Katta-kichik harfga e'tibor bermasin
Bo'sh joy va tinish belgilarini hisobga olmasin

Sinang: "radar", "Ana", "A man, a plan, a canal: Panama", "salom".

Yechim

python

def palindrommi(matn: str) -> bool:
    toza = "".join(h.lower() for h in matn if h.isalnum())
    return toza == toza[::-1]


for s in ["radar", "Ana", "A man, a plan, a canal: Panama", "salom"]:
    print(f"{s!r:<40} → {palindrommi(s)}")

Vazifa 5: So'zlarni sanash

Matn berilgan. Yozing:

Nechta so'z bor
Eng uzun so'z
Eng qisqa so'z
O'rtacha so'z uzunligi
Nechta noyob so'z bor (katta-kichik harfga e'tibor bermay)

Vazifa 6: Tozalash funksiyasi

normalizatsiya(matn) yozing:

Boshi va oxiridagi bo'sh joyni olib tashlasin
Ichkaridagi ketma-ket bo'sh joylarni bittaga aylantirsin
Har so'z bosh harfda bo'lsin
Tinish belgilaridan oldingi bo'sh joyni olib tashlasin

Sinang: " ali valiyev , toshkent " → "Ali Valiyev, Toshkent"

Vazifa 7: Unicode tajribasi

python

matnlar = ["salom", "салом", "你好", "O'zbekiston", "😊"]

for m in matnlar:
    print(f"{m!r:<20} belgilar: {len(m):>2}  baytlar: {len(m.encode('utf-8')):>2}")

Savollar:

Qaysi matnda belgilar va baytlar soni teng?
Nega kirilcha 2 barobar ko'p bayt oladi?
Emoji nechta bayt?

Javoblar

"salom" — faqat ASCII belgilar (1 bayt har biri)
UTF-8 da kirillitsa 2 baytda kodlanadi (ASCII — 1, kirillitsa/arab — 2, xitoy — 3, emoji — 4)
Emoji odatda 4 bayt

Bu — ma'lumotlar bazasida maydon uzunligini belgilashda muhim (2.9-bo'lim).

Nimani mustahkamlaydi: 2.3, 2.4, 2.5, 2.7, 2.9-bo'limlar.

Xulosa

Bu darsda satrlar bilan tanishdik.

Eng muhim uch fikr:

Satrlar o'zgarmas. matn[0] = "X" ishlamaydi. Barcha metod yangi satr qaytaradi — natijani saqlashni unutmang: matn = matn.strip().
Kesimlar kuchli va xavfsiz. matn[a:b:c] — indekslashdan farqli o'laroq chegaradan chiqmaydi. matn[::-1] — teskarilashning standart usuli.
len() belgilarni sanaydi, baytlarni emas. O'zbek, rus, xitoy matnlarida bu farq katta. Baytlar uchun .encode("utf-8").

Keyingi darsda type() va turlarni bilishni o'rganamiz: obyektning turini qanday aniqlash, isinstance() nima uchun type() dan yaxshi va nega Pythonda "o'rdak turlashi" degan tushuncha bor.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!

3.7-dars: str bilan tanishuv

1. Kirish va motivatsiya

2. Nazariya — chuqur tushuntirish

2.1. Satr yaratish

2.2. Ekranlash ketma-ketliklari

2.3. Satr — belgilar ketma-ketligi

2.4. Kesimlar (slicing)

2.5. Satrlar o'zgarmas (immutable)

2.6. Asosiy amallar

2.7. Eng ko'p ishlatiladigan metodlar

2.8. f-satrlar bilan tanishuv

2.9. Unicode va o'zbek tili

3. Tez ma'lumotnoma

4. Batafsil misollar

Misol 1 — Indekslash va kesimlar

Misol 2 — O'zgarmaslikni ko'rish

Misol 3 — Metodlar bilan matn tozalash

Misol 4 — Amaliy dastur: matn statistikasi

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

6. Keng tarqalgan xatolar va yechimlari

7. Integratsiya — bu bilim qayerda kerak bo'ladi

8. Eng yaxshi amaliyotlar

9. Amaliy topshiriq

Xulosa

Izohlar (0)

3.7-dars: `str` bilan tanishuv