15.3-dars: re: amaliy naqshlar

re.findall(r"\d+(?= so'm)", "12 so'm, 5 dona, 300 so'm")   # ['12', '300']
re.findall(r"(?<=\$)\d+", "$40 va 50$")                    # ['40']

re.sub(r"(?<=\d)(?=(?:\d{3})+(?!\d))", " ", "1234567")    # '1 234 567'

PAROL = re.compile(
    r"(?=.*[a-z])"        # kichik harf bor
    r"(?=.*[A-Z])"        # katta harf bor
    r"(?=.*[0-9])"        # raqam bor
    r"(?=.*[^\w\s])"      # belgi bor
    r".{8,}"              # uzunlik
)
PAROL.fullmatch("Salom123!")    # ✅

re.fullmatch(r"(a+)+", "a" * 25 + "!")     # soniyalar, keyin daqiqalar

re.fullmatch(r"a*a", "aaa")      # ✅ — a* bitta 'a' ni qaytarib beradi
re.fullmatch(r"a*+a", "aaa")     # None — a*+ hammasini oldi va qaytarmaydi
re.fullmatch(r"(?>a+)+", "a" * 25 + "!")   # ⭐ darhol None

re.fullmatch(r"(<)?\w+(?(1)>)", "<ab>")   # ✅ — '<' bo'lsa '>' ham kerak
re.fullmatch(r"(<)?\w+(?(1)>)", "<ab")    # None

TOKEN = re.compile(r"""
    (?P<SON>\d+(?:\.\d+)?)
  | (?P<NOM>[A-Za-z_]\w*)
  | (?P<OP>[-+*/=()])
  | (?P<BOSHLIQ>\s+)
  | (?P<XATO>.)
""", re.VERBOSE)

for m in TOKEN.finditer(kod):
    tur, qiymat = m.lastgroup, m[0]

r"\d+(?= so'm)"                      # keyin ' so'm' bo'lsa
r"(?<![0-9])[0-9]{9}(?![0-9])"       # aniq 9 raqam, atrofida raqam yo'q
r"(?=.*[A-Z])(?=.*[0-9]).{8,}"       # bir nechta shart
r"(?<=\d)(?=(?:\d{3})+(?!\d))"       # minglik ajratgich joyi
r"(?>a+)b", r"a++b"                  # orqaga qaytmaslik
m.lastgroup                          # tokenizatorda token turi

lookaround pozitsiyani tekshiradi, belgini olmaydi
lookbehind — qat'iy uzunlik
raqamli naqsh atrofida (?<![0-9]) ... (?![0-9])
ichma-ich miqdor (a+)+ — xavfli
kirish uzunligini cheklang
tokenizator oxirida XATO guruhi

r"""Ijobiy va salbiy lookahead/lookbehind; minglik ajratgich; lookbehind cheklovi; parol siyosati — naqsh va aniq xabarlar."""

import re


def main() -> None:
    print("=== 1. To'rt xil qarash ===")
    matn = "12 so'm, 5 dona, 300 so'm, $40, 50$"
    print(f"  \\d+(?= so'm)   → {re.findall(r"\d+(?= so'm)", matn)}")
    print(f"  \\b\\d+\\b(?! so'm) → {re.findall(r"\b\d+\b(?! so'm)", matn)}")
    print(f"  (?<=\\$)\\d+    → {re.findall(r'(?<=\$)\d+', matn)}")
    print(f"  (?<![$\\d])\\d+(?!\\d)(?=\\$) → {re.findall(r'(?<![$\d])\d+(?!\d)(?=\$)', matn)}")
    print("  ⭐ kontekst tekshirildi, lekin natijaga kirmadi")

    print("\n=== 2. Minglik ajratgich ===")
    for son in ("1234567", "1000", "999", "12345678.905"):
        butun, _, qoldiq = son.partition(".")
        ajratilgan = re.sub(r"(?<=\d)(?=(?:\d{3})+$)", " ", butun)
        print(f"  {son:>13} → {ajratilgan}{'.' + qoldiq if qoldiq else ''}")

    print("\n=== 3. ⚠️ Lookbehind cheklovi ===")
    for naqsh in (r"(?<=\d+)x", r"(?<=ab|xyz)c"):
        try:
            re.compile(naqsh)
        except re.error as xato:
            print(f"  {naqsh:14} → {type(xato).__name__}: {xato}")
    print(f"  (?:(?<=ab)|(?<=xyz))c → {re.findall(r'(?:(?<=ab)|(?<=xyz))c', 'abc xyzc qc')}")

    print("\n=== 4. Parol siyosati: bitta naqsh ===")
    PAROL = re.compile(r"(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^\w\s]).{8,}")
    parollar = ["Salom123!", "salom123!", "Sal1!", "SalomDunyo1", "SALOM 123 !a"]
    for parol in parollar:
        print(f"  {parol!r:15} → {'✅' if PAROL.fullmatch(parol) else '❌'}")

    print("\n=== 5. Parol siyosati: aniq xabarlar ===")
    QOIDALAR = [
        (re.compile(r"[a-z]"), "kichik harf"),
        (re.compile(r"[A-Z]"), "katta harf"),
        (re.compile(r"[0-9]"), "raqam"),
        (re.compile(r"[^\w\s]"), "maxsus belgi"),
    ]
    for parol in parollar:
        yetishmaydi = [nom for naqsh, nom in QOIDALAR if not naqsh.search(parol)]
        if len(parol) < 8:
            yetishmaydi.append("kamida 8 belgi")
        print(f"  {parol!r:15} → {', '.join(yetishmaydi) or 'hammasi joyida'}")
    print("  ⭐ foydalanuvchiga nima yetishmayotganini aytish — bitta naqshdan foydaliroq")


if __name__ == "__main__":
    main()

=== 1. To'rt xil qarash ===
  \d+(?= so'm)   → ['12', '300']
  \b\d+\b(?! so'm) → ['5', '40', '50']
  (?<=\$)\d+    → ['40']
  (?<![$\d])\d+(?!\d)(?=\$) → ['50']
  ⭐ kontekst tekshirildi, lekin natijaga kirmadi

=== 2. Minglik ajratgich ===
        1234567 → 1 234 567
           1000 → 1 000
            999 → 999
   12345678.905 → 12 345 678.905

=== 3. ⚠️ Lookbehind cheklovi ===
  (?<=\d+)x      → PatternError: look-behind requires fixed-width pattern
  (?<=ab|xyz)c   → PatternError: look-behind requires fixed-width pattern
  (?:(?<=ab)|(?<=xyz))c → ['c', 'c']

=== 4. Parol siyosati: bitta naqsh ===
  'Salom123!'     → ✅
  'salom123!'     → ❌
  'Sal1!'         → ❌
  'SalomDunyo1'   → ❌
  'SALOM 123 !a'  → ✅

=== 5. Parol siyosati: aniq xabarlar ===
  'Salom123!'     → hammasi joyida
  'salom123!'     → katta harf
  'Sal1!'         → kamida 8 belgi
  'SalomDunyo1'   → maxsus belgi
  'SALOM 123 !a'  → hammasi joyida
  ⭐ foydalanuvchiga nima yetishmayotganini aytish — bitta naqshdan foydaliroq

r"""IPv4, URL, telefon va email naqshlari: sodda va tuzatilgan variantlar; chegara tuzoqlari; sinov jadvali; ipaddress va urllib bilan solishtirish."""

import ipaddress
import re
from urllib.parse import urlsplit

OKTET = r"(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])"
IP_SODDA = re.compile(r"(?:\d{1,3}\.){3}\d{1,3}")
IP_OKTET = re.compile(rf"{OKTET}(?:\.{OKTET}){{3}}")
IP_TOGRI = re.compile(rf"(?<![0-9.]){OKTET}(?:\.{OKTET}){{3}}(?![0-9]|\.[0-9])")

TELEFON = re.compile(
    r"""
    (?<![0-9])
    (?:\+?998[\s-]?)?
    \(?(?P<kod>[0-9]{2})\)?[\s-]?
    (?P<a>[0-9]{3})[\s-]?
    (?P<b>[0-9]{2})[\s-]?
    (?P<c>[0-9]{2})
    (?![0-9])
    """,
    re.VERBOSE,
)

URL = re.compile(r"https?://[^\s<>\"']+")
EMAIL = re.compile(r"(?<![\w.+-])[\w.+-]+@[\w-]+(?:\.[\w-]+)*\.[A-Za-z]{2,}(?![\w-])")


def main() -> None:
    print("=== 1. IPv4: uch bosqich ===")
    matn = "10.0.0.1 999.1.1.1 256.1.1.1 192.168.1.255 1.2.3.4.5"
    print(f"  sodda:          {IP_SODDA.findall(matn)}")
    print(f"  oktet bilan:    {IP_OKTET.findall(matn)}  ← 256 dan '56' olindi")
    print(f"  chegara bilan:  {IP_TOGRI.findall(matn)}")
    tekshiruv = [s for s in matn.split() if s.count(".") == 3]
    ipaddress_natija = []
    for s in tekshiruv:
        try:
            ipaddress.IPv4Address(s)
            ipaddress_natija.append(s)
        except ValueError:
            pass
    print(f"  ipaddress bilan mos: {ipaddress_natija == [s for s in tekshiruv if IP_TOGRI.fullmatch(s)]}")

    print("\n=== 2. Telefon: me'yorlash ===")
    for kirish in ("+998 90 123 45 67", "998901234567", "(90) 123-45-67", "90 123 45 67",
                   "+998-91-123-45-678", "karta 8600123456789012"):
        m = TELEFON.search(kirish)
        natija = f"+998{m['kod']}{m['a']}{m['b']}{m['c']}" if m else "—"
        print(f"  {kirish!r:24} → {natija}")

    print("\n=== 3. URL: oxiridagi tinish belgilari ===")
    matn = "Sayt: https://wisar.uz/kurs?id=5), yana http://x.io. va (https://a.uz/b)."
    xom = URL.findall(matn)
    tozalangan = [u.rstrip(".,;:!?)") for u in xom]
    print(f"  xom:        {xom}")
    print(f"  tozalangan: {tozalangan}")
    qismlar = urlsplit(tozalangan[0])
    print(f"  urlsplit: scheme={qismlar.scheme!r}, netloc={qismlar.netloc!r}, path={qismlar.path!r}, query={qismlar.query!r}")
    print("  ⭐ URL qismlari uchun regex emas, urllib.parse")

    print("\n=== 4. Email: amaliy naqsh ===")
    sinovlar = {
        "aziz@wisar.uz": True,
        "Aziz.K+kurs@mail.co.uz": True,
        "a@b": False,
        "aziz@@wisar.uz": False,
        "aziz@wisar.uz.": True,
        "@wisar.uz": False,
    }
    for kirish, kutilgan in sinovlar.items():
        topildi = EMAIL.search(kirish)
        natija = topildi[0] if topildi else None
        belgi = "✅" if (natija is not None) == kutilgan else "❌"
        print(f"  {belgi} {kirish!r:26} → {natija!r}")
    print("  ⚠️ naqsh shaklni tekshiradi; manzil mavjudligini faqat tasdiqlash xati isbotlaydi")


if __name__ == "__main__":
    main()

=== 1. IPv4: uch bosqich ===
  sodda:          ['10.0.0.1', '999.1.1.1', '256.1.1.1', '192.168.1.255', '1.2.3.4']
  oktet bilan:    ['10.0.0.1', '99.1.1.1', '56.1.1.1', '192.168.1.255', '1.2.3.4']  ← 256 dan '56' olindi
  chegara bilan:  ['10.0.0.1', '192.168.1.255']
  ipaddress bilan mos: True

=== 2. Telefon: me'yorlash ===
  '+998 90 123 45 67'      → +998901234567
  '998901234567'           → +998901234567
  '(90) 123-45-67'         → +998901234567
  '90 123 45 67'           → +998901234567
  '+998-91-123-45-678'     → —
  'karta 8600123456789012' → —

=== 3. URL: oxiridagi tinish belgilari ===
  xom:        ['https://wisar.uz/kurs?id=5),', 'http://x.io.', 'https://a.uz/b).']
  tozalangan: ['https://wisar.uz/kurs?id=5', 'http://x.io', 'https://a.uz/b']
  urlsplit: scheme='https', netloc='wisar.uz', path='/kurs', query='id=5'
  ⭐ URL qismlari uchun regex emas, urllib.parse

=== 4. Email: amaliy naqsh ===
  ✅ 'aziz@wisar.uz'            → 'aziz@wisar.uz'
  ✅ 'Aziz.K+kurs@mail.co.uz'   → 'Aziz.K+kurs@mail.co.uz'
  ✅ 'a@b'                      → None
  ✅ 'aziz@@wisar.uz'           → None
  ✅ 'aziz@wisar.uz.'           → 'aziz@wisar.uz'
  ✅ '@wisar.uz'                → None
  ⚠️ naqsh shaklni tekshiradi; manzil mavjudligini faqat tasdiqlash xati isbotlaydi

r"""Eksponensial o'sishni o'lchash; atomik guruh va possessiv miqdor bilan tuzatish; naqshni qayta yozish; kirish uzunligini cheklash."""

import re
import time


def olchov(naqsh: re.Pattern[str], matn: str) -> tuple[float, bool]:
    bosh = time.perf_counter()
    natija = naqsh.fullmatch(matn)
    return time.perf_counter() - bosh, natija is not None


def main() -> None:
    XAVFLI = re.compile(r"(a+)+")
    ATOMIK = re.compile(r"(?>a+)+")
    POSSESSIV = re.compile(r"(?:a++)+")
    SODDA = re.compile(r"a+")

    print("=== 1. ⚠️ (a+)+ — deyarli mos keladigan satr ===")
    vaqtlar = {}
    for n in (16, 18, 20, 22):
        vaqt, mos = olchov(XAVFLI, "a" * n + "!")
        vaqtlar[n] = vaqt
        print(f"  n={n}: mos={mos}")
    print(f"  n 16 → 22 (+6 belgi), vaqt kamida 20 barobar oshdi: {vaqtlar[22] / vaqtlar[16] >= 20}")
    print(f"  mos keladigan satrda esa tez: {olchov(XAVFLI, 'a' * 22)[0] < 0.01}")
    print("  ⭐ yaxshi test ma'lumoti muammoni yashiradi")

    print("\n=== 2. Tuzatishlar ===")
    matn = "a" * 22 + "!"
    for nom, naqsh in (("atomik (?>a+)+", ATOMIK), ("possessiv (?:a++)+", POSSESSIV), ("sodda a+", SODDA)):
        vaqt, mos = olchov(naqsh, matn)
        print(f"  {nom:20} mos={mos}, 10 ms dan tez: {vaqt < 0.01}")
    print(f"  natijalar bir xil (mos kelmaydi): {not XAVFLI.fullmatch('a' * 10 + '!') and not SODDA.fullmatch('a' * 10 + '!')}")

    print("\n=== 3. ⚠️ Possessiv miqdor ma'noni o'zgartirishi mumkin ===")
    print(f"  a*a  'aaa' da: {re.fullmatch(r'a*a', 'aaa') is not None}")
    print(f"  a*+a 'aaa' da: {re.fullmatch(r'a*+a', 'aaa') is not None}  ← a*+ oxirgi 'a' ni qaytarmadi")

    print("\n=== 4. Real shakl: so'zlar ro'yxati ===")
    XAVFLI_SOZLAR = re.compile(r"(?:\w+\s?)+:")
    XAVFSIZ_SOZLAR = re.compile(r"\w+(?:\s\w+)*:")
    matn = "salom dunyo " + "x" * 14 + "!"     # ⚠️ har qo'shimcha belgi vaqtni ~2 barobar oshiradi
    t1, _ = olchov(XAVFLI_SOZLAR, matn)
    t2, _ = olchov(XAVFSIZ_SOZLAR, matn)
    print(f"  (?:\\w+\\s?)+:     sekin: {t1 > 0.05}")
    print(f"  \\w+(?:\\s\\w+)*:  10 ms dan tez: {t2 < 0.01}")
    print(f"  ikkalasi mos keladigan satrda bir xil: "
          f"{bool(XAVFLI_SOZLAR.fullmatch('salom dunyo:')) == bool(XAVFSIZ_SOZLAR.fullmatch('salom dunyo:'))}")
    print("  ⭐ ixtiyoriy ajratgich (\\s?) o'rniga aniq tuzilma: so'z (bo'shliq so'z)*")

    print("\n=== 5. Kirish uzunligini cheklash ===")
    MAKS = 200

    def xavfsiz_tekshir(naqsh: re.Pattern[str], matn: str) -> str:
        if len(matn) > MAKS:
            return f"rad etildi: {len(matn)} > {MAKS} belgi"
        return "mos" if naqsh.fullmatch(matn) else "mos emas"

    print(f"  {xavfsiz_tekshir(XAVFSIZ_SOZLAR, 'salom dunyo:')}")
    print(f"  {xavfsiz_tekshir(XAVFSIZ_SOZLAR, 'a ' * 500)}")
    print("  ⭐ re da timeout yo'q — uzunlik chegarasi eng ishonchli himoya")


if __name__ == "__main__":
    main()

=== 1. ⚠️ (a+)+ — deyarli mos keladigan satr ===
  n=16: mos=False
  n=18: mos=False
  n=20: mos=False
  n=22: mos=False
  n 16 → 22 (+6 belgi), vaqt kamida 20 barobar oshdi: True
  mos keladigan satrda esa tez: True
  ⭐ yaxshi test ma'lumoti muammoni yashiradi

=== 2. Tuzatishlar ===
  atomik (?>a+)+       mos=False, 10 ms dan tez: True
  possessiv (?:a++)+   mos=False, 10 ms dan tez: True
  sodda a+             mos=False, 10 ms dan tez: True
  natijalar bir xil (mos kelmaydi): True

=== 3. ⚠️ Possessiv miqdor ma'noni o'zgartirishi mumkin ===
  a*a  'aaa' da: True
  a*+a 'aaa' da: False  ← a*+ oxirgi 'a' ni qaytarmadi

=== 4. Real shakl: so'zlar ro'yxati ===
  (?:\w+\s?)+:     sekin: True
  \w+(?:\s\w+)*:  10 ms dan tez: True
  ikkalasi mos keladigan satrda bir xil: True
  ⭐ ixtiyoriy ajratgich (\s?) o'rniga aniq tuzilma: so'z (bo'shliq so'z)*

=== 5. Kirish uzunligini cheklash ===
  mos
  rad etildi: 1000 > 200 belgi
  ⭐ re da timeout yo'q — uzunlik chegarasi eng ishonchli himoya

"""Nomli guruhli tokenizator; qator/ustun kuzatuvi; xatolarni joyi bilan ko'rsatish; rekursiv tahlilchi va hisoblovchi."""

import re
from dataclasses import dataclass

TOKEN = re.compile(
    r"""
    (?P<SON>\d+(?:\.\d+)?)
  | (?P<NOM>[A-Za-z_]\w*)
  | (?P<OP>\*\*|[-+*/^()=])
  | (?P<QATOR>\n)
  | (?P<BOSHLIQ>[ \t]+)
  | (?P<IZOH>\#[^\n]*)
  | (?P<XATO>.)
    """,
    re.VERBOSE,
)


@dataclass(frozen=True, slots=True)
class Token:
    tur: str
    qiymat: str
    qator: int
    ustun: int


class TilXatosi(Exception):
    pass


def korinish(t: Token) -> str:
    return {"OXIR": "matn oxiri", "QATOR": "qator oxiri"}.get(t.tur, repr(t.qiymat))


def tokenlarga_ajrat(kod: str) -> list[Token]:
    tokenlar, qator, qator_boshi = [], 1, 0
    for m in TOKEN.finditer(kod):
        tur, ustun = m.lastgroup, m.start() - qator_boshi + 1
        assert tur is not None
        if tur == "QATOR":
            tokenlar.append(Token("QATOR", "", qator, ustun))
            qator, qator_boshi = qator + 1, m.end()
        elif tur == "XATO":
            raise TilXatosi(f"{qator}:{ustun}: noma'lum belgi {m[0]!r}")
        elif tur not in ("BOSHLIQ", "IZOH"):
            qiymat = "^" if m[0] == "**" else m[0]
            tokenlar.append(Token(tur, qiymat, qator, ustun))
    tokenlar.append(Token("OXIR", "", qator, len(kod) - qator_boshi + 1))
    return tokenlar


class Hisoblovchi:
    def __init__(self) -> None:
        self.xotira: dict[str, float] = {}

    def bajar(self, kod: str) -> list[float]:
        self.tokenlar, self.i, natijalar = tokenlarga_ajrat(kod), 0, []
        while self.joriy.tur != "OXIR":
            if self.joriy.tur == "QATOR":
                self.i += 1
                continue
            natijalar.append(self.ifoda_qatori())
        return natijalar

    @property
    def joriy(self) -> Token:
        return self.tokenlar[self.i]

    def ol(self, tur: str, qiymat: str | None = None) -> Token:
        t = self.joriy
        if t.tur != tur or (qiymat is not None and t.qiymat != qiymat):
            kutilgan = qiymat or tur
            raise TilXatosi(f"{t.qator}:{t.ustun}: {kutilgan!r} kutilgan, {korinish(t)} keldi")
        self.i += 1
        return t

    def ifoda_qatori(self) -> float:
        if self.joriy.tur == "NOM" and self.tokenlar[self.i + 1].qiymat == "=":
            nom = self.ol("NOM").qiymat
            self.ol("OP", "=")
            self.xotira[nom] = self.qoshish()
            return self.xotira[nom]
        return self.qoshish()

    def qoshish(self) -> float:
        natija = self.kopaytirish()
        while self.joriy.qiymat in ("+", "-"):
            op = self.ol("OP").qiymat
            natija = natija + self.kopaytirish() if op == "+" else natija - self.kopaytirish()
        return natija

    def kopaytirish(self) -> float:
        natija = self.daraja()
        while self.joriy.qiymat in ("*", "/"):
            t = self.ol("OP")
            ong = self.daraja()
            if t.qiymat == "/" and ong == 0:
                raise TilXatosi(f"{t.qator}:{t.ustun}: nolga bo'lish")
            natija = natija * ong if t.qiymat == "*" else natija / ong
        return natija

    def daraja(self) -> float:
        asos = self.birlik()
        if self.joriy.qiymat == "^":
            self.ol("OP")
            return asos ** self.daraja()          # o'ngdan chapga: 2^3^2 = 2^9
        return asos

    def birlik(self) -> float:
        t = self.joriy
        if t.qiymat == "-":
            self.ol("OP")
            return -self.birlik()
        if t.tur == "SON":
            return float(self.ol("SON").qiymat)
        if t.tur == "NOM":
            nom = self.ol("NOM").qiymat
            if nom not in self.xotira:
                raise TilXatosi(f"{t.qator}:{t.ustun}: {nom!r} aniqlanmagan")
            return self.xotira[nom]
        if t.qiymat == "(":
            self.ol("OP", "(")
            natija = self.qoshish()
            self.ol("OP", ")")
            return natija
        raise TilXatosi(f"{t.qator}:{t.ustun}: kutilmagan {korinish(t)}")


def main() -> None:
    print("=== 1. Tokenlar ===")
    for t in tokenlarga_ajrat("narx = 12.5 * (soni + 2)  # izoh")[:8]:
        print(f"  {t.qator}:{t.ustun:<3} {t.tur:5} {t.qiymat!r}")

    print("\n=== 2. Dastur ===")
    dastur = """\
narx = 45000
soni = 3
chegirma = 0.1
jami = narx * soni * (1 - chegirma)
2 ^ 3 ^ 2
-(2 + 3) * 4 ** 2
"""
    hisob = Hisoblovchi()
    for qator, natija in zip(dastur.splitlines(), hisob.bajar(dastur)):
        print(f"  {qator:38} → {natija:g}")
    print(f"  xotira: {hisob.xotira}")

    print("\n=== 3. Xatolar joyi bilan ===")
    for kod in ("x = 5 $ 2", "y = (1 + 2", "3 / (2 - 2)", "a + 1", "narx = * 3"):
        try:
            Hisoblovchi().bajar(kod)
        except TilXatosi as xato:
            print(f"  {kod!r:14} → {xato}")

    print("\n=== 4. Ko'p qatorli xato ===")
    try:
        Hisoblovchi().bajar("a = 1\nb = a +\nc = 3")
    except TilXatosi as xato:
        print(f"  {xato}")
    print("  ⭐ regex — tokenlar va joylar; tuzilma — tahlilchi")


if __name__ == "__main__":
    main()

=== 1. Tokenlar ===
  1:1   NOM   'narx'
  1:6   OP    '='
  1:8   SON   '12.5'
  1:13  OP    '*'
  1:15  OP    '('
  1:16  NOM   'soni'
  1:21  OP    '+'
  1:23  SON   '2'

=== 2. Dastur ===
  narx = 45000                           → 45000
  soni = 3                               → 3
  chegirma = 0.1                         → 0.1
  jami = narx * soni * (1 - chegirma)    → 121500
  2 ^ 3 ^ 2                              → 512
  -(2 + 3) * 4 ** 2                      → -80
  xotira: {'narx': 45000.0, 'soni': 3.0, 'chegirma': 0.1, 'jami': 121500.0}

=== 3. Xatolar joyi bilan ===
  'x = 5 $ 2'    → 1:7: noma'lum belgi '$'
  'y = (1 + 2'   → 1:11: ')' kutilgan, matn oxiri keldi
  '3 / (2 - 2)'  → 1:3: nolga bo'lish
  'a + 1'        → 1:1: 'a' aniqlanmagan
  'narx = * 3'   → 1:8: kutilmagan '*'

=== 4. Ko'p qatorli xato ===
  2:8: kutilmagan qator oxiri
  ⭐ regex — tokenlar va joylar; tuzilma — tahlilchi

re.findall(r"[0-9]{9}", "8600123456789012")        # ❌ karta ichidan "telefon"
re.findall(r"(?<![0-9])[0-9]{9}(?![0-9])", s)      # ✅

re.compile(r"(\w+\s?)+$")                          # ❌ ReDoS
re.compile(r"\w+(?:\s\w+)*$")                      # ✅

NAQSH.fullmatch(request.body)                      # ❌
if len(s) <= 1000 and NAQSH.fullmatch(s): ...      # ✅

r"(?<=USD|EUR |so'm )\d+"                          # ❌ PatternError
r"(?:(?<=USD)|(?<=EUR )|(?<=so'm ))\d+"            # ✅

URL.findall("sayt: https://wisar.uz.")             # ['https://wisar.uz.']
[u.rstrip(".,;:!?)") for u in URL.findall(s)]      # ✅

re.findall(r"\d+|[a-z]+|[-+*/]", "2 $ 3")          # ❌ '$' jim tashlandi
# ✅ oxirida (?P<XATO>.) va xato ko'tarish

re.search(foydalanuvchi_naqshi, matn)              # ❌ ReDoS
# ✅ re.escape (oddiy qidiruv) yoki google-re2

IP.fullmatch(s)                                    # ⚠️ faqat shakl
ipaddress.ip_address(s)                            # ✅ IPv4 va IPv6

import re
1.  print(re.findall(r"\w+(?=!)", "salom! dunyo"))
2.  print(re.findall(r"\b\w+\b(?!!)", "salom! dunyo"))
3.  print(re.findall(r"(?<=#)\w+", "#python va #rust"))
4.  print(re.findall(r"(?<!#)\b\w+", "#python va #rust"))
5.  print(re.sub(r"(?<=\d)(?=(?:\d{3})+$)", ",", "1000000"))
6.  print(bool(re.fullmatch(r"(?=.*\d).{4,}", "abcd")))
7.  print(re.fullmatch(r"a*+a", "aa"))
8.  print(bool(re.fullmatch(r"(?>a*)b", "aab")))
9.  print(re.findall(r"[0-9]{3}", "12345"))
10. print(re.findall(r"(?<![0-9])[0-9]{3}(?![0-9])", "123 12345"))
11. print(bool(re.fullmatch(r"(\()?\d+(?(1)\))", "(42")))
12. print(re.findall(rb"[a-z]+", b"abc 12 de"))

1.  KARTA = re.compile(r"[0-9]{16}")          # 20 xonali son ichidan ham topadi

2.  NARX = re.compile(r"(?<=so'm |USD )\d+")

3.  SOZLAR = re.compile(r"^(\w+\s*)+$")       # uzun matnda osilib qoladi

4.  def email_bormi(s):
        return re.search(r"\S+@\S+", s) is not None   # "a@b" va "x@@y" ham o'tadi

5.  TOKEN = re.compile(r"\d+|[a-z]+|[-+*/]")
    def tokenlar(kod):
        return TOKEN.findall(kod)             # noma'lum belgilar yo'qolib ketadi