Python kursi4.4-dars: Metodlar — o'zgartirish va tozalash
Python kursi · Satrlar chuqur

4.4-dars: Metodlar — o'zgartirish va tozalash

24 daqiqa4/12-dars

4-QISM — SATRLAR CHUQUR · 4-dars


1. Kirish va motivatsiya

Tashqi dunyodan kelgan matn deyarli hech qachon toza bo'lmaydi:

text
"  Ali   Valiyev  \n"           ortiqcha bo'sh joy
"ALI VALIYEV"                   noto'g'ri registr
"Ali\tValiyev"                  tabulyatsiya
"+998 90 123-45-67"             formatlangan telefon
"Ali Valiyev"              buzilmas bo'sh joy (nusxalashda)

Ma'lumotni saqlashdan yoki solishtirishdan oldin uni tozalash kerak. Aks holda:

python
kiritilgan = " ali "
saqlangan = "Ali"
print(kiritilgan == saqlangan)          # False — foydalanuvchi tushunmaydi

Bu darsda tozalash va o'zgartirishning barcha vositasini o'rganamiz:

  • strip oilasi — belgilar to'plami tuzog'i bilan
  • replace — va nima uchun u ba'zan yetarli emas
  • Registr metodlari — lower, upper, title, casefold
  • translate — eng tez ommaviy almashtirish
  • zfill, center, ljust, rjust — to'ldirish

Va eng muhimi: normalizatsiya quvuri — ma'lumotni ishonchli holatga keltirish tartibi.


2. Nazariya — chuqur tushuntirish

2.1. strip oilasi

python
matn = "  salom  "

print(repr(matn.strip()))       # 'salom'      — ikki tomondan
print(repr(matn.lstrip()))      # 'salom  '    — chapdan
print(repr(matn.rstrip()))      # '  salom'    — o'ngdan

Argumentsiz — barcha bo'shliq belgisini olib tashlaydi:

python
import string
print(repr(string.whitespace))  # ' \t\n\r\x0b\x0c'

matn = "\n\t  salom  \r\n"
print(repr(matn.strip()))       # 'salom'

Argument bilan — BELGILAR TO'PLAMI, pastki satr emas:

python
print("xxsalomxx".strip("x"))           # 'salom'
print("xyxsalomxyx".strip("xy"))        # 'salom'  — x va y ning istalgan kombinatsiyasi
print("python.py".strip(".py"))         # 'ython'  ← 'p' ham o'chdi!

Bu — 3-darsda ko'rgan tuzoq. strip(".py") = "., p, y belgilaridan birortasi bo'lsa olib tashla".

To'g'ri usul (Python 3.9+):

python
print("python.py".removesuffix(".py"))      # 'python'
print("test_fayl.py".removeprefix("test_")) # 'fayl.py'

3.9 gacha:

python
def removesuffix(matn: str, suffiks: str) -> str:
    if suffiks and matn.endswith(suffiks):
        return matn[:-len(suffiks)]
    return matn

if suffiks tekshiruvi muhim — bo'sh suffiks matn[:-0] = '' beradi (4.2-dars).

Amaliy misollar:

python
# Tinish belgilarini tozalash
print("Salom!!!".strip("!?."))              # 'Salom'
print("...Salom...".strip("."))             # 'Salom'

# Nol bilan to'ldirilgan sonlar
print("000123000".strip("0"))               # '123'
print("000123000".lstrip("0"))              # '123000'

# CSV qatoridan tirnoqlarni olib tashlash
print('"qiymat"'.strip('"'))                # 'qiymat'

2.2. Bo'shliq belgilarining turlari

Bu — kutilmagan muammolar manbai:

python
belgilar = {
    "bo'sh joy":            " ",
    "tabulyatsiya":         "\t",
    "yangi qator":          "\n",
    "karetka":              "\r",
    "vertikal tab":         "\v",
    "sahifa oxiri":         "\f",
    "buzilmas bo'sh joy":   " ",
    "nol kenglikdagi":      "​",
    "keng bo'sh joy":       " ",
}

print(f"{'Nom':<22} {'Kod':<10} {'strip()':>8} {'isspace()':>10}")
print("─" * 54)
for nom, b in belgilar.items():
    tozalandi = ("salom" + b).strip() == "salom"
    print(f"{nom:<22} U+{ord(b):04X}     {str(tozalandi):>8} {str(b.isspace()):>10}")
text
Nom                    Kod         strip()  isspace()
──────────────────────────────────────────────────────
bo'sh joy              U+0020         True       True
tabulyatsiya           U+0009         True       True
yangi qator            U+000A         True       True
karetka                U+000D         True       True
vertikal tab           U+000B         True       True
sahifa oxiri           U+000C         True       True
buzilmas bo'sh joy     U+00A0         True       True
nol kenglikdagi        U+200B        False      False
keng bo'sh joy         U+3000         True       True

​ (Zero Width Space) — strip() uni olib tashlamaydi va isspace() False beradi. Lekin u ko'zga ko'rinmaydi!

Bu belgi veb-saytdan nusxalashda tez-tez uchraydi va tushunarsiz muammolar keltiradi:

python
matn = "salom​"
print(repr(matn.strip()))       # 'salom​' — tozalanmadi
print(len(matn))                # 6, lekin ko'zga 5 ko'rinadi
print(matn == "salom")          # False!

Yechim:

python
NOKORINADIGAN = "​‌‍"

def toliq_tozala(matn: str) -> str:
    return matn.strip().strip(NOKORINADIGAN).strip()


print(repr(toliq_tozala("  salom​  ")))    # 'salom'

Buzilmas bo'sh joy ( ) — Word va veb-sahifalardan nusxalashda keladi. strip() uni tozalaydi, lekin ichkarida qolsa muammo:

python
matn = "Ali Valiyev"
print(matn.split())             # ['Ali', 'Valiyev'] — split tozalaydi
print(matn == "Ali Valiyev")    # False!
print(matn.replace(" ", " ") == "Ali Valiyev")     # True

2.3. Ichki bo'sh joylarni normallashtirish

Bu — eng ko'p ishlatiladigan idioma:

python
matn = "  Ali   \t Valiyev \n Toshkentdan  "

print(repr(" ".join(matn.split())))     # 'Ali Valiyev Toshkentdan'

Qanday ishlaydi?

  1. split() argumentsiz — har qanday bo'shliq bo'yicha bo'ladi va bo'sh elementlarni tashlaydi
  2. " ".join(...) — bitta bo'sh joy bilan birlashtiradi
python
print("  a   b  ".split())      # ['a', 'b']
print("  a   b  ".split(" "))   # ['', '', 'a', '', '', 'b', '', ''] — farq!

Bu idioma quyidagilarni hal qiladi:

  • Boshi va oxiridagi bo'sh joy
  • Ketma-ket bo'sh joylar
  • Tabulyatsiya va yangi qatorlar
  • Buzilmas bo'sh joy (  ham isspace() — split uni tanidi)
python
sinovlar = [
    "  salom  ",
    "salom\tdunyo",
    "salom\n\ndunyo",
    "salom     dunyo",
    "Ali Valiyev",
]

for s in sinovlar:
    print(f"  {s!r:<26} → {' '.join(s.split())!r}")
text
  '  salom  '                → 'salom'
  'salom\tdunyo'             → 'salom dunyo'
  'salom\n\ndunyo'           → 'salom dunyo'
  'salom     dunyo'          → 'salom dunyo'
  'Ali\xa0Valiyev'           → 'Ali Valiyev'

2.4. replace — almashtirish

python
matn = "salom dunyo, salom olam"

print(matn.replace("salom", "assalom"))         # ikkalasi ham
print(matn.replace("salom", "assalom", 1))      # faqat birinchisi
print(matn.replace("o", ""))                    # o'chirish

Xususiyatlari:

  • Yangi satr qaytaradi (satrlar o'zgarmas — 3.7-dars)
  • Topilmasa — xato yo'q, asl satr qaytadi
  • Zanjirlash mumkin
python
print("abc".replace("z", "x"))          # 'abc' — o'zgarmadi

# Zanjirlash
telefon = "+998 (90) 123-45-67"
toza = (telefon
        .replace("+", "")
        .replace(" ", "")
        .replace("(", "")
        .replace(")", "")
        .replace("-", ""))
print(toza)                             # '998901234567'

Zanjirlash tuzog'i — tartib muhim:

python
# ❌ Noto'g'ri natija
print("ab".replace("a", "b").replace("b", "a"))     # 'aa'
# 1-qadam: 'ab' → 'bb'
# 2-qadam: 'bb' → 'aa'

# ✅ translate bilan (2.7-bo'lim)
print("ab".translate(str.maketrans("ab", "ba")))    # 'ba'

Ko'p almashtirish uchun:

python
ALMASHTIRISHLAR = {
    "&": "&amp;",
    "<": "&lt;",
    ">": "&gt;",
}

matn = "a < b & c > d"

# Usul 1: sikl (tartib muhim!)
natija = matn
for eski, yangi in ALMASHTIRISHLAR.items():
    natija = natija.replace(eski, yangi)
print(natija)               # 'a &lt; b &amp; c &gt; d'

Bu yerda & birinchi almashtirilishi kerak — aks holda &lt; dagi & ham almashardi. Lug'atlar Python 3.7+ da tartibni saqlaydi (6-qism).

Xavfsizroq — translate:

python
jadval = str.maketrans({"&": "&amp;", "<": "&lt;", ">": "&gt;"})
print(matn.translate(jadval))           # tartib muammosi yo'q

Yoki tayyor kutubxona:

python
import html
print(html.escape("a < b & c > d"))     # 'a &lt; b &amp; c &gt; d'

2.5. Registr metodlari

python
matn = "salom DUNYO va olam"

print(matn.upper())         # 'SALOM DUNYO VA OLAM'
print(matn.lower())         # 'salom dunyo va olam'
print(matn.title())         # 'Salom Dunyo Va Olam'
print(matn.capitalize())    # 'Salom dunyo va olam'
print(matn.swapcase())      # 'SALOM dunyo VA OLAM'
print(matn.casefold())      # 'salom dunyo va olam'

Farqlar:

Metod Nima qiladi
upper() Hammasi katta
lower() Hammasi kichik
title() Har So'z Bosh Harfda
capitalize() Faqat birinchi harf katta, qolgani kichik
swapcase() Almashtiradi
casefold() Agressiv kichik (xalqaro solishtirish uchun)

title() tuzoqlari:

python
print("ali's kitobi".title())           # "Ali'S Kitobi"  ← 'S katta!
print("O'zbekiston".title())            # "O'Zbekiston"   ← noto'g'ri
print("ali-vali".title())               # 'Ali-Vali'      ← to'g'ri
print("MacDonald".title())              # 'Macdonald'     ← noto'g'ri

title() har bir harf bo'lmagan belgidan keyin bosh harf qo'yadi. O'zbek tilidagi apostrof uchun bu muammo.

To'g'ri usul:

python
def ism_formatla(matn: str) -> str:
    """Har so'zning birinchi harfini kattalashtiradi."""
    return " ".join(soz.capitalize() for soz in matn.split())


print(ism_formatla("ali valiyev"))          # 'Ali Valiyev'
print(ism_formatla("o'ktam karimov"))       # "O'ktam Karimov"  ✅
print("o'ktam karimov".title())             # "O'Ktam Karimov"  ❌

casefold() va lower() farqi:

python
print("STRASSE".lower())        # 'strasse'
print("STRASSE".casefold())     # 'strasse'

print("ß".lower())              # 'ß'
print("ß".casefold())           # 'ss'

print("İ".lower())              # 'i̇'  (turk katta I)
print("İ".casefold())           # 'i̇'

Qoida: solishtirish uchun casefold(), ko'rsatish uchun lower().

python
# ✅ Xalqaro matnni solishtirish
if a.casefold() == b.casefold():
    ...

Turk tili muammosi:

python
# Turk tilida i → İ (nuqtali katta I), I → ı (nuqtasiz kichik)
print("i".upper())              # 'I' — turkcha noto'g'ri

Python tildan xabardor emas. Til-spetsifik registr kerak bo'lsa — PyICU kutubxonasi.

2.6. To'ldirish metodlari

python
matn = "42"

print(matn.zfill(5))            # '00042'  — nol bilan
print(matn.rjust(5))            # '   42'  — o'ngga
print(matn.ljust(5))            # '42   '  — chapga
print(matn.center(5))           # ' 42  '  — markazga
print(matn.center(5, "*"))      # '*42**'
print(matn.rjust(5, "0"))       # '00042'

zfill — ishorani hisobga oladi:

python
print("-42".zfill(6))           # '-00042'  ← minus oldinda!
print("-42".rjust(6, "0"))      # '000-42'  ← noto'g'ri
print("+42".zfill(6))           # '+00042'

f-satr bilan bir xil (3.13-dars):

python
print(f"{42:05d}")              # '00042'
print(f"{'42':>5}")             # '   42'
print(f"{'42':*^5}")            # '*42**'

f-satr moslashuvchanroq, lekin metodlar dinamik kenglikda qulay:

python
kenglik = 10
print("abc".center(kenglik, "-"))
print(f"{'abc':-^{kenglik}}")   # bir xil

Amaliy foydalanish:

python
# Chek chizig'i
print("MENYU".center(40, "="))

# Raqamlarni tekislash
for i in [1, 42, 100, 5000]:
    print(f"  {str(i).rjust(6)}")

# Fayl raqamlash
for i in range(1, 4):
    print(f"fayl_{str(i).zfill(3)}.txt")    # fayl_001.txt

2.7. translate — eng tez almashtirish

translate bir belgini bir belgiga (yoki satrga, yoki hech narsaga) almashtiradi. Bir o'tishda.

python
# 1. str.maketrans lug'at bilan
jadval = str.maketrans({"a": "1", "b": "2", "c": None})
print("abcabc".translate(jadval))       # '1212' — c o'chdi

# 2. Ikki satr bilan (bir xil uzunlikda)
jadval = str.maketrans("abc", "123")
print("abcabc".translate(jadval))       # '123123'

# 3. Uchinchi argument — o'chiriladigan belgilar
jadval = str.maketrans("abc", "123", "xyz")
print("abcxyz".translate(jadval))       # '123'

Nega replace dan yaxshiroq?

python
# ❌ replace zanjiri — n marta o'tish, tartib muhim
matn.replace("a", "1").replace("b", "2").replace("c", "3")

# ✅ translate — BIR marta o'tish, tartib muammosi yo'q
matn.translate(str.maketrans("abc", "123"))

Klassik masala — almashtirish:

python
matn = "ab"

print(matn.replace("a", "b").replace("b", "a"))     # 'aa' ❌
print(matn.translate(str.maketrans("ab", "ba")))    # 'ba' ✅

Belgilarni o'chirish:

python
TINISH = ".,!?;:\"'()[]{}"

matn = "Salom, dunyo! Qalaysiz?"
print(matn.translate(str.maketrans("", "", TINISH)))
# 'Salom dunyo Qalaysiz'

Bu — tinish belgilarini olib tashlashning eng tez usuli.

Kirillcha ↔ lotincha translitteratsiya:

python
KIRIL = "абвгдеёжзийклмнопрстуфхцчшъыьэюя"
LOTIN = ["a","b","v","g","d","e","yo","j","z","i","y","k","l","m","n","o",
         "p","r","s","t","u","f","x","ts","ch","sh","'","i","'","e","yu","ya"]

jadval = {ord(k): l for k, l in zip(KIRIL, LOTIN)}
print("салом дунё".translate(jadval))       # 'salom dunyo'

translate bir belgini ko'p belgili satrga almashtira oladi — replace dan farqli o'laroq bir o'tishda.

Tezlik:

python
import time

matn = "abcdefghij" * 100_000
TINISH = "aeiou"

boshlandi = time.perf_counter()
natija = matn
for h in TINISH:
    natija = natija.replace(h, "")
vaqt_replace = time.perf_counter() - boshlandi

jadval = str.maketrans("", "", TINISH)
boshlandi = time.perf_counter()
natija = matn.translate(jadval)
vaqt_translate = time.perf_counter() - boshlandi

print(f"  replace ({len(TINISH)} marta): {vaqt_replace * 1000:>7.1f} ms")
print(f"  translate (1 marta):          {vaqt_translate * 1000:>7.1f} ms")
print(f"  Tezlik farqi: {vaqt_replace / vaqt_translate:.1f}x")

translate odatda 3-10 barobar tezroq.

2.8. expandtabs va boshqalar

python
matn = "a\tb\tc"

print(matn.expandtabs())        # 'a       b       c'  (8 ta sukut)
print(matn.expandtabs(4))       # 'a   b   c'
print(matn.expandtabs(2))       # 'a b c'

expandtabs tabulyatsiyani ustun chegarasigacha to'ldiradi, oddiy almashtirish emas:

python
print("ab\tc".expandtabs(4))    # 'ab  c'   — 2 ta bo'sh joy (4-ustungacha)
print("a\tc".expandtabs(4))     # 'a   c'   — 3 ta bo'sh joy
print("ab\tc".replace("\t", " " * 4))       # 'ab    c' — har doim 4 ta

Kod ko'rsatishda foydali:

python
kod = "def f():\n\treturn 1"
print(kod.expandtabs(4))

2.9. Normalizatsiya quvuri

Amaliyotda tozalash bir necha bosqichda bo'ladi. Tartib muhim:

python
import unicodedata

NOKORINADIGAN = "​‌‍⁠"


def normalizatsiya(matn: str, registr: bool = True) -> str:
    """Matnni solishtirish va saqlash uchun normallashtiradi.

    Bosqichlar:
      1. Unicode NFC normalizatsiya (é → bitta belgi)
      2. Ko'rinmas belgilarni olib tashlash
      3. Bo'shliqlarni normallashtirish
      4. Registrni tushirish (ixtiyoriy)
    """
    # 1. Unicode
    matn = unicodedata.normalize("NFC", matn)

    # 2. Ko'rinmas belgilar
    matn = matn.translate(str.maketrans("", "", NOKORINADIGAN))

    # 3. Bo'shliqlar
    matn = " ".join(matn.split())

    # 4. Registr
    if registr:
        matn = matn.casefold()

    return matn


sinovlar = [
    "  Ali   Valiyev  ",
    "ALI\tVALIYEV",
    "Ali Valiyev",
    "Ali​Valiyev",
    "José",              # NFC
    "José",        # NFD
]

for s in sinovlar:
    print(f"  {s!r:<24} → {normalizatsiya(s)!r}")
text
  '  Ali   Valiyev  '     → 'ali valiyev'
  'ALI\tVALIYEV'          → 'ali valiyev'
  'Ali\xa0Valiyev'        → 'ali valiyev'
  'Ali​Valiyev'      → 'alivaliyev'
  'José'                  → 'josé'
  'José'                  → 'josé'

Diqqat: ​ olib tashlanganda so'zlar birlashib ketdi. Bu — to'g'ri xatti-harakat, chunki nol kenglikdagi bo'sh joy ajratgich emas.

Ikki daraja normalizatsiya:

Daraja Maqsad Registr
Saqlash uchun Ma'lumotni toza saqlash Saqlanadi
Solishtirish uchun Qidiruv, takrorni topish Tushiriladi
python
# Ma'lumotlar bazasiga
ism = normalizatsiya(kiritilgan, registr=False)      # 'Ali Valiyev'

# Qidiruv indeksiga
qidiruv_kaliti = normalizatsiya(kiritilgan)          # 'ali valiyev'

3. Tez ma'lumotnoma

Tozalash

python
matn.strip()                bo'shliqni ikki tomondan
matn.strip("xy")            BELGILAR TO'PLAMI (pastki satr emas!)
matn.lstrip()  matn.rstrip()
matn.removeprefix(x)        3.9+ — pastki satr
matn.removesuffix(x)        3.9+
" ".join(matn.split())      ⭐ ichki bo'shliqlarni normallashtirish

Almashtirish

python
matn.replace(eski, yangi)
matn.replace(eski, yangi, n)        faqat n marta
matn.translate(jadval)              ⭐ eng tez, bir o'tish

str.maketrans({"a": "1"})
str.maketrans("abc", "123")
str.maketrans("", "", "o'chiriladigan")

Registr

python
upper() lower() title() capitalize() swapcase() casefold()

⚠️ title() apostrofda buziladi → " ".join(s.capitalize() for s in matn.split())
✅ Solishtirish uchun casefold(), ko'rsatish uchun lower()

To'ldirish

python
zfill(n)        nol bilan (ishorani hisobga oladi)
rjust(n, c)  ljust(n, c)  center(n, c)
expandtabs(n)   tab → bo'sh joy (ustun chegarasigacha)

Tuzoqlar

python
"python.py".strip(".py")            → 'ython'  (belgilar to'plami)
"ab".replace("a","b").replace("b","a") → 'aa'  (tartib)
"o'ktam".title()                    → "O'Ktam"
"salom​".strip()               → tozalanmaydi

4. Batafsil misollar

Misol 1 — strip tuzoqlari

python
"""strip belgilar to'plami bilan ishlaydi."""

print("=== Argumentsiz — bo'shliq belgilari ===")
namunalar = ["  salom  ", "\tsalom\n", "\r\n salom \r\n"]
for s in namunalar:
    print(f"  {s!r:<22} → {s.strip()!r}")

print("\n=== Argument bilan — BELGILAR TO'PLAMI ===")
sinovlar = [
    ("xxsalomxx", "x", "faqat x"),
    ("xyxsalomxyx", "xy", "x va y kombinatsiyasi"),
    ("python.py", ".py", "❌ p ham o'chdi"),
    ("test_py.py", ".py", "❌ oxirgi py ham"),
    ("000123000", "0", "nollarni tozalash"),
    ("...Salom!!!", ".!", "tinish belgilari"),
    ('"qiymat"', '"', "tirnoqlar"),
]
for matn, belgilar, izoh in sinovlar:
    print(f"  {matn!r:<16}.strip({belgilar!r:<6}) → {matn.strip(belgilar)!r:<12} {izoh}")

print("\n=== ✅ To'g'ri usul: removeprefix/removesuffix ===")
for matn in ["python.py", "test_py.py", "yolboshchi.py"]:
    print(f"  {matn!r:<18} → {matn.removesuffix('.py')!r}")

print("\n=== 3.9 gacha bo'lgan usul ===")


def suffiksni_olib_tashla(matn: str, suffiks: str) -> str:
    if suffiks and matn.endswith(suffiks):
        return matn[:-len(suffiks)]
    return matn


for matn in ["python.py", "hujjat.txt"]:
    print(f"  {matn!r:<16} → {suffiksni_olib_tashla(matn, '.py')!r}")

print("\n  ⚠️ Bo'sh suffiks tuzog'i:")
print(f"    matn[:-0] → {'python'[:-0]!r}  ← bo'sh!")
print(f"    Shuning uchun `if suffiks` tekshiruvi kerak")

print("\n=== Ko'rinmas belgilar ===")
xavfli = [
    ("salom​", "nol kenglikdagi bo'sh joy"),
    ("salom ", "buzilmas bo'sh joy"),
    ("salom", "BOM belgisi"),
]
for matn, izoh in xavfli:
    tozalandi = matn.strip()
    holat = "✅ tozalandi" if tozalandi == "salom" else "❌ QOLDI"
    print(f"  {izoh:<26} strip() → {holat}")

print("\n  Yechim:")
NOKORINADIGAN = "​‌‍⁠"
for matn, izoh in xavfli:
    toza = matn.strip().strip(NOKORINADIGAN).strip()
    print(f"    {izoh:<26} → {toza!r}")
text
=== Argumentsiz — bo'shliq belgilari ===
  '  salom  '            → 'salom'
  '\tsalom\n'            → 'salom'
  '\r\n salom \r\n'      → 'salom'

=== Argument bilan — BELGILAR TO'PLAMI ===
  'xxsalomxx'     .strip('x'   ) → 'salom'      faqat x
  'xyxsalomxyx'   .strip('xy'  ) → 'salom'      x va y kombinatsiyasi
  'python.py'     .strip('.py' ) → 'ython'      ❌ p ham o'chdi
  'test_py.py'    .strip('.py' ) → 'test_'      ❌ oxirgi py ham
  '000123000'     .strip('0'   ) → '123'        nollarni tozalash
  '...Salom!!!'   .strip('.!'  ) → 'Salom'      tinish belgilari
  '"qiymat"'      .strip('"'   ) → 'qiymat'     tirnoqlar

=== ✅ To'g'ri usul: removeprefix/removesuffix ===
  'python.py'        → 'python'
  'test_py.py'       → 'test_py'
  'yolboshchi.py'    → 'yolboshchi'

=== Ko'rinmas belgilar ===
  nol kenglikdagi bo'sh joy  strip() → ❌ QOLDI
  buzilmas bo'sh joy         strip() → ✅ tozalandi
  BOM belgisi                strip() → ❌ QOLDI

  Yechim:
    nol kenglikdagi bo'sh joy  → 'salom'
    buzilmas bo'sh joy         → 'salom'
    BOM belgisi                → 'salom'

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

Misol 2 — replace va translate solishtiruvi

python
"""Ikki almashtirish usulining farqi va tezligi."""

import time

print("=== 1. Tartib muammosi ===")
matn = "ab"
print(f"  Asl: {matn!r}, maqsad: 'ba' (a↔b almashtirish)")
print(f"  replace zanjiri: "
      f"{matn.replace('a', 'b').replace('b', 'a')!r}  ❌")
print(f"  translate:       "
      f"{matn.translate(str.maketrans('ab', 'ba'))!r}  ✅")

print("\n=== 2. HTML ekranlash ===")
matn = "a < b & c > d"
ALMASHTIRISHLAR = {"&": "&amp;", "<": "&lt;", ">": "&gt;"}

# replace — tartib MUHIM
natija = matn
for eski, yangi in ALMASHTIRISHLAR.items():
    natija = natija.replace(eski, yangi)
print(f"  replace (& birinchi):  {natija!r}")

# Noto'g'ri tartib
natija = matn
for eski, yangi in reversed(list(ALMASHTIRISHLAR.items())):
    natija = natija.replace(eski, yangi)
print(f"  replace (& oxirgi):    {natija!r}  ❌ ikki karra ekranlangan")

# translate — tartib muammosi YO'Q
print(f"  translate:             "
      f"{matn.translate(str.maketrans(ALMASHTIRISHLAR))!r}  ✅")

import html
print(f"  html.escape:           {html.escape(matn)!r}  ✅ tayyor yechim")

print("\n=== 3. Tinish belgilarini o'chirish ===")
TINISH = ".,!?;:\"'()[]{}"
matn = "Salom, dunyo! Qalaysiz? (yaxshi)"

# replace bilan — 15 marta o'tish
natija = matn
for b in TINISH:
    natija = natija.replace(b, "")
print(f"  replace:   {natija!r}")

# translate bilan — 1 marta
print(f"  translate: {matn.translate(str.maketrans('', '', TINISH))!r}")

print("\n=== 4. Bir belgini ko'p belgiga ===")
KIRIL = "абвгдеёжзийклмнопрстуфхцчшъыьэюя"
LOTIN = ["a","b","v","g","d","e","yo","j","z","i","y","k","l","m","n","o",
         "p","r","s","t","u","f","x","ts","ch","sh","'","i","'","e","yu","ya"]

jadval = {ord(k): l for k, l in zip(KIRIL, LOTIN)}
for matn in ["салом дунё", "мен ўзбекман", "яхши"]:
    print(f"  {matn:<16} → {matn.translate(jadval)}")

print("\n=== 5. Tezlik solishtiruvi ===")
katta = "abcdefghij" * 200_000
UNLILAR = "aeiou"

boshlandi = time.perf_counter()
natija = katta
for h in UNLILAR:
    natija = natija.replace(h, "")
vaqt_replace = time.perf_counter() - boshlandi

jadval = str.maketrans("", "", UNLILAR)
boshlandi = time.perf_counter()
natija = katta.translate(jadval)
vaqt_translate = time.perf_counter() - boshlandi

print(f"  Matn hajmi: {len(katta):,} belgi")
print(f"  replace ({len(UNLILAR)} marta o'tish): {vaqt_replace * 1000:>8.1f} ms")
print(f"  translate (1 marta):           {vaqt_translate * 1000:>8.1f} ms")
print(f"  Tezlik farqi:                  {vaqt_replace / vaqt_translate:>8.1f}x")
text
=== 1. Tartib muammosi ===
  Asl: 'ab', maqsad: 'ba' (a↔b almashtirish)
  replace zanjiri: 'aa'  ❌
  translate:       'ba'  ✅

=== 2. HTML ekranlash ===
  replace (& birinchi):  'a &lt; b &amp; c &gt; d'
  replace (& oxirgi):    'a &amp;lt; b &amp; c &amp;gt; d'  ❌ ikki karra
  translate:             'a &lt; b &amp; c &gt; d'  ✅
  html.escape:           'a &lt; b &amp; c &gt; d'  ✅ tayyor yechim

=== 4. Bir belgini ko'p belgiga ===
  салом дунё       → salom dunyo
  мен ўзбекман     → men ўzbekman
  яхши             → yaxshi

=== 5. Tezlik solishtiruvi ===
  Matn hajmi: 2,000,000 belgi
  replace (5 marta o'tish):    412.7 ms
  translate (1 marta):          58.3 ms
  Tezlik farqi:                  7.1x

Eslatma: 4-misolda ў almashtirilmadi — u KIRIL ro'yxatida yo'q. To'liq o'zbek kirillitsasi uchun ў, қ, ғ, ҳ ni ham qo'shish kerak.

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

Misol 3 — Registr metodlari va title tuzog'i

python
"""Registr o'zgartirishning barcha varianti."""

print("=== Asosiy metodlar ===")
matn = "salom DUNYO va olam"
metodlar = [
    ("upper", matn.upper()),
    ("lower", matn.lower()),
    ("title", matn.title()),
    ("capitalize", matn.capitalize()),
    ("swapcase", matn.swapcase()),
    ("casefold", matn.casefold()),
]
print(f"  Asl: {matn!r}\n")
for nom, natija in metodlar:
    print(f"  {nom:<12} → {natija!r}")

print("\n=== ⚠️ title() tuzoqlari ===")
sinovlar = [
    ("ali valiyev", "oddiy"),
    ("o'ktam karimov", "apostrof"),
    ("ali's kitobi", "egalik"),
    ("MacDonald", "ichki katta harf"),
    ("ali-vali", "chiziqcha"),
    ("3-dars", "raqam"),
]


def ism_formatla(matn: str) -> str:
    """Har so'zning birinchi harfini kattalashtiradi."""
    return " ".join(soz.capitalize() for soz in matn.split())


print(f"  {'Asl':<18} {'title()':<20} {'ism_formatla()'}")
print("  " + "─" * 60)
for matn, izoh in sinovlar:
    t = matn.title()
    f = ism_formatla(matn)
    belgi = "  ⚠️" if t != f else ""
    print(f"  {matn!r:<18} {t!r:<20} {f!r}{belgi}")

print("\n=== casefold vs lower ===")
namunalar = ["STRASSE", "ß", "İ", "SALOM", "ΣΊΣΥΦΟΣ"]
print(f"  {'Asl':<12} {'lower()':<14} {'casefold()':<14} {'Farq'}")
print("  " + "─" * 50)
for m in namunalar:
    lo = m.lower()
    cf = m.casefold()
    farq = "⚠️ ha" if lo != cf else "yo'q"
    print(f"  {m!r:<12} {lo!r:<14} {cf!r:<14} {farq}")

print("\n=== Solishtirishda farq ===")
juftliklar = [("STRASSE", "strasse"), ("STRASSE", "straße"), ("Salom", "salom")]
for a, b in juftliklar:
    print(f"  {a!r:<12} == {b!r:<12}")
    print(f"    ==              → {a == b}")
    print(f"    lower()         → {a.lower() == b.lower()}")
    print(f"    casefold()      → {a.casefold() == b.casefold()}")

print("\n=== Amaliy: ismlarni formatlash ===")
xom_ismlar = [
    "  ALI   VALIYEV  ",
    "o'ktam\tkarimov",
    "AZIZA karimova",
    "sarvarbek  abdullayev",
]
for xom in xom_ismlar:
    toza = ism_formatla(" ".join(xom.split()))
    print(f"  {xom!r:<26} → {toza!r}")
text
=== Asosiy metodlar ===
  Asl: 'salom DUNYO va olam'

  upper        → 'SALOM DUNYO VA OLAM'
  lower        → 'salom dunyo va olam'
  title        → 'Salom Dunyo Va Olam'
  capitalize   → 'Salom dunyo va olam'
  swapcase     → 'SALOM dunyo VA OLAM'
  casefold     → 'salom dunyo va olam'

=== ⚠️ title() tuzoqlari ===
  Asl                title()              ism_formatla()
  ────────────────────────────────────────────────────────────
  'ali valiyev'      'Ali Valiyev'        'Ali Valiyev'
  "o'ktam karimov"   "O'Ktam Karimov"     "O'ktam Karimov"  ⚠️
  "ali's kitobi"     "Ali'S Kitobi"       "Ali's Kitobi"  ⚠️
  'MacDonald'        'Macdonald'          'Macdonald'
  'ali-vali'         'Ali-Vali'           'Ali-vali'  ⚠️
  '3-dars'           '3-Dars'             '3-dars'  ⚠️

=== casefold vs lower ===
  Asl          lower()        casefold()     Farq
  ──────────────────────────────────────────────────
  'STRASSE'    'strasse'      'strasse'      yo'q
  'ß'          'ß'            'ss'           ⚠️ ha
  'İ'          'i̇'            'i̇'            yo'q
  'SALOM'      'salom'        'salom'        yo'q
  'ΣΊΣΥΦΟΣ'    'σίσυφος'      'σίσυφοσ'      ⚠️ ha

=== Solishtirishda farq ===
  'STRASSE'    == 'strasse'
    ==              → False
    lower()         → True
    casefold()      → True
  'STRASSE'    == 'straße'
    ==              → False
    lower()         → False
    casefold()      → True   ← faqat casefold topdi

Diqqat: 'ali-vali' uchun title() 'Ali-Vali' beradi, ism_formatla esa 'Ali-vali'. Qaysi biri to'g'ri — kontekstga bog'liq. Ism uchun title() yaxshiroq, oddiy matn uchun capitalize.

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — To'liq normalizatsiya quvuri

python
"""Foydalanuvchi ma'lumotini ishonchli tozalash."""

import unicodedata
from dataclasses import dataclass

NOKORINADIGAN = "​‌‍⁠᠎"
TINISH_TELEFON = " ()-+."


def tozala(matn: str) -> str:
    """1-daraja: ko'rinmas belgilar va bo'shliqlar."""
    matn = unicodedata.normalize("NFC", matn)
    matn = matn.translate(str.maketrans("", "", NOKORINADIGAN))
    return " ".join(matn.split())


def solishtirish_uchun(matn: str) -> str:
    """2-daraja: qidiruv va takrorni topish uchun."""
    return tozala(matn).casefold()


def ism_formatla(matn: str) -> str:
    """Ismni ko'rsatish uchun formatlaydi."""
    toza = tozala(matn)
    return " ".join(soz.capitalize() for soz in toza.split())


def telefon_tozala(matn: str) -> str:
    """Telefon raqamidan faqat raqamlarni qoldiradi."""
    toza = tozala(matn)
    faqat_raqam = "".join(h for h in toza if h.isdecimal())
    return faqat_raqam


def telefon_formatla(raqam: str) -> str:
    """998901234567 → +998 90 123-45-67"""
    r = telefon_tozala(raqam)
    if len(r) == 12 and r.startswith("998"):
        return f"+{r[:3]} {r[3:5]} {r[5:8]}-{r[8:10]}-{r[10:]}"
    if len(r) == 9:
        return f"+998 {r[:2]} {r[2:5]}-{r[5:7]}-{r[7:]}"
    return raqam


def email_tozala(matn: str) -> str:
    """Email ni normallashtiradi."""
    toza = tozala(matn).casefold()
    if "@" not in toza:
        return toza
    nom, _, domen = toza.partition("@")
    # Gmail nuqtalarni e'tiborsiz qoldiradi
    if domen in {"gmail.com", "googlemail.com"}:
        nom = nom.replace(".", "").partition("+")[0]
        domen = "gmail.com"
    return f"{nom}@{domen}"


@dataclass
class Foydalanuvchi:
    ism: str
    email: str
    telefon: str

    @classmethod
    def yarat(cls, ism: str, email: str, telefon: str) -> "Foydalanuvchi":
        return cls(
            ism=ism_formatla(ism),
            email=email_tozala(email),
            telefon=telefon_formatla(telefon),
        )

    @property
    def qidiruv_kaliti(self) -> str:
        return solishtirish_uchun(self.ism)


XOM_MALUMOT = [
    ("  ALI   VALIYEV  ", "  ALI.VALIYEV+spam@Gmail.COM ", "+998 (90) 123-45-67"),
    ("o'ktam\tkarimov", "oktam@MAIL.RU", "998 91 234 56 78"),
    ("aziza​karimova", "aziza.k@gmail.com", "935556677"),
    ("Ali Valiyev", "alivaliyev@gmail.com", "90 123 45 67"),
]

print("┌─ FOYDALANUVCHILARNI TOZALASH")
print("│")

foydalanuvchilar = []
for xom_ism, xom_email, xom_tel in XOM_MALUMOT:
    f = Foydalanuvchi.yarat(xom_ism, xom_email, xom_tel)
    foydalanuvchilar.append(f)

    print(f"│  Xom:")
    print(f"│    ism:     {xom_ism!r}")
    print(f"│    email:   {xom_email!r}")
    print(f"│    telefon: {xom_tel!r}")
    print(f"│  Toza:")
    print(f"│    ism:     {f.ism!r}")
    print(f"│    email:   {f.email!r}")
    print(f"│    telefon: {f.telefon!r}")
    print(f"│    kalit:   {f.qidiruv_kaliti!r}")
    print("│")

print("└─")

print("\n=== Takrorlarni topish ===")
from collections import Counter

kalitlar = Counter(f.qidiruv_kaliti for f in foydalanuvchilar)
emaillar = Counter(f.email for f in foydalanuvchilar)

print("  Ism bo'yicha takrorlar:")
for kalit, soni in kalitlar.items():
    if soni > 1:
        print(f"    {kalit!r} — {soni} marta")

print("  Email bo'yicha takrorlar:")
for email, soni in emaillar.items():
    if soni > 1:
        print(f"    {email!r} — {soni} marta")

print("""
Xulosa: normalizatsiyasiz bu takrorlar topilmasdi.
  '  ALI   VALIYEV  ' va 'Ali\\u00a0Valiyev' — turli satrlar
  'ALI.VALIYEV+spam@Gmail.COM' va 'alivaliyev@gmail.com' — bir xil pochta
""")
text
┌─ FOYDALANUVCHILARNI TOZALASH
│
│  Xom:
│    ism:     '  ALI   VALIYEV  '
│    email:   '  ALI.VALIYEV+spam@Gmail.COM '
│    telefon: '+998 (90) 123-45-67'
│  Toza:
│    ism:     'Ali Valiyev'
│    email:   'alivaliyev@gmail.com'
│    telefon: '+998 90 123-45-67'
│    kalit:   'ali valiyev'
│
...
└─

=== Takrorlarni topish ===
  Ism bo'yicha takrorlar:
    'ali valiyev' — 2 marta
  Email bo'yicha takrorlar:
    'alivaliyev@gmail.com' — 2 marta

Xulosa: normalizatsiyasiz bu takrorlar topilmasdi.

Kodda ko'rish kerak:

  • Ikki daraja normalizatsiya: saqlash va solishtirish uchun (2.9-bo'lim)
  • unicodedata.normalize("NFC", ...) — birinchi bosqich (4.1-dars)
  • translate bilan ko'rinmas belgilarni o'chirish (2.7-bo'lim)
  • " ".join(matn.split()) — bo'shliqlarni normallashtirish (2.3-bo'lim)
  • partition("@") — email ni bo'lish (5-darsda batafsil)
  • Gmail qoidasi — real dunyodagi biznes mantiq

Nima ko'rsatdi: butun dars — 2.1'dan 2.9'gacha.


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

Noto'g'ri fikr To'g'risi
"strip("abc") "abc" pastki satrini olib tashlaydi" Belgilar to'plami. a, b, c ning istalgan kombinatsiyasi
"strip() barcha ko'rinmas belgini tozalaydi" ​ va  ni tozalamaydi
"replace zanjiri xavfsiz" Tartib muhim. translate ishonchliroq
"title() ismlar uchun to'g'ri" Apostrofda buziladi: "O'Ktam"
"lower() solishtirish uchun yetarli" casefold() xalqaro matnda to'g'riroq
"replace asl satrni o'zgartiradi" Yangi satr qaytaradi (o'zgarmas)
"zfill va rjust("0") bir xil" zfill ishorani hisobga oladi
"expandtabs(4) \t ni 4 bo'sh joyga almashtiradi" Ustun chegarasigacha to'ldiradi

6. Keng tarqalgan xatolar va yechimlari

1. strip bilan suffiks olib tashlash

python
"python.py".strip(".py")                # ❌ 'ython'
"python.py".removesuffix(".py")         # ✅ 'python'

2. replace natijasini saqlamaslik

python
matn.replace("a", "b")                  # ❌ natija yo'qoladi
matn = matn.replace("a", "b")           # ✅

Satrlar o'zgarmas (3.7-dars).

3. Almashtirishda tartib

python
matn.replace("a", "b").replace("b", "c")            # ❌ a ham c bo'ladi
matn.translate(str.maketrans("ab", "bc"))           # ✅

4. Ko'rinmas belgilar

python
if kirish.strip() == "ha":              # ❌ ​ qolishi mumkin
if tozala(kirish) == "ha":              # ✅ (2.9-bo'lim)

5. title() ni ismlar uchun

python
"o'ktam".title()                        # ❌ "O'Ktam"
" ".join(s.capitalize() for s in "o'ktam".split())  # ✅ "O'ktam"

6. Bo'sh suffiks bilan matn[:-len(x)]

python
suffiks = ""
matn[:-len(suffiks)]                    # ❌ '' — chunki matn[:-0]
if suffiks:                             # ✅ tekshiring
    matn = matn[:-len(suffiks)]

7. split(" ") va split() ni adashtirish

python
"  a   b  ".split(" ")                  # ['', '', 'a', '', '', 'b', '', '']
"  a   b  ".split()                     # ['a', 'b']  ✅

8. Registrsiz solishtirishni unutish

python
if kirish == "ha":                      # ❌ "Ha", "HA" ishlamaydi
if kirish.strip().casefold() == "ha":   # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 4.5-dars: split/join — " ".join(matn.split()) idiomasi
  • 4.8-dars: Unicode normalizatsiya chuqur
  • 9-qism: foydalanuvchi kiritmasini tasdiqlash
  • 16-qism: fayl o'qishda BOM va qator oxiri belgilarini tozalash
  • 15-qism: re.sub() — murakkab almashtirish
  • 20-qism: veb-formalar, XSS himoyasi (html.escape)
  • 23-qism: ma'lumotlar bazasiga yozishdan oldin normalizatsiya
  • 24-qism: ma'lumot tahlili — matn ustunlarini tozalash

8. Eng yaxshi amaliyotlar

  1. " ".join(matn.split()) — universal tozalash. Boshi, oxiri va ichki ortiqcha bo'shliqlarni bir vaqtda hal qiladi.

  2. strip() o'rniga removeprefix/removesuffix. Belgilar to'plami tuzog'idan qutuling.

  3. Ko'p almashtirish uchun translate. Tezroq va tartib muammosi yo'q.

  4. Solishtirish uchun casefold(). lower() — faqat ko'rsatish uchun.

  5. title() o'rniga capitalize() zanjiri. Apostrofli so'zlarda to'g'ri ishlaydi.

  6. Ikki daraja normalizatsiya qiling. Saqlash uchun bir xil, solishtirish uchun boshqa.

  7. Ko'rinmas belgilarni alohida tozalang. strip() ularni ushlamaydi.

  8. Tayyor kutubxonalarni ishlating. html.escape, unicodedata.normalize, pathlib — o'zingiz yozishdan yaxshiroq.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
1.  "  salom  ".strip()
2.  "xxsalomxx".strip("x")
3.  "python.py".strip(".py")
4.  "banana".strip("ban")
5.  "ab".replace("a","b").replace("b","a")
6.  "aaa".replace("aa", "b")
7.  "o'ktam".title()
8.  "-42".zfill(6)
9.  "-42".rjust(6, "0")
10. "ab\tc".expandtabs(4)
11. " ".join("  a   b  ".split())
12. "ß".casefold()
Javoblar
  1. 'salom'
  2. 'salom'
  3. 'thon' — strip qo'shimchani emas, belgilar to'plamini (., p, y) ikki chetdan olib tashlaydi: boshidan p, y, oxiridan y, p, .
  4. '' — hamma belgi b, a, n dan iborat!
  5. 'aa'
  6. 'ba' — birinchi aa almashdi, a qoldi
  7. "O'Ktam"
  8. '-00042'
  9. '000-42'
  10. 'ab c'
  11. 'a b'
  12. 'ss'

Vazifa 2: Tozalash funksiyasi

toza(matn) funksiyasini yozing:

  • Boshi va oxiridagi bo'shliqni olib tashlasin
  • Ichki ketma-ket bo'shliqlarni bittaga aylantirsin
  • Ko'rinmas belgilarni (​, ) o'chirsin
  • NFC normalizatsiya qilsin

Sinang barcha xavfli belgi bilan.

Vazifa 3: Telefon formatlash

telefon(raqam) funksiyasini yozing. Quyidagilarni bir formatga keltirsin:

text
"+998 90 123-45-67"     →  +998 90 123-45-67
"998901234567"          →  +998 90 123-45-67
"90 123 45 67"          →  +998 90 123-45-67
"(90) 123-45-67"        →  +998 90 123-45-67
"+998(90)1234567"       →  +998 90 123-45-67
"12345"                 →  noto'g'ri format

Vazifa 4: translate bilan translitteratsiya

To'liq o'zbek kirillcha → lotincha jadval tuzing. Diqqat: ў, қ, ғ, ҳ, ц, щ.

Sinang: "Ўзбекистон Республикаси".

Vazifa 5: HTML ekranlash

html.escape ni o'zingiz yozing:

  • & → &amp; (birinchi!)
  • < → &lt;
  • > → &gt;
  • " → &quot;
  • ' → &#x27;

Ikki usulda: replace zanjiri va translate. Natijalarni solishtiring.

Vazifa 6: Ism formatlash

ism_formatla(matn) ni yozing va sinang:

text
"  ALI   VALIYEV  "     →  "Ali Valiyev"
"o'ktam karimov"        →  "O'ktam Karimov"
"ali-vali toshmatov"    →  ?
"MacDonald"             →  ?

Chiziqchali familiyalar uchun qanday qaror qabul qilasiz?

Vazifa 7: O'ylash

Nega "banana".strip("ban") bo'sh satr qaytaradi?

Javob

strip("ban") = "b, a, yoki n belgilaridan biri bo'lsa, ikkala tomondan olib tashla".

"banana" — barcha belgisi b, a, n to'plamidan:

text
banana
^      'b' — to'plamda bor, olib tashlanadi
 ^     'a' — bor, olib tashlanadi
  ^    'n' — bor
   ... barcha belgi olib tashlanadi

Natija — bo'sh satr.

Bu — strip ning belgilar to'plami bilan ishlashining eng aniq namoyishi. Prefiks/suffiks olib tashlash uchun hech qachon strip ishlatmang.

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


Xulosa

Bu darsda o'zgartirish va tozalash metodlarini o'rgandik.

Eng muhim uch fikr:

  1. strip(x) belgilar to'plami bilan ishlaydi, pastki satr bilan emas. "banana".strip("ban") bo'sh satr beradi. Prefiks/suffiks uchun removeprefix/removesuffix.

  2. " ".join(matn.split()) — universal tozalash idiomasi. Boshi, oxiri va ichki ortiqcha bo'shliqlarni bir vaqtda normallashtiradi, hatto buzilmas bo'sh joyni ham.

  3. Ko'p almashtirish uchun translate. replace zanjiri tartibga bog'liq va sekinroq. translate bir o'tishda ishlaydi va oraliq natijalarni qayta almashtirmaydi.

Keyingi darsda bo'lish va birlashtirish metodlarini o'rganamiz: split, rsplit, splitlines, partition va join — hamda ular bilan bog'liq eng ko'p uchraydigan xatolar.

Satrlar chuqur · 4-dars yakunlandi

4.4-dars: Metodlar — o'zgartirish va tozalash

24 daqvaqt
0belgi
Keyingi dars: 4.5-dars: Metodlar — bo'lish va birlashtirish
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0