4.10-dars: Xom satr va ekranlash
4-QISM — SATRLAR CHUQUR · 10-dars
1. Kirish va motivatsiya
Teskari chiziq (\) — satrlardagi eng ko'p muammo keltiradigan belgi.
print("C:\new\table")C:
ew ableNima bo'ldi? \n — yangi qator, \t — tabulyatsiya. Windows yo'li buzildi.
Va bu — faqat boshlanishi:
print(len("\\")) # 1 — bitta belgi
print("\d") # '\\d' — lekin ogohlantirish bilan
print(r"\d") # '\\d' — xato yo'q
print("\101") # 'A' — sakkizlik!
print("\x41") # 'A'
print("\N{GREEK SMALL LETTER ALPHA}") # 'α'# r"..." bilan ham tuzoq bor
print(r"C:\papka\") # ❌ SyntaxError — nega?Bu darsda:
- Barcha ekranlash ketma-ketligi
- Xom satrlar (
r"...") — qanday ishlaydi va cheklovlari \dkabi noma'lum ketma-ketliklar vaSyntaxWarning- Windows yo'llari — uch yechim
- Muntazam ifodalar uchun nima uchun
r""majburiy
2. Nazariya — chuqur tushuntirish
2.1. Ekranlash nima va nega kerak
Satr ichida ba'zi belgilarni to'g'ridan-to'g'ri yozib bo'lmaydi:
# print("U "salom" dedi") # ❌ SyntaxError — tirnoq satrni tugatadi
print("U \"salom\" dedi") # ✅ ekranlash bilan
print('U "salom" dedi') # ✅ boshqa tirnoq bilanEkranlash ketma-ketligi — \ va undan keyingi belgi(lar) bitta belgini anglatadi.
print(len("\n")) # 1 — bitta belgi (yangi qator)
print(len("\\")) # 1 — bitta belgi (teskari chiziq)
print(len("\t")) # 1
print(ord("\n")) # 10Bu — kompilyatsiya paytida amalga oshadi. Ishlash paytida satrda \ va n emas, bitta \n belgisi bor.
2.2. To'liq ro'yxat
| Ketma-ketlik | Nomi | Kod |
|---|---|---|
\\ |
Teskari chiziq | U+005C |
\' |
Apostrof | U+0027 |
\" |
Qo'shtirnoq | U+0022 |
\n |
Yangi qator (LF) | U+000A |
\r |
Karetkani qaytarish (CR) | U+000D |
\t |
Gorizontal tabulyatsiya | U+0009 |
\v |
Vertikal tabulyatsiya | U+000B |
\f |
Sahifa oxiri (FF) | U+000C |
\b |
Orqaga (backspace) | U+0008 |
\a |
Signal (bell) | U+0007 |
\0 |
Nol belgi | U+0000 |
\ooo |
Sakkizlik (1-3 raqam) | — |
\xhh |
O'n oltilik (aniq 2 raqam) | — |
\uXXXX |
Unicode (aniq 4 raqam) | — |
\UXXXXXXXX |
Unicode (aniq 8 raqam) | — |
\N{NOM} |
Unicode nom bo'yicha | — |
\ + qator oxiri |
Qatorni davom ettirish | — |
Namoyish:
namunalar = [
(r"\n", "\n", "yangi qator"),
(r"\t", "\t", "tabulyatsiya"),
(r"\\", "\\", "teskari chiziq"),
(r"\'", "\'", "apostrof"),
(r"\"", "\"", "qo'shtirnoq"),
(r"\0", "\0", "nol belgi"),
(r"\a", "\a", "signal"),
(r"\101", "\101", "sakkizlik 101 = 65 = 'A'"),
(r"\x41", "\x41", "o'n oltilik 41 = 'A'"),
(r"\u0410", "\u0410", "Unicode kirillcha А"),
(r"\U0001F60A", "\U0001F60A", "Unicode emoji"),
(r"\N{DEGREE SIGN}", "\N{DEGREE SIGN}", "Unicode nom bo'yicha"),
]
print(f" {'Yozuv':<22} {'Natija':<8} {'Kod':<10} Izoh")
print(" " + "─" * 62)
for yozuv, natija, izoh in namunalar:
kod = f"U+{ord(natija):04X}" if len(natija) == 1 else ""
korinish = repr(natija) if len(natija) == 1 and ord(natija) < 32 else natija
print(f" {yozuv:<22} {korinish:<8} {kod:<10} {izoh}")2.3. Sonli ketma-ketliklar
Sakkizlik — \ooo:
print("\101") # 'A' — 0o101 = 65
print("\o101") # ❌ 'o' — noto'g'ri, \o yo'q
print("\0") # nol belgi
print("\07") # signal (7)
print("\1234") # 'S4' — faqat 3 raqam oladi (0o123 = 83 = 'S')O'n oltilik — \xhh (aniq 2 raqam):
print("\x41") # 'A'
print("\x41BC") # 'ABC' — \x41 = 'A', keyin 'BC'
# print("\x4") # ❌ SyntaxError — 2 raqam kerak
print("\x00") # nol belgi \x faqat 2 raqam oladi:
print("\x410") # 'A0' — \x41 = 'A', keyin '0'Bu — kutilmagan natija manbai. \x bilan Unicode belgi yozib bo'lmaydi (255 dan katta).
Unicode — \uXXXX (4 raqam) va \UXXXXXXXX (8 raqam):
print("\u0410") # 'А' — kirillcha
print("\u00e9") # 'é'
print("\U0001F60A") # '😊'
# print("\u1F60A") # ❌ 4 raqam oladi: \u1F60 + 'A'
print("\u1F60A") # 'ὠA' — kutilmagan!Diqqat: \u aniq 4 raqam, \U aniq 8 raqam oladi. BMP dan tashqaridagi belgilar uchun \U kerak.
Nom bo'yicha — \N{NOM}:
print("\N{DEGREE SIGN}") # '°'
print("\N{GREEK SMALL LETTER ALPHA}") # 'α'
print("\N{SMILING FACE WITH SMILING EYES}") # '😊'
print("\N{CYRILLIC CAPITAL LETTER A}") # 'А'
print("\N{MODIFIER LETTER TURNED COMMA}") # 'ʻ' ← o'zbekcha apostrofBu — eng o'qiladigan usul:
# ❌ Nima ekani noma'lum
apostrof = "\u02bb"
# ✅ Aniq
apostrof = "\N{MODIFIER LETTER TURNED COMMA}"Nomni topish:
import unicodedata
print(unicodedata.name("ʻ")) # 'MODIFIER LETTER TURNED COMMA'2.4. Xom satrlar — r"..."
Xom satrda ekranlash ishlamaydi:
print("C:\new") # C: + yangi qator + ew
print(r"C:\new") # C:\new
print(len("\n")) # 1
print(len(r"\n")) # 2 — '\' va 'n'
print(r"\n" == "\\n") # TrueQanday ishlaydi? r prefiksi Python'ga "\ ni maxsus belgi deb qabul qilma" deydi.
print(repr("\t")) # '\t' — bitta belgi
print(repr(r"\t")) # '\\t' — ikki belgi Xom satr \ bilan tugay olmaydi:
# print(r"C:\papka\") # ❌ SyntaxError
print(r"C:\papka" + "\\") # ✅
print("C:\\papka\\") # ✅
print(r"C:\papka\ "[:-1]) # ✅ (hiyla, lekin chirkin)Nega? Chunki tahlilchi \" ni ekranlangan tirnoq deb ko'radi va satr tugamaydi. Xom satrda \ ekranlashni bekor qilmaydi — u faqat talqinni o'chiradi.
Bu tushunish muhim:
print(r"C:\papka\"file\"") # 'C:\\papka\\"file\\"'\" ekranlandi (satr tugamadi), lekin natijada \ saqlanib qoldi.
f-satr bilan birga:
yol = "papka"
print(rf"C:\{yol}\fayl.txt") # 'C:\papka\fayl.txt'
print(fr"C:\{yol}") # tartib muhim emasb-satr bilan:
print(rb"\x41") # b'\\x41' — baytlar, ekranlashsiz
print(b"\x41") # b'A'2.5. Noma'lum ketma-ketliklar
print("\d") # '\\d' — ishlaydi, lekin ogohlantirish bilanPython 3.12+ da:
SyntaxWarning: invalid escape sequence '\d'Python 3.6 dan DeprecationWarning, 3.12 dan SyntaxWarning. Kelajakda SyntaxError bo'ladi.
Noma'lum ketma-ketliklar:
\d \s \w \D \S \W \b(satr ichida — backspace!) \A \Z
\p \k \g \e \c \q \y \z ...Eng xavflisi — \b:
print(len("\b")) # 1 — BACKSPACE belgisi!
print(len(r"\b")) # 2 — '\' va 'b'Muntazam ifodalarda \b — "so'z chegarasi". Lekin oddiy satrda u backspace:
import re
# ❌ \b backspace bo'lib ketadi
print(re.findall("\bsalom\b", "salom dunyo")) # []
# ✅ Xom satr bilan
print(re.findall(r"\bsalom\b", "salom dunyo")) # ['salom']Bu — muntazam ifodalarda r"" nima uchun majburiy ekanining asosiy sababi.
Ogohlantirishlarni ko'rish:
python -W error::SyntaxWarning main.pyRuff topadi: W605 ("invalid escape sequence").
2.6. Windows yo'llari — uch yechim
# ❌ Xato
yol = "C:\Users\new\table.txt"
# \U → xato, \n → yangi qator, \t → tab
# ✅ 1. Xom satr
yol = r"C:\Users\new\table.txt"
# ✅ 2. Ikki teskari chiziq
yol = "C:\\Users\\new\\table.txt"
# ✅ 3. To'g'ri chiziq (Windows ham tushunadi!)
yol = "C:/Users/new/table.txt"
# ✅ 4. pathlib (ENG YAXSHI)
from pathlib import Path
yol = Path("C:/Users/new/table.txt")Nega pathlib eng yaxshi?
from pathlib import Path
yol = Path("C:/Users") / "hujjatlar" / "hisobot.pdf"
print(yol) # Windows: C:\Users\hujjatlar\hisobot.pdf
# Linux: C:/Users/hujjatlar/hisobot.pdf
print(yol.name) # 'hisobot.pdf'
print(yol.stem) # 'hisobot'
print(yol.suffix) # '.pdf'
print(yol.parent) # C:/Users/hujjatlar
print(yol.exists()) # False/ operatori yo'llarni birlashtiradi va tizimga mos ajratgichni qo'yadi.
15-qismda batafsil.
\U tuzog'i:
# yol = "C:\Users\admin" # ❌ SyntaxError: (unicode error) 'unicodeescape'\U — 8 raqamli Unicode ketma-ketligi boshlanishi. sers\adm yaroqli o'n oltilik emas.
Bu — Windows'da eng ko'p uchraydigan satr xatosi.
2.7. Muntazam ifodalar va r""
Muntazam ifodalarda \ juda ko'p ishlatiladi:
import re
# ❌ Ikki karra ekranlash kerak
naqsh = "\\d+\\.\\d+"
# ✅ Xom satr
naqsh = r"\d+\.\d+"
print(re.findall(naqsh, "narx 12.50 va 3.14")) # ['12.50', '3.14']Nega ikki karra?
Siz yozasiz: "\\d"
Python o'qiydi: \d ← bitta teskari chiziq
re oladi: \d ← regex "raqam" deb tushunadiXom satr bilan:
Siz yozasiz: r"\d"
Python o'qiydi: \d
re oladi: \dKlassik chalkashlik — teskari chiziqni qidirish:
matn = r"C:\papka"
print(re.findall("\\\\", matn)) # ['\\'] — TO'RT teskari chiziq!
print(re.findall(r"\\", matn)) # ['\\'] — ikkitaNega to'rtta? "\\\\" → Python \\ deb o'qiydi → regex \ deb tushunadi.
Bu — "leaning toothpick syndrome" (egilgan tish cho'plari sindromi).
Almashtirish satrida ham:
print(re.sub(r"(\d+)", r"[\1]", "narx 42")) # 'narx [42]'
print(re.sub(r"(\d+)", "[\\1]", "narx 42")) # bir xil, lekin chirkinQoida:
Muntazam ifodalarda doim
r""ishlating — hatto\bo'lmasa ham. Bu — odat masalasi.
15-qismda batafsil.
2.8. Ekranlash boshqa kontekstlarda
JSON:
import json
malumot = {"yol": "C:\\Users", "matn": "a\nb"}
print(json.dumps(malumot))
# {"yol": "C:\\Users", "matn": "a\nb"}JSON o'z ekranlashiga ega — \n, \t, \", \\, \uXXXX.
SQL:
# ❌ Qo'lda ekranlash — xavfli
sorov = f"SELECT * FROM t WHERE ism = '{ism}'"
# ✅ Parametrlangan so'rov
kursor.execute("SELECT * FROM t WHERE ism = ?", (ism,))Shell:
import shlex
fayl = "mening fayl.txt"
print(shlex.quote(fayl)) # "'mening fayl.txt'"HTML:
import html
print(html.escape('<a href="x">')) # '<a href="x">'CSV:
import csv, io
chiqish = io.StringIO()
csv.writer(chiqish).writerow(['a"b', "c,d"])
print(chiqish.getvalue()) # '"a""b","c,d"'CSV da tirnoq ikkilantirish bilan ekranlanadi, \ bilan emas.
Har bir formatning o'z ekranlash qoidasi bor — ularni aralashtirmang.
2.9. Amaliy naqshlar
Ko'rinmas belgilarni ko'rish:
matn = "salom\tdunyo\n"
print(matn) # ko'rinmaydi
print(repr(matn)) # 'salom\tdunyo\n'
print(matn.encode("unicode_escape")) # b'salom\\tdunyo\\n'
print(ascii(matn)) # "'salom\\tdunyo\\n'"repr() — nosozlik izlashda majburiy (2.9-dars).
Barcha ekranlashni ko'rsatish:
def korinadigan(matn: str) -> str:
"""Ko'rinmas belgilarni ko'rinadigan qiladi."""
almashtirishlar = {
"\n": "\\n", "\t": "\\t", "\r": "\\r",
"\v": "\\v", "\f": "\\f", "\b": "\\b",
"\0": "\\0", "\a": "\\a",
}
natija = []
for c in matn:
if c in almashtirishlar:
natija.append(almashtirishlar[c])
elif ord(c) < 32 or ord(c) == 127:
natija.append(f"\\x{ord(c):02x}")
else:
natija.append(c)
return "".join(natija)
print(korinadigan("a\tb\nc\x00d")) # 'a\\tb\\nc\\0d'Xom satrni oddiy satrga aylantirish:
xom = r"a\nb"
oddiy = xom.encode().decode("unicode_escape")
print(repr(oddiy)) # 'a\nb'
print(len(xom), len(oddiy)) # 4 3 unicode_escape faqat latin-1 bilan ishlaydi:
xom = r"салом\n"
# xom.encode().decode("unicode_escape") # ❌ buziladi
# To'g'ri usul
import codecs
print(codecs.decode(xom, "unicode_escape")) # ⚠️ hali ham muammo bo'lishi mumkinKirillcha bilan unicode_escape ishonchsiz. Iloji bo'lsa qochib qoling.
3. Tez ma'lumotnoma
Asosiy ekranlashlar
\\ \' \" teskari chiziq va tirnoqlar
\n \r \t yangi qator, karetka, tab
\v \f \b \a \0 vertikal tab, sahifa, backspace, signal, nolSonli
\ooo sakkizlik (1-3 raqam) "\101" → 'A'
\xhh o'n oltilik (ANIQ 2) "\x41" → 'A'
\uXXXX Unicode (ANIQ 4) "\u0410" → 'А'
\UXXXXXXXX Unicode (ANIQ 8) "\U0001F60A" → '😊'
\N{NOM} nom bo'yicha "\N{DEGREE SIGN}" → '°'Xom satrlar
r"\n" ikki belgi ('\' va 'n')
rf"..." f-satr bilan
rb"..." baytlar bilan
⚠️ r"..\" ❌ SyntaxError — \ bilan tugay olmaydiWindows yo'llari
r"C:\Users\admin" ✅ xom satr
"C:\\Users\\admin" ✅ ikkilantirish
"C:/Users/admin" ✅ to'g'ri chiziq
Path("C:/Users/admin") ✅ ENG YAXSHI
"C:\Users\admin" ❌ \U xatosiTuzoqlar
"\b" backspace, regex "so'z chegarasi" EMAS
"\d" SyntaxWarning → kelajakda xato
"\x410" 'A0' — \x aniq 2 raqam
"\u1F60A" 'ὠA' — \u aniq 4 raqam, \U kerak
r"\d" ✅ regex uchun DOIM4. Batafsil misollar
Misol 1 — Barcha ekranlash ketma-ketligi
"""Ekranlash ketma-ketliklarining to'liq jadvali."""
import unicodedata
print("=== 1. Asosiy ekranlashlar ===")
asosiy = [
(r"\\", "\\", "teskari chiziq"),
(r"\'", "\'", "apostrof"),
(r'\"', "\"", "qo'shtirnoq"),
(r"\n", "\n", "yangi qator (LF)"),
(r"\r", "\r", "karetka (CR)"),
(r"\t", "\t", "tabulyatsiya"),
(r"\v", "\v", "vertikal tab"),
(r"\f", "\f", "sahifa oxiri"),
(r"\b", "\b", "backspace ⚠️"),
(r"\a", "\a", "signal"),
(r"\0", "\0", "nol belgi"),
]
print(f" {'Yozuv':<8} {'len':>4} {'Kod':<10} {'repr':<10} Izoh")
print(" " + "─" * 54)
for yozuv, natija, izoh in asosiy:
print(f" {yozuv:<8} {len(natija):>4} U+{ord(natija):04X} "
f"{repr(natija):<10} {izoh}")
print("\n=== 2. Sonli ketma-ketliklar ===")
sonli = [
(r"\101", "\101", "sakkizlik 0o101 = 65"),
(r"\x41", "\x41", "o'n oltilik 0x41 = 65"),
(r"\u0041", "\u0041", "Unicode 4 raqam"),
(r"\U00000041", "\U00000041", "Unicode 8 raqam"),
(r"\N{LATIN CAPITAL LETTER A}", "\N{LATIN CAPITAL LETTER A}", "nom bo'yicha"),
]
for yozuv, natija, izoh in sonli:
print(f" {yozuv:<32} → {natija!r:<6} {izoh}")
print("\n Barchasi bir xil natija — 'A'")
print("\n=== 3. ⚠️ Aniq raqam soni ===")
sinovlar = [
(r'"\x41"', "\x41", "\\x — aniq 2 raqam"),
(r'"\x410"', "\x410", "\\x41 + '0'"),
(r'"\u0410"', "\u0410", "\\u — aniq 4 raqam"),
(r'"\u04100"', "\u04100", "\\u0410 + '0'"),
(r'"\1234"', "\1234", "\\ooo — 3 raqamgacha"),
]
for yozuv, natija, izoh in sinovlar:
print(f" {yozuv:<14} → {natija!r:<10} len={len(natija)} {izoh}")
print("\n=== 4. Unicode nom bo'yicha ===")
belgilar = ["°", "α", "😊", "А", "ʻ", "€", "→"]
for c in belgilar:
nom = unicodedata.name(c)
print(f" {c} \\N{{{nom}}}")
print("\n Bu — eng o'qiladigan usul:")
print(r' apostrof = "\u02bb" ❌ noaniq')
print(r' apostrof = "\N{MODIFIER LETTER TURNED COMMA}" ✅ aniq')
print("\n=== 5. Ko'rinmas belgilarni ko'rish ===")
matn = "salom\tdunyo\nyangi\x00qator"
print(f" print(): {matn}")
print(f" repr(): {matn!r}")
print(f" ascii(): {ascii(matn)}")
print(f" encode('unicode_escape'): {matn.encode('unicode_escape')}")
def korinadigan(matn: str) -> str:
almashtirishlar = {"\n": "\\n", "\t": "\\t", "\r": "\\r",
"\v": "\\v", "\f": "\\f", "\b": "\\b",
"\0": "\\0", "\a": "\\a"}
return "".join(
almashtirishlar.get(c, f"\\x{ord(c):02x}" if ord(c) < 32 else c)
for c in matn
)
print(f" korinadigan(): {korinadigan(matn)}")Natijaning muhim qismi:
=== 3. ⚠️ Aniq raqam soni ===
"\x41" → 'A' len=1 \x — aniq 2 raqam
"\x410" → 'A0' len=2 \x41 + '0'
"\u0410" → 'А' len=1 \u — aniq 4 raqam
"\u04100" → 'А0' len=2 \u0410 + '0'
"\1234" → 'S4' len=2 \ooo — 3 raqamgacha
=== 4. Unicode nom bo'yicha ===
° \N{DEGREE SIGN}
α \N{GREEK SMALL LETTER ALPHA}
😊 \N{SMILING FACE WITH SMILING EYES}
А \N{CYRILLIC CAPITAL LETTER A}
ʻ \N{MODIFIER LETTER TURNED COMMA}Nima ko'rsatdi: 2.2, 2.3, 2.9-bo'limlar.
Misol 2 — Xom satrlar
"""r"..." qanday ishlaydi va cheklovlari."""
print("=== 1. Asosiy farq ===")
juftliklar = [
('"\\n"', "\n", r"\n"),
('"\\t"', "\t", r"\t"),
('"\\\\"', "\\", r"\\"),
('"\\d"', "\d", r"\d"),
('"\\x41"', "\x41", r"\x41"),
]
print(f" {'Yozuv':<12} {'Oddiy':<12} {'len':>4} {'Xom':<12} {'len':>4}")
print(" " + "─" * 54)
for yozuv, oddiy, xom in juftliklar:
print(f" {yozuv:<12} {oddiy!r:<12} {len(oddiy):>4} "
f"{xom!r:<12} {len(xom):>4}")
print("\n=== 2. ⚠️ Xom satr \\ bilan tugay olmaydi ===")
print(r""" # print(r"C:\papka\") ❌ SyntaxError
Yechimlar:
r"C:\papka" + "\\" ✅
"C:\\papka\\" ✅
r"C:\papka" "\\" ✅ (yonma-yon satrlar)""")
yol1 = r"C:\papka" + "\\"
yol2 = "C:\\papka\\"
print(f"\n Natija: {yol1!r}, teng: {yol1 == yol2}")
print("\n=== 3. Xom satrda \\ ekranlashni BEKOR QILMAYDI ===")
xom = r"C:\papka\"fayl\""
print(f' r"C:\\papka\\"fayl\\"" → {xom!r}')
print(" ← \\\" satrni tugatmadi, lekin \\ SAQLANDI")
print("\n=== 4. Prefikslarni birlashtirish ===")
yol = "papka"
namunalar = [
("rf'...'", rf"C:\{yol}\fayl.txt"),
("fr'...'", fr"C:\{yol}\fayl.txt"),
("rb'...'", rb"\x41"),
("br'...'", br"\x41"),
]
for nom, natija in namunalar:
print(f" {nom:<10} → {natija!r}")
print("\n=== 5. Windows yo'llari — 4 yechim ===")
from pathlib import Path
print(" ❌ Xato:")
print(r' "C:\Users\new\table.txt"')
print(" → \\U xatosi yoki \\n, \\t buzilishi")
yechimlar = [
('r"C:\\Users\\new\\table.txt"', r"C:\Users\new\table.txt"),
('"C:\\\\Users\\\\new"', "C:\\Users\\new"),
('"C:/Users/new"', "C:/Users/new"),
]
print("\n ✅ Yechimlar:")
for yozuv, natija in yechimlar:
print(f" {yozuv:<34} → {natija}")
p = Path("C:/Users") / "hujjatlar" / "hisobot.pdf"
print(f"\n ✅ pathlib (eng yaxshi):")
print(f" Path('C:/Users') / 'hujjatlar' / 'hisobot.pdf'")
print(f" → {p}")
print(f" .name = {p.name}")
print(f" .stem = {p.stem}")
print(f" .suffix = {p.suffix}")
print(f" .parent = {p.parent}")
print("\n=== 6. \\U tuzog'i ===")
print(" Bu qatorlar SyntaxError beradi:")
print(r' "C:\Users\admin" ← \U + "sers\adm" yaroqsiz')
print(r' "D:\Ustoz\loyiha" ← \U + "stoz\loy" yaroqsiz')
print("\n Lekin bular ishlaydi:")
print(r' "C:\temp\admin" ← \t va \a — yaroqli ekranlash')
print(f' → {chr(9)}emp{chr(7)}dmin ← lekin NOTO\'G\'RI natija!')=== 1. Asosiy farq ===
Yozuv Oddiy len Xom len
──────────────────────────────────────────────────────
"\n" '\n' 1 '\\n' 2
"\t" '\t' 1 '\\t' 2
"\\" '\\' 1 '\\\\' 2
"\d" '\\d' 2 '\\d' 2
"\x41" 'A' 1 '\\x41' 4
=== 3. Xom satrda \ ekranlashni BEKOR QILMAYDI ===
r"C:\papka\"fayl\"" → 'C:\\papka\\"fayl\\"'
← \" satrni tugatmadi, lekin \ SAQLANDI
=== 5. Windows yo'llari — 4 yechim ===
✅ pathlib (eng yaxshi):
Path('C:/Users') / 'hujjatlar' / 'hisobot.pdf'
→ C:\Users\hujjatlar\hisobot.pdf
.name = hisobot.pdf
.stem = hisobot
.suffix = .pdf
.parent = C:\Users\hujjatlarNima ko'rsatdi: 2.4, 2.6-bo'limlar.
Misol 3 — Muntazam ifodalar va r""
"""Nima uchun regex da r"" majburiy."""
import re
import warnings
print("=== 1. \\b tuzog'i ===")
matn = "salom dunyo salomat"
print(f" Matn: {matn!r}")
print(f' "\\b" nima: {"\\b"!r} (len={len(chr(8))}) — BACKSPACE')
print(f' r"\\b" nima: {r"\b"!r} (len={len(r"\b")}) — ikki belgi')
print(f"\n re.findall('\\\\bsalom\\\\b', matn):")
try:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
natija = re.findall("\bsalom\b", matn)
print(f" → {natija} ← backspace qidirdi, topmadi")
except re.error as x:
print(f" → xato: {x}")
print(f"\n re.findall(r'\\bsalom\\b', matn):")
print(f" → {re.findall(r'\bsalom\b', matn)} ← ✅ so'z chegarasi")
print("\n=== 2. Ikki karra ekranlash ===")
naqshlar = [
("Raqamlar", "\\d+", r"\d+"),
("Kasr son", "\\d+\\.\\d+", r"\d+\.\d+"),
("So'z", "\\w+", r"\w+"),
("Bo'shliq", "\\s+", r"\s+"),
("Satr boshi", "^\\w", r"^\w"),
]
print(f" {'Nima':<14} {'Ekranlash bilan':<20} {'Xom satr':<16} Teng?")
print(" " + "─" * 60)
for nom, oddiy, xom in naqshlar:
print(f" {nom:<14} {oddiy!r:<20} {xom!r:<16} {oddiy == xom}")
print("\n Ikkalasi ham ishlaydi, lekin xom satr O'QISH OSON.")
print("\n=== 3. ⚠️ 'Egilgan tish cho'plari sindromi' ===")
matn = r"C:\papka\fayl.txt"
print(f" Matn: {matn!r}")
print(f" Ko'rinishi: {matn}")
print("\n Teskari chiziqni qidirish:")
print(f" re.findall('\\\\\\\\', matn) → {re.findall(chr(92)*4, matn)}")
print(f" re.findall(r'\\\\', matn) → {re.findall(r'\\', matn)}")
print("\n Birinchisida TO'RT teskari chiziq kerak:")
print(" Siz yozasiz: '\\\\\\\\'")
print(" Python o'qiydi: '\\\\'")
print(" re oladi: '\\' ← bitta")
print("\n=== 4. Almashtirish satrida ===")
matn = "narx 42 va 100"
print(f" Matn: {matn!r}")
print(f" re.sub(r'(\\d+)', r'[\\1]', matn)")
print(f" → {re.sub(r'(d+)'.replace('d', chr(92)+'d'), r'[\1]', matn)!r}")
print("\n=== 5. Amaliy naqshlar ===")
naqshlar_toplami = {
"Email": r"[\w.+-]+@[\w-]+\.[\w.]+",
"Telefon (UZ)": r"\+?998\s?\d{2}\s?\d{3}[\s-]?\d{2}[\s-]?\d{2}",
"URL": r"https?://[\w.-]+(?:/[\w./-]*)?",
"Sana (kk.oo.yyyy)": r"\d{2}\.\d{2}\.\d{4}",
"IP manzil": r"\b(?:\d{1,3}\.){3}\d{1,3}\b",
}
sinov_matni = """
Aloqa: ali@example.com yoki +998 90 123-45-67
Sayt: https://wisar.uz/kurslar
Sana: 08.09.2026
Server: 192.168.1.1
"""
for nom, naqsh in naqshlar_toplami.items():
topilgan = re.findall(naqsh, sinov_matni)
print(f" {nom:<20} {topilgan}")
print("\n Har bir naqsh r'' bilan yozilgan — bu MAJBURIY odat.")=== 1. \b tuzog'i ===
Matn: 'salom dunyo salomat'
"\b" nima: '\x08' (len=1) — BACKSPACE
r"\b" nima: '\\b' (len=2) — ikki belgi
re.findall('\\bsalom\\b', matn):
→ [] ← backspace qidirdi, topmadi
re.findall(r'\bsalom\b', matn):
→ ['salom'] ← ✅ so'z chegarasi
=== 5. Amaliy naqshlar ===
Email ['ali@example.com']
Telefon (UZ) ['+998 90 123-45-67']
URL ['https://wisar.uz/kurslar']
Sana (kk.oo.yyyy) ['08.09.2026']
IP manzil ['192.168.1.1']Nima ko'rsatdi: 2.5, 2.7-bo'limlar.
Misol 4 — Har bir formatning ekranlashi
"""Turli formatlarda ekranlash qoidalari."""
import json
import csv
import io
import html
import shlex
from urllib.parse import quote
XAVFLI_MATN = 'Ali "Valiyev", C:\\papka\nyangi qator, a<b&c'
print("┌─ BIR MATN — BESH FORMAT")
print("│")
print(f"│ Asl matn (repr): {XAVFLI_MATN!r}")
print("│")
print("│ Ko'rinishi:")
for qator in XAVFLI_MATN.splitlines():
print(f"│ {qator}")
print("└─")
print("\n=== 1. Python satr literali ===")
print(f" repr(): {XAVFLI_MATN!r}")
print(f" ascii(): {ascii(XAVFLI_MATN)}")
print(" Ekranlash: \\\\ \\' \\\" \\n \\t \\xXX \\uXXXX")
print("\n=== 2. JSON ===")
j = json.dumps({"matn": XAVFLI_MATN}, ensure_ascii=False)
print(f" {j}")
print(" Ekranlash: \\\" \\\\ \\n \\r \\t \\b \\f \\uXXXX")
print(" ⚠️ Yagona tirnoq — faqat qo'shtirnoq ishlatiladi")
qaytgan = json.loads(j)["matn"]
print(f" Aylanish: {qaytgan == XAVFLI_MATN}")
print("\n=== 3. CSV ===")
chiqish = io.StringIO()
csv.writer(chiqish).writerow(["Ali", XAVFLI_MATN, 42])
csv_matn = chiqish.getvalue()
print(f" {csv_matn!r}")
print(" Ekranlash: tirnoq IKKILANTIRILADI (\"\"), \\ ishlatilmaydi")
oquvchi = csv.reader(io.StringIO(csv_matn))
qaytgan = next(oquvchi)[1]
print(f" Aylanish: {qaytgan == XAVFLI_MATN}")
print("\n=== 4. HTML ===")
h = html.escape(XAVFLI_MATN)
print(f" {h!r}")
print(" Ekranlash: & < > " '")
qaytgan = html.unescape(h)
print(f" Aylanish: {qaytgan == XAVFLI_MATN}")
print("\n=== 5. URL ===")
u = quote(XAVFLI_MATN)
print(f" {u}")
print(" Ekranlash: %XX (UTF-8 baytlari)")
from urllib.parse import unquote
qaytgan = unquote(u)
print(f" Aylanish: {qaytgan == XAVFLI_MATN}")
print("\n=== 6. Shell ===")
s = shlex.quote(XAVFLI_MATN)
print(f" {s!r}")
print(" Ekranlash: butun matnni ' ichiga oladi, ichkaridagi ' — '\\''")
print("\n\n=== ⚠️ MUHIM QOIDA ===")
print("""
Har bir formatning O'Z ekranlash qoidasi bor.
Ularni ARALASHTIRMANG:
❌ HTML uchun Python ekranlashi:
javob = f"<p>{matn.replace('<', '<')}</p>" # to'liq emas
✅ Tayyor funksiya:
javob = f"<p>{html.escape(matn)}</p>"
❌ SQL uchun qo'lda ekranlash:
sorov = f"... WHERE ism = '{ism.replace(chr(39), chr(39)*2)}'"
✅ Parametrlangan so'rov:
kursor.execute("... WHERE ism = ?", (ism,))
Qo'lda ekranlash — deyarli DOIM xato va xavfsizlik zaifligi.
""")┌─ BIR MATN — BESH FORMAT
│
│ Asl matn (repr): 'Ali "Valiyev", C:\\papka\nyangi qator, a<b&c'
│
│ Ko'rinishi:
│ Ali "Valiyev", C:\papka
│ yangi qator, a<b&c
└─
=== 2. JSON ===
{"matn": "Ali \"Valiyev\", C:\\papka\nyangi qator, a<b&c"}
Ekranlash: \" \\ \n \r \t \b \f \uXXXX
Aylanish: True
=== 3. CSV ===
'Ali,"Ali ""Valiyev"", C:\\papka\nyangi qator, a<b&c",42\r\n'
Ekranlash: tirnoq IKKILANTIRILADI (""), \ ishlatilmaydi
Aylanish: True
=== 4. HTML ===
'Ali "Valiyev", C:\\papka\nyangi qator, a<b&c'
Ekranlash: & < > " '
Aylanish: True
=== 5. URL ===
Ali%20%22Valiyev%22%2C%20C%3A%5Cpapka%0Ayangi%20qator%2C%20a%3Cb%26c
Ekranlash: %XX (UTF-8 baytlari)
Aylanish: TrueNima ko'rsatdi: 2.8-bo'lim. Har bir format uchun tayyor funksiya ishlating.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
"r"..." ekranlashni butunlay o'chiradi" |
Faqat talqinni. \" hali ham satrni tugatmaydi |
"r"C:\papka\" ishlaydi" |
SyntaxError — xom satr \ bilan tugay olmaydi |
""\b" — so'z chegarasi" |
Backspace belgisi. Regex uchun r"\b" |
""\d" xato beradi" |
SyntaxWarning — hozircha ishlaydi, kelajakda xato |
""\x410" → 'А'" |
'A0' — \x aniq 2 raqam oladi |
""\u1F60A" → emoji" |
\u aniq 4 raqam. Emoji uchun \U0001F60A |
"len("\\") = 2" |
1 — bitta teskari chiziq belgisi |
"Windows yo'llarida / ishlamaydi" |
Ishlaydi. Python va Windows API tushunadi |
| "Ekranlash barcha formatda bir xil" | Har bir formatning o'z qoidasi bor |
6. Keng tarqalgan xatolar va yechimlari
1. Windows yo'li buzildi
yol = "C:\new\table.txt" # ❌
yol = r"C:\new\table.txt" # ✅
yol = "C:/new/table.txt" # ✅
Path("C:/new/table.txt") # ✅ eng yaxshi2. SyntaxError: (unicode error) 'unicodeescape'
yol = "C:\Users\admin" # ❌ \U ketma-ketligi
yol = r"C:\Users\admin" # ✅3. Regex ishlamayapti
re.findall("\bsalom\b", matn) # ❌ backspace qidiradi
re.findall(r"\bsalom\b", matn) # ✅4. SyntaxWarning: invalid escape sequence
naqsh = "\d+" # ⚠️ ogohlantirish
naqsh = r"\d+" # ✅
naqsh = "\\d+" # ✅ (lekin chirkin)5. Xom satr \ bilan tugaydi
yol = r"C:\papka\" # ❌ SyntaxError
yol = r"C:\papka" + "\\" # ✅
yol = "C:\\papka\\" # ✅6. \x bilan Unicode
"\x410" # ❌ 'A0'
"\u0410" # ✅ 'А'7. Qo'lda ekranlash
javob = matn.replace("<", "<") # ❌ to'liq emas
javob = html.escape(matn) # ✅8. \N{} da noto'g'ri nom
# "\N{SALOM}" # ❌ SyntaxError
import unicodedata
print(unicodedata.name("ʻ")) # nomni topish7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 4.11-dars: ko'p qatorli satrlar va ekranlash
- 15-qism: fayl yo'llari,
pathlib - 16-qism: JSON, CSV — har birining ekranlashi
- 15-qism: muntazam ifodalar —
r""majburiy - 20-qism: URL kodlash, HTML ekranlash
- 23-qism: SQL — parametrlangan so'rovlar
- Windows'da ishlaganda: har kuni
8. Eng yaxshi amaliyotlar
Regex uchun doim
r"". Hatto\bo'lmasa ham — odat masalasi.Windows yo'llari uchun
pathlib./operatori bilan birlashtiring.\N{NOM}ni afzal ko'ring."\u02bb"dan ko'ra"\N{MODIFIER LETTER TURNED COMMA}"aniqroq.SyntaxWarninglarni tuzating. Kelajakda ular xato bo'ladi. RuffW605bilan topadi.Har bir format uchun tayyor funksiya.
html.escape,json.dumps,shlex.quote,csv.writer.Qo'lda ekranlashdan qoching. Bu — deyarli doim to'liq emas va xavfsizlik zaifligi.
repr()bilan tekshiring. Ko'rinmas belgilarni ko'rish uchun.Xom satr
\bilan tuga olmasligini eslang. Bu — kutilmaganSyntaxErrormanbai.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
1. len("\n")
2. len(r"\n")
3. len("\\")
4. len(r"\\")
5. "\x41"
6. "\x410"
7. "\101"
8. "\u0410"
9. "\N{DEGREE SIGN}"
10. r"\d" == "\\d"
11. len("\b")
12. "C:\temp"Javoblar
1212'A''A0''A''А'— kirillcha'°'True1— backspace'C:\temp'da\t— tabulyatsiya! →'C: emp'
Vazifa 2: Xatolarni tuzatish
1. yol = "C:\Users\admin\Desktop"
2. naqsh = "\d{2}\.\d{2}\.\d{4}"
3. re.findall("\bsalom\b", matn)
4. yol = r"C:\papka\"
5. belgi = "\x0410"Javoblar
1. yol = r"C:\Users\admin\Desktop"
# yoki: Path("C:/Users/admin/Desktop")
2. naqsh = r"\d{2}\.\d{2}\.\d{4}"
3. re.findall(r"\bsalom\b", matn)
4. yol = r"C:\papka" + "\\"
# yoki: Path("C:/papka")
5. belgi = "\u0410" # \x aniq 2 raqam oladiVazifa 3: Ko'rinadigan qiluvchi
korinadigan(matn) funksiyasini yozing (2.9-bo'limdagidek), lekin qo'shing:
- Rangli chiqish (ANSI kodlari bilan)
- Har bir maxsus belgi uchun izoh
- Unicode belgilar uchun
\uXXXXko'rsatish
Vazifa 4: Yo'l normalizatori
yol_normal(yol) funksiyasini yozing:
- Har qanday shakldagi Windows/Unix yo'lini qabul qilsin
pathlib.Pathobyekti qaytarsin- Nisbiy yo'lni mutlaqga aylantirsin
Sinang: "C:\\Users\\a", "C:/Users/a", r"C:\Users\a", "./papka/fayl.txt".
Vazifa 5: Regex naqshlar to'plami
3-misoldagi naqshlar to'plamini kengaytiring:
- O'zbek telefon raqami (barcha format)
- Passport seriyasi (
AA1234567) - INN (9 raqam)
- Bank hisob raqami (20 raqam)
Har birini r"" bilan yozing va sinang.
Vazifa 6: Ekranlash solishtiruvi
4-misoldagi dasturni kengaytiring:
- XML ekranlashini qo'shing
- Markdown ekranlashini qo'shing
- Har bir format uchun aylanish testini yozing
Vazifa 7: O'ylash
Nega xom satr (r"...") teskari chiziq bilan tugay olmaydi?
Javob
Tahlilchi (parser) darajasidagi cheklov.
Python tahlilchisi satr chegarasini topish uchun \" ni ekranlangan tirnoq deb ko'radi — bu qoida xom satrlarda ham amal qiladi.
r"C:\papka\"
# ^^ — bu \" deb o'qiladi, satr tugamaydiTahlilchi satr davom etyapti deb o'ylaydi va faylning oxirigacha yopilish tirnog'ini qidiradi.
Nega shunday qilingan? Chunki xom satrda ham tirnoqni ekranlash kerak bo'lishi mumkin:
print(r"U \"salom\" dedi") # 'U \\"salom\\" dedi'Bu yerda \" satrni tugatmadi — lekin natijada \ saqlanib qoldi.
Ya'ni: r prefiksi ekranlashning natijasini o'chiradi (\ saqlanadi), lekin tahlilini o'chirmaydi (satr chegarasi topilishida hisobga olinadi).
Amaliy yechim:
r"C:\papka" + "\\" # ikki satrni qo'shish
"C:\\papka\\" # oddiy satr
Path("C:/papka") # eng yaxshisiBu — Python dizaynidagi kam sonli "chirkin burchak" lardan biri va u ataylab tuzatilmagan (moslikni buzmaslik uchun).
Nimani mustahkamlaydi: 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8-bo'limlar.
Xulosa
Bu darsda ekranlash va xom satrlarni o'rgandik.
Eng muhim uch fikr:
r"..."ekranlash talqinini o'chiradi, tahlilini emas. Shuning uchun xom satr\bilan tugay olmaydi — bu kutilmaganSyntaxErrormanbai.Muntazam ifodalarda
r""majburiy."\b"— backspace belgisi,r"\b"— so'z chegarasi. Bu farq regex ni jimgina ishlamas holga keltiradi.Windows yo'llari uchun
pathlib."C:\Users"—SyntaxError,r"C:\Users"— ishlaydi, lekinPath("C:/Users")— eng yaxshi. U tizimlararo ishlaydi va yo'l amallarini beradi.
Keyingi darsda ko'p qatorli satrlarni o'rganamiz: uch tirnoq, textwrap moduli, chekinish muammosi va docstring formatlash.
Izohlar · 0
Izoh yozish uchun kiring.