4.4-dars: Metodlar — o'zgartirish va tozalash
4-QISM — SATRLAR CHUQUR · 4-dars
1. Kirish va motivatsiya
Tashqi dunyodan kelgan matn deyarli hech qachon toza bo'lmaydi:
" 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:
kiritilgan = " ali "
saqlangan = "Ali"
print(kiritilgan == saqlangan) # False — foydalanuvchi tushunmaydiBu darsda tozalash va o'zgartirishning barcha vositasini o'rganamiz:
stripoilasi — belgilar to'plami tuzog'i bilanreplace— va nima uchun u ba'zan yetarli emas- Registr metodlari —
lower,upper,title,casefold translate— eng tez ommaviy almashtirishzfill,center,ljust,rjust— to'ldirish
Va eng muhimi: normalizatsiya quvuri — ma'lumotni ishonchli holatga keltirish tartibi.
2. Nazariya — chuqur tushuntirish
2.1. strip oilasi
matn = " salom "
print(repr(matn.strip())) # 'salom' — ikki tomondan
print(repr(matn.lstrip())) # 'salom ' — chapdan
print(repr(matn.rstrip())) # ' salom' — o'ngdanArgumentsiz — barcha bo'shliq belgisini olib tashlaydi:
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:
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+):
print("python.py".removesuffix(".py")) # 'python'
print("test_fayl.py".removeprefix("test_")) # 'fayl.py'3.9 gacha:
def removesuffix(matn: str, suffiks: str) -> str:
if suffiks and matn.endswith(suffiks):
return matn[:-len(suffiks)]
return matnif suffiks tekshiruvi muhim — bo'sh suffiks matn[:-0] = '' beradi (4.2-dars).
Amaliy misollar:
# 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:
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}")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:
matn = "salom"
print(repr(matn.strip())) # 'salom' — tozalanmadi
print(len(matn)) # 6, lekin ko'zga 5 ko'rinadi
print(matn == "salom") # False!Yechim:
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:
matn = "Ali Valiyev"
print(matn.split()) # ['Ali', 'Valiyev'] — split tozalaydi
print(matn == "Ali Valiyev") # False!
print(matn.replace(" ", " ") == "Ali Valiyev") # True2.3. Ichki bo'sh joylarni normallashtirish
Bu — eng ko'p ishlatiladigan idioma:
matn = " Ali \t Valiyev \n Toshkentdan "
print(repr(" ".join(matn.split()))) # 'Ali Valiyev Toshkentdan'Qanday ishlaydi?
split()argumentsiz — har qanday bo'shliq bo'yicha bo'ladi va bo'sh elementlarni tashlaydi" ".join(...)— bitta bo'sh joy bilan birlashtiradi
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 (
hamisspace()— split uni tanidi)
sinovlar = [
" salom ",
"salom\tdunyo",
"salom\n\ndunyo",
"salom dunyo",
"Ali Valiyev",
]
for s in sinovlar:
print(f" {s!r:<26} → {' '.join(s.split())!r}") ' salom ' → 'salom'
'salom\tdunyo' → 'salom dunyo'
'salom\n\ndunyo' → 'salom dunyo'
'salom dunyo' → 'salom dunyo'
'Ali\xa0Valiyev' → 'Ali Valiyev'2.4. replace — almashtirish
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'chirishXususiyatlari:
- Yangi satr qaytaradi (satrlar o'zgarmas — 3.7-dars)
- Topilmasa — xato yo'q, asl satr qaytadi
- Zanjirlash mumkin
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:
# ❌ 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:
ALMASHTIRISHLAR = {
"&": "&",
"<": "<",
">": ">",
}
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 < b & c > d'Bu yerda & birinchi almashtirilishi kerak — aks holda < dagi & ham almashardi. Lug'atlar Python 3.7+ da tartibni saqlaydi (6-qism).
Xavfsizroq — translate:
jadval = str.maketrans({"&": "&", "<": "<", ">": ">"})
print(matn.translate(jadval)) # tartib muammosi yo'qYoki tayyor kutubxona:
import html
print(html.escape("a < b & c > d")) # 'a < b & c > d'2.5. Registr metodlari
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:
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'rititle() har bir harf bo'lmagan belgidan keyin bosh harf qo'yadi. O'zbek tilidagi apostrof uchun bu muammo.
To'g'ri usul:
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:
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().
# ✅ Xalqaro matnni solishtirish
if a.casefold() == b.casefold():
...Turk tili muammosi:
# Turk tilida i → İ (nuqtali katta I), I → ı (nuqtasiz kichik)
print("i".upper()) # 'I' — turkcha noto'g'riPython tildan xabardor emas. Til-spetsifik registr kerak bo'lsa — PyICU kutubxonasi.
2.6. To'ldirish metodlari
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:
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):
print(f"{42:05d}") # '00042'
print(f"{'42':>5}") # ' 42'
print(f"{'42':*^5}") # '*42**'f-satr moslashuvchanroq, lekin metodlar dinamik kenglikda qulay:
kenglik = 10
print("abc".center(kenglik, "-"))
print(f"{'abc':-^{kenglik}}") # bir xilAmaliy foydalanish:
# 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.txt2.7. translate — eng tez almashtirish
translate bir belgini bir belgiga (yoki satrga, yoki hech narsaga) almashtiradi. Bir o'tishda.
# 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?
# ❌ 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:
matn = "ab"
print(matn.replace("a", "b").replace("b", "a")) # 'aa' ❌
print(matn.translate(str.maketrans("ab", "ba"))) # 'ba' ✅Belgilarni o'chirish:
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:
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:
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
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:
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 taKod ko'rsatishda foydali:
kod = "def f():\n\treturn 1"
print(kod.expandtabs(4))2.9. Normalizatsiya quvuri
Amaliyotda tozalash bir necha bosqichda bo'ladi. Tartib muhim:
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",
"AliValiyev",
"José", # NFC
"José", # NFD
]
for s in sinovlar:
print(f" {s!r:<24} → {normalizatsiya(s)!r}") ' Ali Valiyev ' → 'ali valiyev'
'ALI\tVALIYEV' → 'ali valiyev'
'Ali\xa0Valiyev' → 'ali valiyev'
'AliValiyev' → '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 |
# Ma'lumotlar bazasiga
ism = normalizatsiya(kiritilgan, registr=False) # 'Ali Valiyev'
# Qidiruv indeksiga
qidiruv_kaliti = normalizatsiya(kiritilgan) # 'ali valiyev'3. Tez ma'lumotnoma
Tozalash
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 normallashtirishAlmashtirish
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
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
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.py".strip(".py") → 'ython' (belgilar to'plami)
"ab".replace("a","b").replace("b","a") → 'aa' (tartib)
"o'ktam".title() → "O'Ktam"
"salom".strip() → tozalanmaydi4. Batafsil misollar
Misol 1 — strip tuzoqlari
"""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}")=== 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
"""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 = {"&": "&", "<": "<", ">": ">"}
# 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")=== 1. Tartib muammosi ===
Asl: 'ab', maqsad: 'ba' (a↔b almashtirish)
replace zanjiri: 'aa' ❌
translate: 'ba' ✅
=== 2. HTML ekranlash ===
replace (& birinchi): 'a < b & c > d'
replace (& oxirgi): 'a &lt; b & c &gt; d' ❌ ikki karra
translate: 'a < b & c > d' ✅
html.escape: 'a < b & c > 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.1xEslatma: 4-misolda
ўalmashtirilmadi — uKIRILro'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
"""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}")=== 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 topdiDiqqat: '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
"""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"),
("azizakarimova", "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
""")┌─ 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)translatebilan 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.py".strip(".py") # ❌ 'ython'
"python.py".removesuffix(".py") # ✅ 'python'2. replace natijasini saqlamaslik
matn.replace("a", "b") # ❌ natija yo'qoladi
matn = matn.replace("a", "b") # ✅Satrlar o'zgarmas (3.7-dars).
3. Almashtirishda tartib
matn.replace("a", "b").replace("b", "c") # ❌ a ham c bo'ladi
matn.translate(str.maketrans("ab", "bc")) # ✅4. Ko'rinmas belgilar
if kirish.strip() == "ha": # ❌ qolishi mumkin
if tozala(kirish) == "ha": # ✅ (2.9-bo'lim)5. title() ni ismlar uchun
"o'ktam".title() # ❌ "O'Ktam"
" ".join(s.capitalize() for s in "o'ktam".split()) # ✅ "O'ktam"6. Bo'sh suffiks bilan matn[:-len(x)]
suffiks = ""
matn[:-len(suffiks)] # ❌ '' — chunki matn[:-0]
if suffiks: # ✅ tekshiring
matn = matn[:-len(suffiks)]7. split(" ") va split() ni adashtirish
" a b ".split(" ") # ['', '', 'a', '', '', 'b', '', '']
" a b ".split() # ['a', 'b'] ✅8. Registrsiz solishtirishni unutish
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
" ".join(matn.split())— universal tozalash. Boshi, oxiri va ichki ortiqcha bo'shliqlarni bir vaqtda hal qiladi.strip()o'rnigaremoveprefix/removesuffix. Belgilar to'plami tuzog'idan qutuling.Ko'p almashtirish uchun
translate. Tezroq va tartib muammosi yo'q.Solishtirish uchun
casefold().lower()— faqat ko'rsatish uchun.title()o'rnigacapitalize()zanjiri. Apostrofli so'zlarda to'g'ri ishlaydi.Ikki daraja normalizatsiya qiling. Saqlash uchun bir xil, solishtirish uchun boshqa.
Ko'rinmas belgilarni alohida tozalang.
strip()ularni ushlamaydi.Tayyor kutubxonalarni ishlating.
html.escape,unicodedata.normalize,pathlib— o'zingiz yozishdan yaxshiroq.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
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
'salom''salom''thon'—stripqo'shimchani emas, belgilar to'plamini (.,p,y) ikki chetdan olib tashlaydi: boshidanp,y, oxiridany,p,.''— hamma belgib,a,ndan iborat!'aa''ba'— birinchiaaalmashdi,aqoldi"O'Ktam"'-00042''000-42''ab c''a b''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:
"+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 formatVazifa 4: translate bilan translitteratsiya
To'liq o'zbek kirillcha → lotincha jadval tuzing. Diqqat: ў, қ, ғ, ҳ, ц, щ.
Sinang: "Ўзбекистон Республикаси".
Vazifa 5: HTML ekranlash
html.escape ni o'zingiz yozing:
&→&(birinchi!)<→<>→>"→"'→'
Ikki usulda: replace zanjiri va translate. Natijalarni solishtiring.
Vazifa 6: Ism formatlash
ism_formatla(matn) ni yozing va sinang:
" 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:
banana
^ 'b' — to'plamda bor, olib tashlanadi
^ 'a' — bor, olib tashlanadi
^ 'n' — bor
... barcha belgi olib tashlanadiNatija — 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:
strip(x)belgilar to'plami bilan ishlaydi, pastki satr bilan emas."banana".strip("ban")bo'sh satr beradi. Prefiks/suffiks uchunremoveprefix/removesuffix." ".join(matn.split())— universal tozalash idiomasi. Boshi, oxiri va ichki ortiqcha bo'shliqlarni bir vaqtda normallashtiradi, hatto buzilmas bo'sh joyni ham.Ko'p almashtirish uchun
translate.replacezanjiri tartibga bog'liq va sekinroq.translatebir 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.
Izohlar · 0
Izoh yozish uchun kiring.