15.1-dars: Muntazam ifodalar: asoslar

re.findall(r"\+998[0-9]{9}", matn)  # barcha +998XXXXXXXXX raqamlar

import re

m = re.search(r"\d+", "buyurtma 4521 tayyor")
m.group()     # '4521'
m.span()      # (9, 13)

if (m := re.search(naqsh, matn)) is not None:
    print(m.group())

re.findall("\bol\b", "ol olma")    # [] — jim xato!
re.findall(r"\bol\b", "ol olma")   # ['ol']

re.search(r"1\+1", "1+1=2")        # '+' — oddiy belgi
re.escape("1+1=2? (ha)")           # '1\\+1=2\\?\\ \\(ha\\)'

re.findall(r"<.+>",  "<b>qalin</b>")   # ['<b>qalin</b>']  — ochko'z
re.findall(r"<.+?>", "<b>qalin</b>")   # ['<b>', '</b>']   — dangasa

re.findall(r"kot|kotlin", "kotlin")    # ['kot']
re.findall(r"kotlin|kot", "kotlin")    # ['kotlin']

TELEFON = re.compile(r"\+998[0-9]{9}")
TELEFON.search(matn); TELEFON.findall(matn)

import re

re.search(r"\d+", s)            # birinchi moslik yoki None
re.fullmatch(r"[0-9]{4}", s)    # butun satr — validatsiya
re.findall(r"\w+", s)           # hammasi, ro'yxat
re.finditer(r"\w+", s)          # hammasi, Match lar
re.escape(foydalanuvchi_matni)  # naqsh ichiga xavfsiz qo'yish
NAQSH = re.compile(r"...", re.I | re.X)

naqsh doim r"..."
validatsiya — fullmatch
aniq 0-9 kerak — [0-9] yoki re.ASCII
foydalanuvchi matni naqshda — re.escape
.* ochko'z — kerak bo'lsa .*?

"""search, match, fullmatch farqi; findall va finditer; Match obyekti; xom satr tuzog'i; compile va xato naqsh."""

import re

MATN = "Buyurtma 4521: 3 ta kitob, 12 ta daftar. Jami 185000 so'm."


def main() -> None:
    print("=== 1. search, match, fullmatch ===")
    for funksiya in (re.search, re.match, re.fullmatch):
        for satr in ("4521", "4521-sonli", "buyurtma 4521"):
            m = funksiya(r"\d+", satr)
            natija = repr(m.group()) if m else "None"
            print(f"  {funksiya.__name__:9} {satr!r:16} → {natija}")
    print("  ⭐ validatsiya uchun faqat fullmatch ishonchli")

    print("\n=== 2. findall va finditer ===")
    print(f"  findall:  {re.findall(r'\d+', MATN)}")
    for m in re.finditer(r"\d+", MATN):
        print(f"  finditer: {m.group():>6}  span={m.span()}")

    print("\n=== 3. Match obyekti ===")
    m = re.search(r"\d+", MATN)
    assert m is not None
    print(f"  {m!r}")
    print(f"  group()={m.group()!r}, start()={m.start()}, end()={m.end()}")
    print(f"  kesma bilan bir xil: {MATN[m.start():m.end()] == m.group()}")
    print(f"  bool(m): {bool(m)}, topilmasa: {re.search(r'xyz', MATN)}")

    print("\n=== 4. ⚠️ Xom satr tuzog'i ===")
    print(f"  '\\b' uzunligi: {len('\b')} (backspace), r'\\b' uzunligi: {len(r'\b')}")
    print(f"  oddiy satr naqsh: {re.findall('\bta\b', MATN)}")
    print(f"  xom satr naqsh:   {re.findall(r'\bta\b', MATN)}")

    print("\n=== 5. compile va xato naqsh ===")
    SON = re.compile(r"\d+")
    print(f"  turi: {type(SON).__name__}, naqsh: {SON.pattern!r}")
    print(f"  SON.findall: {SON.findall('7 va 42')}")
    try:
        re.compile(r"[0-9")
    except re.error as xato:
        print(f"  {type(xato).__name__}: {xato.msg} (pozitsiya {xato.pos})")
        print(f"  re.error — PatternError ning eski nomi: {re.error is re.PatternError}")


if __name__ == "__main__":
    main()

=== 1. search, match, fullmatch ===
  search    '4521'           → '4521'
  search    '4521-sonli'     → '4521'
  search    'buyurtma 4521'  → '4521'
  match     '4521'           → '4521'
  match     '4521-sonli'     → '4521'
  match     'buyurtma 4521'  → None
  fullmatch '4521'           → '4521'
  fullmatch '4521-sonli'     → None
  fullmatch 'buyurtma 4521'  → None
  ⭐ validatsiya uchun faqat fullmatch ishonchli

=== 2. findall va finditer ===
  findall:  ['4521', '3', '12', '185000']
  finditer:   4521  span=(9, 13)
  finditer:      3  span=(15, 16)
  finditer:     12  span=(27, 29)
  finditer: 185000  span=(46, 52)

=== 3. Match obyekti ===
  <re.Match object; span=(9, 13), match='4521'>
  group()='4521', start()=9, end()=13
  kesma bilan bir xil: True
  bool(m): True, topilmasa: None

=== 4. ⚠️ Xom satr tuzog'i ===
  '\b' uzunligi: 1 (backspace), r'\b' uzunligi: 2
  oddiy satr naqsh: []
  xom satr naqsh:   ['ta', 'ta']

=== 5. compile va xato naqsh ===
  turi: Pattern, naqsh: '\\d+'
  SON.findall: ['7', '42']
  PatternError: unterminated character set (pozitsiya 0)
  re.error — PatternError ning eski nomi: True

r"""[...] sinflari; \d \w \s; Unicode va ASCII rejim; o'zbek apostroflari; \p{L} yo'qligi va [^\W\d_]; re.escape."""

import re
import unicodedata


def main() -> None:
    print("=== 1. Sinflar ===")
    matn = "Dasturlash 2026-yil, narxi $49.99!"
    for naqsh in (r"[aeiou]", r"[A-Z]", r"[0-9]+", r"[^\w\s]", r"[.$]"):
        print(f"  {naqsh:10} → {re.findall(naqsh, matn)}")

    print("\n=== 2. ⚠️ \\d sukut bo'yicha Unicode ===")
    yoshlar = ["25", "٢٥", "२५", "25a"]
    for yosh in yoshlar:
        unicode_rejim = bool(re.fullmatch(r"\d+", yosh))
        ascii_rejim = bool(re.fullmatch(r"\d+", yosh, re.ASCII))
        oraliq = bool(re.fullmatch(r"[0-9]+", yosh))
        print(f"  {yosh!r:6} \\d+={unicode_rejim!s:5}  ASCII={ascii_rejim!s:5}  [0-9]+={oraliq}")
    print(f"  int('٢٥') = {int('٢٥')}  ← Python ularni son deb biladi")

    print("\n=== 3. ⚠️ O'zbek apostroflari va \\w ===")
    variantlar = {"o'zbek": "'", "oʻzbek": "ʻ", "o‘zbek": "‘"}
    for soz, belgi in variantlar.items():
        nom = unicodedata.name(belgi)
        kategoriya = unicodedata.category(belgi)
        print(f"  {soz:8} {nom:32} [{kategoriya}] \\w+ → {re.findall(r'\w+', soz)}")
    print("  ⭐ faqat U+02BB (rasmiy o'zbek belgisi) harf hisoblanadi")

    print("\n=== 4. Faqat harflar: \\p{L} o'rniga ===")
    try:
        re.compile(r"\p{L}+")
    except re.error as xato:
        print(f"  \\p{{L}} → {type(xato).__name__}: {xato.msg}")
    matn = "Oʻzbekiston 2026 café_bar тил"
    print(f"  \\w+       → {re.findall(r'\w+', matn)}")
    print(f"  [^\\W\\d_]+ → {re.findall(r'[^\W\d_]+', matn)}")

    print("\n=== 5. \\s — bo'shliqlar ===")
    matn = "a b\tc\nd\u00a0e"
    print(f"  \\s ga mos keladiganlar: {[hex(ord(b)) for b in re.findall(r'\s', matn)]}")
    print(f"  ASCII rejimda:           {[hex(ord(b)) for b in re.findall(r'\s', matn, re.ASCII)]}")
    print("  ⭐ 0xa0 — bo'linmas bo'shliq (veb sahifalardan nusxalanganda ko'p uchraydi)")

    print("\n=== 6. re.escape ===")
    qidiruv = "narxi $49.99"
    xavfli = re.findall(qidiruv, "narxi $49.99 va narxi 49x99")
    xavfsiz = re.findall(re.escape(qidiruv), "narxi $49.99 va narxi 49x99")
    print(f"  re.escape natijasi: {re.escape(qidiruv)!r}")
    print(f"  ekranlanmagan:  {xavfli}  ← '$' — satr oxiri, '.' — istalgan belgi")
    print(f"  ekranlangan:    {xavfsiz}")


if __name__ == "__main__":
    main()

=== 1. Sinflar ===
  [aeiou]    → ['a', 'u', 'a', 'i', 'a', 'i']
  [A-Z]      → ['D']
  [0-9]+     → ['2026', '49', '99']
  [^\w\s]    → ['-', ',', '$', '.', '!']
  [.$]       → ['$', '.']

=== 2. ⚠️ \d sukut bo'yicha Unicode ===
  '25'   \d+=True   ASCII=True   [0-9]+=True
  '٢٥'   \d+=True   ASCII=False  [0-9]+=False
  '२५'   \d+=True   ASCII=False  [0-9]+=False
  '25a'  \d+=False  ASCII=False  [0-9]+=False
  int('٢٥') = 25  ← Python ularni son deb biladi

=== 3. ⚠️ O'zbek apostroflari va \w ===
  o'zbek   APOSTROPHE                       [Po] \w+ → ['o', 'zbek']
  oʻzbek   MODIFIER LETTER TURNED COMMA     [Lm] \w+ → ['oʻzbek']
  o‘zbek   LEFT SINGLE QUOTATION MARK       [Pi] \w+ → ['o', 'zbek']
  ⭐ faqat U+02BB (rasmiy o'zbek belgisi) harf hisoblanadi

=== 4. Faqat harflar: \p{L} o'rniga ===
  \p{L} → PatternError: bad escape \p
  \w+       → ['Oʻzbekiston', '2026', 'café_bar', 'тил']
  [^\W\d_]+ → ['Oʻzbekiston', 'café', 'bar', 'тил']

=== 5. \s — bo'shliqlar ===
  \s ga mos keladiganlar: ['0x20', '0x9', '0xa', '0xa0']
  ASCII rejimda:           ['0x20', '0x9', '0xa']
  ⭐ 0xa0 — bo'linmas bo'shliq (veb sahifalardan nusxalanganda ko'p uchraydi)

=== 6. re.escape ===
  re.escape natijasi: 'narxi\\ \\$49\\.99'
  ekranlanmagan:  []  ← '$' — satr oxiri, '.' — istalgan belgi
  ekranlangan:    ['narxi $49.99']

r"""Miqdorlar; ochko'z va dangasa; bo'sh moslik; ^ $ \A \Z \b; | tartibi; MULTILINE, DOTALL, IGNORECASE, VERBOSE."""

import re


def main() -> None:
    print("=== 1. Miqdorlar ===")
    for naqsh in (r"colou?r", r"\d{3}", r"\d{2,3}", r"\d{2,}", r"go+l"):
        print(f"  {naqsh:9} → {re.findall(naqsh, 'color colour 12345 7 gol gooool gl')}")

    print("\n=== 2. Ochko'z va dangasa ===")
    html = '<a href="/bosh">Bosh</a> | <a href="/kurs">Kurs</a>'
    print(f"  <.+>   → {re.findall(r'<.+>', html)}")
    print(f"  <.+?>  → {re.findall(r'<.+?>', html)}")
    print(f"  \"(.*)\"  ochko'z uzunligi: {len(re.search(r'\".*\"', html).group())}")
    print(f"  \"(.*?)\" dangasa:         {re.search(r'\".*?\"', html).group()}")

    print("\n=== 3. ⚠️ Bo'sh moslik ===")
    print(f"  x* 'axxb' da: {re.findall(r'x*', 'axxb')}")
    print(f"  x+ 'axxb' da: {re.findall(r'x+', 'axxb')}")

    print("\n=== 4. Langarlar ===")
    matn = "ol olma bol ol."
    print(f"  ol      → {len(re.findall(r'ol', matn))} ta")
    print(f"  \\bol\\b  → {len(re.findall(r'\bol\b', matn))} ta (alohida so'z)")
    print(f"  \\Bol\\b  → {re.findall(r'\Bol\b', matn)} (so'z oxirida)")
    print(f"  '$' 'abc\\n' da pozitsiya: {re.search(r'$', 'abc\n').start()}")
    print(f"  '\\Z' 'abc\\n' da pozitsiya: {re.search(r'\Z', 'abc\n').start()}")
    print(f"  ⚠️ fullmatch(r'\\d+$') ham '123\\n' ni o'tkazmaydi: {re.fullmatch(r'\d+$', '123\n')}")
    print(f"  lekin match(r'\\d+$') o'tkazadi:                  {bool(re.match(r'\d+$', '123\n'))}")

    print("\n=== 5. Muqobillar tartibi ===")
    print(f"  kot|kotlin → {re.findall(r'kot|kotlin', 'kotlin')}")
    print(f"  kotlin|kot → {re.findall(r'kotlin|kot', 'kotlin')}")
    print("  ⭐ uzunroq muqobilni oldinga qo'ying")

    print("\n=== 6. Bayroqlar ===")
    jurnal = "XATO: disk\nogoh: xotira\nxato: tarmoq"
    print(f"  ^xato               → {re.findall(r'^xato', jurnal)}")
    print(f"  ^xato + I           → {re.findall(r'^xato', jurnal, re.I)}")
    print(f"  ^xato: \\w+ + I + M  → {re.findall(r'^xato: \w+', jurnal, re.I | re.M)}")
    print(f"  (?im) ichki yozuv   → {re.findall(r'(?im)^xato: \w+', jurnal)}")
    print(f"  a.b  → {re.findall(r'a.b', 'a' + chr(10) + 'b')},  DOTALL bilan → {len(re.findall(r'a.b', 'a' + chr(10) + 'b', re.S))} ta")

    print("\n=== 7. VERBOSE — o'qiladigan naqsh ===")
    SANA = re.compile(r"""
        \b
        [0-9]{4}        # yil
        -
        (?:0[1-9]|1[0-2])  # oy: 01-12
        -
        (?:0[1-9]|[12][0-9]|3[01])  # kun: 01-31
        \b
    """, re.VERBOSE)
    print(f"  {SANA.findall('2026-09-17, 2026-13-01, 2026-02-30, 26-09-17')}")
    print("  ⚠️ 2026-02-30 o'tdi — regex taqvimni bilmaydi (15.4-dars: datetime)")


if __name__ == "__main__":
    main()

=== 1. Miqdorlar ===
  colou?r   → ['color', 'colour']
  \d{3}     → ['123']
  \d{2,3}   → ['123', '45']
  \d{2,}    → ['12345']
  go+l      → ['gol', 'gooool']

=== 2. Ochko'z va dangasa ===
  <.+>   → ['<a href="/bosh">Bosh</a> | <a href="/kurs">Kurs</a>']
  <.+?>  → ['<a href="/bosh">', '</a>', '<a href="/kurs">', '</a>']
  "(.*)"  ochko'z uzunligi: 34
  "(.*?)" dangasa:         "/bosh"

=== 3. ⚠️ Bo'sh moslik ===
  x* 'axxb' da: ['', 'xx', '', '']
  x+ 'axxb' da: ['xx']

=== 4. Langarlar ===
  ol      → 4 ta
  \bol\b  → 2 ta (alohida so'z)
  \Bol\b  → ['ol'] (so'z oxirida)
  '$' 'abc\n' da pozitsiya: 3
  '\Z' 'abc\n' da pozitsiya: 4
  ⚠️ fullmatch(r'\d+$') ham '123\n' ni o'tkazmaydi: None
  lekin match(r'\d+$') o'tkazadi:                  True

=== 5. Muqobillar tartibi ===
  kot|kotlin → ['kot']
  kotlin|kot → ['kotlin']
  ⭐ uzunroq muqobilni oldinga qo'ying

=== 6. Bayroqlar ===
  ^xato               → []
  ^xato + I           → ['XATO']
  ^xato: \w+ + I + M  → ['XATO: disk', 'xato: tarmoq']
  (?im) ichki yozuv   → ['XATO: disk', 'xato: tarmoq']
  a.b  → [],  DOTALL bilan → 1 ta

=== 7. VERBOSE — o'qiladigan naqsh ===
  ['2026-09-17', '2026-02-30']
  ⚠️ 2026-02-30 o'tdi — regex taqvimni bilmaydi (15.4-dars: datetime)

"""Forma validatsiyasi: xato qoidalar va tuzatilganlari; sinov jadvali bilan baholash; o'zbek ismlari, raqamlar, telefon, login."""

import re
import unicodedata

XATO_QOIDALAR = {
    "ism": re.compile(r"^\w+$"),
    "yosh": re.compile(r"\d+"),
    "telefon": re.compile(r"\+998\d{9}"),
    "login": re.compile(r"[a-z0-9_]{3,16}"),
}

ISM_HARFI = r"[^\W\d_]"
TOGRI_QOIDALAR = {
    "ism": re.compile(rf"{ISM_HARFI}+(?:[ʻ'‘`’]{ISM_HARFI}+)*(?:-{ISM_HARFI}+)?"),
    "yosh": re.compile(r"[1-9][0-9]?|1[01][0-9]"),
    "telefon": re.compile(r"\+998[0-9]{9}"),
    "login": re.compile(r"[a-z][a-z0-9_]{2,15}", re.ASCII),
}

# (maydon, kiritish, to'g'ri qabul qilinishi kerakmi)
SINOVLAR = [
    ("ism", "Aziza", True),
    ("ism", "Oʻgʻiloy", True),
    ("ism", "O'g'iloy", True),
    ("ism", "O‘g‘iloy", True),
    ("ism", "Anna-Mariya", True),
    ("ism", "Ali_2", False),
    ("ism", "Ali\n", False),
    ("yosh", "25", True),
    ("yosh", "٢٥", False),
    ("yosh", "25 yosh", False),
    ("yosh", "0", False),
    ("yosh", "119", True),
    ("telefon", "+998901234567", True),
    ("telefon", "+9989012345678", False),
    ("telefon", "tel: +998901234567", False),
    ("telefon", "+998٩٠١٢٣٤٥٦٧", False),
    ("login", "aziz_99", True),
    ("login", "99aziz", False),
    ("login", "az", False),
    ("login", "aziz!!", False),
]


def tekshir(qoidalar: dict[str, re.Pattern[str]], maydon: str, qiymat: str, qat_iy: bool) -> bool:
    naqsh = qoidalar[maydon]
    if qat_iy:
        qiymat = unicodedata.normalize("NFC", qiymat)
        return naqsh.fullmatch(qiymat) is not None
    return naqsh.match(qiymat) is not None


def baholash(nom: str, qoidalar: dict[str, re.Pattern[str]], qat_iy: bool) -> list[str]:
    xatolar = []
    for maydon, qiymat, kutilgan in SINOVLAR:
        if tekshir(qoidalar, maydon, qiymat, qat_iy) != kutilgan:
            holat = "o'tkazib yubordi" if not kutilgan else "rad etdi"
            xatolar.append(f"{maydon:8} {qiymat!r:24} → {holat}")
    print(f"  {nom}: {len(SINOVLAR) - len(xatolar)}/{len(SINOVLAR)} to'g'ri")
    return xatolar


def main() -> None:
    print("=== 1. Xato qoidalar (match, \\w, \\d, langarlarsiz) ===")
    for xato in baholash("xato qoidalar", XATO_QOIDALAR, qat_iy=False):
        print(f"    ❌ {xato}")

    print("\n=== 2. Tuzatilgan qoidalar (fullmatch, [0-9], ASCII, apostroflar) ===")
    xatolar = baholash("tuzatilgan", TOGRI_QOIDALAR, qat_iy=True)
    for xato in xatolar:
        print(f"    ❌ {xato}")
    print(f"  hamma sinov o'tdi: {xatolar == []}")

    print("\n=== 3. Nima o'zgardi ===")
    print("  match → fullmatch:     'tel: ...', '25 yosh', 'aziz!!' endi rad etiladi")
    print("  \\d → [0-9]:            arabcha raqamlar rad etiladi")
    print("  \\w → [^\\W\\d_]:         ismda '_' va raqam rad etiladi")
    print("  apostrof variantlari:  O'g'iloy, Oʻgʻiloy, O‘g‘iloy — hammasi qabul")
    print("  re.ASCII (login):      faqat lotin harflari")

    print("\n=== 4. ⚠️ Regex nimani tekshirmaydi ===")
    print("  telefon raqami haqiqatan mavjudmi — yo'q (SMS kod kerak)")
    print("  yosh mantiqiymi (ro'yxatdan o'tish sanasiga nisbatan) — yo'q")
    print("  ⭐ regex — shakl tekshiruvi; ma'no tekshiruvi — alohida qatlam (13.8-dars)")


if __name__ == "__main__":
    main()

=== 1. Xato qoidalar (match, \w, \d, langarlarsiz) ===
  xato qoidalar: 8/20 to'g'ri
    ❌ ism      "O'g'iloy"               → rad etdi
    ❌ ism      'O‘g‘iloy'               → rad etdi
    ❌ ism      'Anna-Mariya'            → rad etdi
    ❌ ism      'Ali_2'                  → o'tkazib yubordi
    ❌ ism      'Ali\n'                  → o'tkazib yubordi
    ❌ yosh     '٢٥'                     → o'tkazib yubordi
    ❌ yosh     '25 yosh'                → o'tkazib yubordi
    ❌ yosh     '0'                      → o'tkazib yubordi
    ❌ telefon  '+9989012345678'         → o'tkazib yubordi
    ❌ telefon  '+998٩٠١٢٣٤٥٦٧'          → o'tkazib yubordi
    ❌ login    '99aziz'                 → o'tkazib yubordi
    ❌ login    'aziz!!'                 → o'tkazib yubordi

=== 2. Tuzatilgan qoidalar (fullmatch, [0-9], ASCII, apostroflar) ===
  tuzatilgan: 20/20 to'g'ri
  hamma sinov o'tdi: True

=== 3. Nima o'zgardi ===
  match → fullmatch:     'tel: ...', '25 yosh', 'aziz!!' endi rad etiladi
  \d → [0-9]:            arabcha raqamlar rad etiladi
  \w → [^\W\d_]:         ismda '_' va raqam rad etiladi
  apostrof variantlari:  O'g'iloy, Oʻgʻiloy, O‘g‘iloy — hammasi qabul
  re.ASCII (login):      faqat lotin harflari

=== 4. ⚠️ Regex nimani tekshirmaydi ===
  telefon raqami haqiqatan mavjudmi — yo'q (SMS kod kerak)
  yosh mantiqiymi (ro'yxatdan o'tish sanasiga nisbatan) — yo'q
  ⭐ regex — shakl tekshiruvi; ma'no tekshiruvi — alohida qatlam (13.8-dars)

re.findall("\bso'z\b", matn)       # ❌ backspace
re.findall(r"\bso'z\b", matn)      # ✅

if re.match(r"\d+", yosh): ...     # ❌ '25abc' o'tadi
if re.fullmatch(r"[0-9]+", yosh): ...  # ✅

re.search(qidiruv, matn)           # ❌ 'c++' → xato naqsh
re.search(re.escape(qidiruv), matn)  # ✅

re.findall(r'"(.*)"', matn)        # ❌ birinchi va oxirgi qo'shtirnoq orasini oladi
re.findall(r'"(.*?)"', matn)       # ✅ yoki [^"]*

r"kot|kotlin"                      # ❌ 'kotlin' da 'kot'
r"kotlin|kot"                      # ✅

re.search(naqsh, matn).group()     # ❌ AttributeError: 'NoneType'
if (m := re.search(naqsh, matn)): m.group()  # ✅

re.match(r"[0-9]+$", "123\n")      # ⚠️ o'tadi
re.fullmatch(r"[0-9]+", "123\n")   # ✅ o'tmaydi

re.findall(r"<div>(.*?)</div>", html)  # ⚠️ ichma-ich teglar buziladi
# ✅ html.parser, BeautifulSoup, json (16-qism)

import re
1.  print(re.findall(r"\d+", "a1b22c333"))
2.  print(re.match(r"\d+", "abc123"))
3.  print(re.search(r"\d+", "abc123").group())
4.  print(bool(re.fullmatch(r"\d+", "123abc")))
5.  print(re.findall(r"a.c", "abc a\nc aXc"))
6.  print(re.findall(r"<.*?>", "<p><b>"))
7.  print(re.findall(r"\bis\b", "this is his island"))
8.  print(re.findall(r"[^aeiou]", "audio"))
9.  print(len("\n"), len(r"\n"))
10. print(re.findall(r"\w+", "o'rik"))
11. print(bool(re.fullmatch(r"\d", "٣")), bool(re.fullmatch(r"[0-9]", "٣")))
12. print(re.escape("a.b"))

1.  def pochta_indeksimi(s):
        return re.match("\d{6}", s) is not None

2.  def qidir(soz, matn):
        return re.findall(soz, matn)            # soz = "c++"

3.  def sarlavha(html):
        return re.search(r"<title>(.*)</title>", html).group()

4.  def yil(s):
        return re.fullmatch(r"\d{4}", s)         # "٢٠٢٦" ham o'tadi

5.  FAYL = r"rasm|rasmlar"
    re.findall(FAYL, "rasmlar papkasi")