Python kursi4.10-dars: Xom satr va ekranlash
Python kursi · Satrlar chuqur

4.10-dars: Xom satr va ekranlash

22 daqiqa10/12-dars

4-QISM — SATRLAR CHUQUR · 10-dars


1. Kirish va motivatsiya

Teskari chiziq (\) — satrlardagi eng ko'p muammo keltiradigan belgi.

python
print("C:\new\table")
text
C:
ew	able

Nima bo'ldi? \n — yangi qator, \t — tabulyatsiya. Windows yo'li buzildi.

Va bu — faqat boshlanishi:

python
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}")   # 'α'
python
# r"..." bilan ham tuzoq bor
print(r"C:\papka\")             # ❌ SyntaxError — nega?

Bu darsda:

  • Barcha ekranlash ketma-ketligi
  • Xom satrlar (r"...") — qanday ishlaydi va cheklovlari
  • \d kabi noma'lum ketma-ketliklar va SyntaxWarning
  • 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:

python
# print("U "salom" dedi")       # ❌ SyntaxError — tirnoq satrni tugatadi
print("U \"salom\" dedi")       # ✅ ekranlash bilan
print('U "salom" dedi')         # ✅ boshqa tirnoq bilan

Ekranlash ketma-ketligi — \ va undan keyingi belgi(lar) bitta belgini anglatadi.

python
print(len("\n"))                # 1 — bitta belgi (yangi qator)
print(len("\\"))                # 1 — bitta belgi (teskari chiziq)
print(len("\t"))                # 1
print(ord("\n"))                # 10

Bu — 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:

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

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

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

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

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

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

Bu — eng o'qiladigan usul:

python
# ❌ Nima ekani noma'lum
apostrof = "\u02bb"

# ✅ Aniq
apostrof = "\N{MODIFIER LETTER TURNED COMMA}"

Nomni topish:

python
import unicodedata
print(unicodedata.name("ʻ"))    # 'MODIFIER LETTER TURNED COMMA'

2.4. Xom satrlar — r"..."

Xom satrda ekranlash ishlamaydi:

python
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")           # True

Qanday ishlaydi? r prefiksi Python'ga "\ ni maxsus belgi deb qabul qilma" deydi.

python
print(repr("\t"))               # '\t'   — bitta belgi
print(repr(r"\t"))              # '\\t'  — ikki belgi

Xom satr \ bilan tugay olmaydi:

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

python
print(r"C:\papka\"file\"")      # 'C:\\papka\\"file\\"'

\" ekranlandi (satr tugamadi), lekin natijada \ saqlanib qoldi.

f-satr bilan birga:

python
yol = "papka"
print(rf"C:\{yol}\fayl.txt")    # 'C:\papka\fayl.txt'
print(fr"C:\{yol}")             # tartib muhim emas

b-satr bilan:

python
print(rb"\x41")                 # b'\\x41' — baytlar, ekranlashsiz
print(b"\x41")                  # b'A'

2.5. Noma'lum ketma-ketliklar

python
print("\d")                     # '\\d' — ishlaydi, lekin ogohlantirish bilan

Python 3.12+ da:

text
SyntaxWarning: invalid escape sequence '\d'

Python 3.6 dan DeprecationWarning, 3.12 dan SyntaxWarning. Kelajakda SyntaxError bo'ladi.

Noma'lum ketma-ketliklar:

text
\d  \s  \w  \D  \S  \W  \b(satr ichida — backspace!)  \A  \Z
\p  \k  \g  \e  \c  \q  \y  \z  ...

Eng xavflisi — \b:

python
print(len("\b"))                # 1 — BACKSPACE belgisi!
print(len(r"\b"))               # 2 — '\' va 'b'

Muntazam ifodalarda \b — "so'z chegarasi". Lekin oddiy satrda u backspace:

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

bash
python -W error::SyntaxWarning main.py

Ruff topadi: W605 ("invalid escape sequence").

2.6. Windows yo'llari — uch yechim

python
# ❌ 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?

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

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

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

text
Siz yozasiz:     "\\d"
Python o'qiydi:  \d       ← bitta teskari chiziq
re oladi:        \d       ← regex "raqam" deb tushunadi

Xom satr bilan:

text
Siz yozasiz:     r"\d"
Python o'qiydi:  \d
re oladi:        \d

Klassik chalkashlik — teskari chiziqni qidirish:

python
matn = r"C:\papka"

print(re.findall("\\\\", matn))         # ['\\'] — TO'RT teskari chiziq!
print(re.findall(r"\\", matn))          # ['\\'] — ikkita

Nega to'rtta? "\\\\" → Python \\ deb o'qiydi → regex \ deb tushunadi.

Bu — "leaning toothpick syndrome" (egilgan tish cho'plari sindromi).

Almashtirish satrida ham:

python
print(re.sub(r"(\d+)", r"[\1]", "narx 42"))         # 'narx [42]'
print(re.sub(r"(\d+)", "[\\1]", "narx 42"))         # bir xil, lekin chirkin

Qoida:

Muntazam ifodalarda doim r"" ishlating — hatto \ bo'lmasa ham. Bu — odat masalasi.

15-qismda batafsil.

2.8. Ekranlash boshqa kontekstlarda

JSON:

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

python
# ❌ Qo'lda ekranlash — xavfli
sorov = f"SELECT * FROM t WHERE ism = '{ism}'"

# ✅ Parametrlangan so'rov
kursor.execute("SELECT * FROM t WHERE ism = ?", (ism,))

Shell:

python
import shlex

fayl = "mening fayl.txt"
print(shlex.quote(fayl))        # "'mening fayl.txt'"

HTML:

python
import html
print(html.escape('<a href="x">'))      # '&lt;a href=&quot;x&quot;&gt;'

CSV:

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

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

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

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

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

Kirillcha bilan unicode_escape ishonchsiz. Iloji bo'lsa qochib qoling.


3. Tez ma'lumotnoma

Asosiy ekranlashlar

python
\\  \'  \"          teskari chiziq va tirnoqlar
\n  \r  \t          yangi qator, karetka, tab
\v  \f  \b  \a  \0  vertikal tab, sahifa, backspace, signal, nol

Sonli

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

python
r"\n"       ikki belgi ('\' va 'n')
rf"..."     f-satr bilan
rb"..."     baytlar bilan

⚠️ r"..\"    ❌ SyntaxError — \ bilan tugay olmaydi

Windows yo'llari

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

Tuzoqlar

python
"\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 DOIM

4. Batafsil misollar

Misol 1 — Barcha ekranlash ketma-ketligi

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

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

python
"""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!')
text
=== 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\hujjatlar

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

Misol 3 — Muntazam ifodalar va r""

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

python
"""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: &amp; &lt; &gt; &quot; &#x27;")

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('<', '&lt;')}</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.
""")
text
┌─ 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 &quot;Valiyev&quot;, C:\\papka\nyangi qator, a&lt;b&amp;c'
  Ekranlash: &amp; &lt; &gt; &quot; &#x27;
  Aylanish: True

=== 5. URL ===
  Ali%20%22Valiyev%22%2C%20C%3A%5Cpapka%0Ayangi%20qator%2C%20a%3Cb%26c
  Ekranlash: %XX (UTF-8 baytlari)
  Aylanish: True

Nima 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

python
yol = "C:\new\table.txt"                # ❌
yol = r"C:\new\table.txt"               # ✅
yol = "C:/new/table.txt"                # ✅
Path("C:/new/table.txt")                # ✅ eng yaxshi

2. SyntaxError: (unicode error) 'unicodeescape'

python
yol = "C:\Users\admin"                  # ❌ \U ketma-ketligi
yol = r"C:\Users\admin"                 # ✅

3. Regex ishlamayapti

python
re.findall("\bsalom\b", matn)           # ❌ backspace qidiradi
re.findall(r"\bsalom\b", matn)          # ✅

4. SyntaxWarning: invalid escape sequence

python
naqsh = "\d+"                           # ⚠️ ogohlantirish
naqsh = r"\d+"                          # ✅
naqsh = "\\d+"                          # ✅ (lekin chirkin)

5. Xom satr \ bilan tugaydi

python
yol = r"C:\papka\"                      # ❌ SyntaxError
yol = r"C:\papka" + "\\"                # ✅
yol = "C:\\papka\\"                     # ✅

6. \x bilan Unicode

python
"\x410"                                 # ❌ 'A0'
"\u0410"                                # ✅ 'А'

7. Qo'lda ekranlash

python
javob = matn.replace("<", "&lt;")       # ❌ to'liq emas
javob = html.escape(matn)               # ✅

8. \N{} da noto'g'ri nom

python
# "\N{SALOM}"                           # ❌ SyntaxError

import unicodedata
print(unicodedata.name("ʻ"))            # nomni topish

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

  1. Regex uchun doim r"". Hatto \ bo'lmasa ham — odat masalasi.

  2. Windows yo'llari uchun pathlib. / operatori bilan birlashtiring.

  3. \N{NOM} ni afzal ko'ring. "\u02bb" dan ko'ra "\N{MODIFIER LETTER TURNED COMMA}" aniqroq.

  4. SyntaxWarning larni tuzating. Kelajakda ular xato bo'ladi. Ruff W605 bilan topadi.

  5. Har bir format uchun tayyor funksiya. html.escape, json.dumps, shlex.quote, csv.writer.

  6. Qo'lda ekranlashdan qoching. Bu — deyarli doim to'liq emas va xavfsizlik zaifligi.

  7. repr() bilan tekshiring. Ko'rinmas belgilarni ko'rish uchun.

  8. Xom satr \ bilan tuga olmasligini eslang. Bu — kutilmagan SyntaxError manbai.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
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
  1. 1
  2. 2
  3. 1
  4. 2
  5. 'A'
  6. 'A0'
  7. 'A'
  8. 'А' — kirillcha
  9. '°'
  10. True
  11. 1 — backspace
  12. 'C:\temp' da \t — tabulyatsiya! → 'C: emp'

Vazifa 2: Xatolarni tuzatish

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

Vazifa 3: Ko'rinadigan qiluvchi

korinadigan(matn) funksiyasini yozing (2.9-bo'limdagidek), lekin qo'shing:

  1. Rangli chiqish (ANSI kodlari bilan)
  2. Har bir maxsus belgi uchun izoh
  3. Unicode belgilar uchun \uXXXX ko'rsatish

Vazifa 4: Yo'l normalizatori

yol_normal(yol) funksiyasini yozing:

  • Har qanday shakldagi Windows/Unix yo'lini qabul qilsin
  • pathlib.Path obyekti 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:

  1. O'zbek telefon raqami (barcha format)
  2. Passport seriyasi (AA1234567)
  3. INN (9 raqam)
  4. Bank hisob raqami (20 raqam)

Har birini r"" bilan yozing va sinang.

Vazifa 6: Ekranlash solishtiruvi

4-misoldagi dasturni kengaytiring:

  1. XML ekranlashini qo'shing
  2. Markdown ekranlashini qo'shing
  3. 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.

python
r"C:\papka\"
#          ^^ — bu \" deb o'qiladi, satr tugamaydi

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

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

python
r"C:\papka" + "\\"              # ikki satrni qo'shish
"C:\\papka\\"                   # oddiy satr
Path("C:/papka")                # eng yaxshisi

Bu — 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:

  1. r"..." ekranlash talqinini o'chiradi, tahlilini emas. Shuning uchun xom satr \ bilan tugay olmaydi — bu kutilmagan SyntaxError manbai.

  2. Muntazam ifodalarda r"" majburiy. "\b" — backspace belgisi, r"\b" — so'z chegarasi. Bu farq regex ni jimgina ishlamas holga keltiradi.

  3. Windows yo'llari uchun pathlib. "C:\Users" — SyntaxError, r"C:\Users" — ishlaydi, lekin Path("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.

Satrlar chuqur · 10-dars yakunlandi

4.10-dars: Xom satr va ekranlash

22 daqvaqt
0belgi
Keyingi dars: 4.11-dars: Ko'p qatorli satrlar
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0