రెగ్యులర్ ఎక్స్‌ప్రెషన్స్ (Regex & Pattern Matching)

1 రెగ్యులర్ ఎక్స్‌ప్రెషన్స్ అంటే ఏమిటి? (Regex Engine Architecture)

రెగ్యులర్ ఎక్స్‌ప్రెషన్ అనేది టెక్స్ట్‌లోని ఒక నిర్దిష్ట అమరికను (Text Pattern) వివరించడానికి ఉపయోగించే ఒక సంక్షిప్త సంకేత భాష. పైథాన్‌లో Regex సపోర్ట్ కోసం ఇన్-బిల్ట్ re మాడ్యూల్ ఉంది.

2 రా స్ట్రింగ్స్ ప్రాముఖ్యత (Why Raw Strings r"" are Mandatory)

సాధారణ పైథాన్ స్ట్రింగ్స్‌లో బ్యాక్‌స్లాష్ అనేది ఒక ఎస్కేప్ క్యారెక్టర్ (ఉదా: అంటే న్యూలైన్, అంటే ట్యాబ్). కానీ రెగ్యులర్ ఎక్స్‌ప్రెషన్స్‌లో కూడా d, w, s లాంటి బ్యాక్‌స్లాష్ సింబల్స్ వాడతాము.

సాధారణ స్ట్రింగ్ వాడితే బ్యాక్‌స్లాష్‌ను డబుల్ ఎస్కేప్ "\d" చేయాల్సి వస్తుంది. దీనివల్ల కోడ్ చదవడానికి వికృతంగా మారుతుంది. పరిష్కారం: స్ట్రింగ్ ముందు r (Raw String) పెట్టడం!
pattern = r"d{3}-d{4}"
రా స్ట్రింగ్ వాడినప్పుడు పైథాన్ బ్యాక్‌స్లాష్‌లను ఎస్కేప్ చేయకుండా యాజిటీజ్‌గా Regex ఇంజిన్‌కు అందజేస్తుంది.

3 ప్రాథమిక మెటాక్యారెక్టర్లు (Meta-Characters: ^, $, ., [], |)

రెగ్యులర్ ఎక్స్‌ప్రెషన్స్‌లో అక్షరాలకు ప్రత్యేక అర్థాన్ని ఇచ్చే చిహ్నాలను మెటాక్యారెక్టర్లు (Meta-characters) అంటారు:

4 స్పెషల్ సీక్వెన్సెస్ (d, D, w, W, s, S, )

పదే పదే [0-9] లేదా [a-zA-Z0-9_] అని పెద్ద పెద్ద రేంజెస్ రాయకుండా పైథాన్ షార్ట్‌కట్ సీక్వెన్సులను అందిస్తుంది:

5 క్వాంటిఫైయర్స్ — పునరావృతం నియంత్రణ (*, +, ?, {m,n})

ఒక అక్షరం ఎన్నిసార్లు రావాలో నిర్ణయించడానికి క్వాంటిఫైయర్లను ఉపయోగిస్తాము:

• *: 0 లేదా అంతకంటే ఎక్కువ సార్లు (ఉదా: d*).
• +: కనీసం 1 సారి లేదా అంతకంటే ఎక్కువ సార్లు తప్పనిసరిగా ఉండాలి (ఉదా: d+).
• ?: 0 లేదా 1 సారి మాత్రమే (ఐచ్ఛికం - Optional: ఉదా: https? అనేది "http" మరియు "https" రెండింటినీ మ్యాచ్ చేస్తుంది).
• {n}: ఖచ్చితంగా $n$ సార్లు మాత్రమే ఉండాలి (ఉదా: d{10} అంటే ఖచ్చితంగా 10 అంకెలు).
• {min,max}: కనీసం min నుండి గరిష్టంగా max సార్లు (ఉదా: w{4,12} పాస్‌వర్డ్ పొడవు 4 నుండి 12).

6 కోడ్ డెమో 1: ప్రాథమిక మెటాక్యారెక్టర్లు & మొబైల్ నంబర్ వాలిడేటర్

భారతీయ 10-అంకెల మొబైల్ నంబర్ (6, 7, 8, 9 తో ప్రారంభమయ్యేవి) ని Regex ద్వారా ఎలా ధృవీకరించవచ్చో పరిశీలించండి:

# భారతీయ మొబైల్ నంబర్ వాలిడేషన్ డెమో
import re

# Regex ప్యాటర్న్ విశ్లేషణ:
# ^          -> ప్రారంభం
# (\+91[\-\s]?)? -> ఐచ్ఛిక +91 కంట్రీ కోడ్
# [6-9]      -> మొదటి అంకె 6, 7, 8 లేదా 9 మాత్రమే ఉండాలి
# \d{9}      -> మిగిలిన 9 అంకెలు (0-9)
# $          -> ముగింపు
mobile_pattern = r"^(\+91[\-\s]?)?[6-9]\d{9}$"

test_numbers = [
    "9876543210",       # ✅ సరైన నంబర్
    "+91 9123456789",   # ✅ కంట్రీ కోడ్‌తో సరైన నంబర్
    "5123456789",       # ❌ 5 తో ప్రారంభమైంది (చెల్లదు)
    "98765432",         # ❌ కేవలం 8 అంకెలు మాత్రమే
    "987654321099"      # ❌ 12 అంకెలు (చాలా పొడవు)
]

print("=== భారతీయ మొబైల్ నంబర్ ధృవీకరణ నివేదిక ===")
for num in test_numbers:
    is_valid = bool(re.match(mobile_pattern, num.strip()))
    status = "✅ సరైన మొబైల్ నంబర్" if is_valid else "❌ చెల్లని మొబైల్ నంబర్"
    print(f"నంబర్: {num:<18} ──▶ {status}")

7 పైథాన్ re మాడ్యూల్ ఫంక్షన్లు (search, match, findall, sub)

re మాడ్యూల్‌లో అత్యంత ఎక్కువగా ఉపయోగించే 5 ప్రధాన ఫంక్షన్లు:

8 క్యాప్చరింగ్ గ్రూప్స్ & నేమ్డ్ గ్రూప్స్ (Capturing & Named Groups)

ప్యాటర్న్ లోపల రౌండ్ బ్రాకెట్లు (...) పెట్టి నిర్దిష్ట భాగాలను ప్రత్యేకంగా సేకరించవచ్చు:

• ప్రాథమిక గ్రూప్స్: r"(d{2})-(d{2})-(d{4})"
match.group(1) -> రోజు, match.group(2) -> నెల, match.group(3) -> సంవత్సరం.
• నేమ్డ్ గ్రూప్స్ (Python Named Groups): గ్రూప్‌లకు పేర్లు పెట్టడం:
  r"(?P<day>d{2})-(?P<month>d{2})-(?P<year>d{4})"
match.group("year") లేదా match.groupdict() ద్వారా డిక్షనరీగా పొందవచ్చు!

9 కోడ్ డెమో 2: నేమ్డ్ గ్రూప్స్ & లాగ్ రికార్డ్ పార్సింగ్

సర్వర్ లాగ్ లైన్ నుండి నేమ్డ్ గ్రూప్స్ ద్వారా IP, టైమ్‌స్టాంప్, మరియు స్టేటస్ కోడ్‌ను సంగ్రహించే కోడ్ చూడండి:

# నేమ్డ్ గ్రూప్స్ (Named Capturing Groups) డెమో
import re

log_entry = "2026-11-02 10:45:12 | IP: 192.168.1.105 | STATUS: 200 | URL: /api/v1/checkout"

log_regex = r"(?P\d{4}-\d{2}-\d{2})\s(?P\d{2}:\d{2}:\d{2})\s\|\sIP:\s(?P\d+\.\d+\.\d+\.\d+)\s\|\sSTATUS:\s(?P\d+)\s\|\sURL:\s(?P\S+)"

match = re.search(log_regex, log_entry)

if match:
    data = match.groupdict() # అన్ని గ్రూప్‌లను డిక్షనరీగా ఇస్తుంది!
    print("=== విశ్లేషించబడిన లాగ్ డేటా (Structured Dictionary) ===")
    for key, val in data.items():
        print(f"{key:<12} : {val}")
else:
    print("లాగ్ ఫార్మాట్ సరిపోలలేదు.")

10 కాంపిలేషన్ ఫ్లాగ్స్ (re.IGNORECASE, re.MULTILINE, re.VERBOSE)

Regex ఇంజిన్ ప్రవర్తనను మార్చడానికి ఫ్లాగ్‌లను రెండవ లేదా మూడవ ఆర్గ్యుమెంట్‌గా పంపుతాము:

• re.IGNORECASE (లేదా re.I): అప్పర్ మరియు లోయర్ కేస్ తేడా లేకుండా వెతుకుతుంది.
• re.MULTILINE (లేదా re.M): ^ మరియు $ లు మొత్తం టెక్స్ట్ ప్రారంభం/ముగింపు కాకుండా ప్రతి లైన్ ప్రారంభం/ముగింపుకు వర్తిస్తాయి.
• re.DOTALL (లేదా re.S): చుక్క . న్యూలైన్ ను కూడా మ్యాచ్ చేస్తుంది.
• re.VERBOSE (లేదా re.X): అతిపెద్ద సంక్లిష్టమైన Regex లో కామెంట్స్ మరియు స్పేస్‌లు పెట్టి అందంగా రాయడానికి అనుమతిస్తుంది!

11 ప్రముఖ రియల్-వరల్డ్ రెగెక్స్ ప్యాటర్న్స్ (Email, PAN Card, Strong Password)

భారతదేశంలో మరియు అంతర్జాతీయంగా సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌లో అత్యధికంగా వాడే అధికారిక Regex ప్యాటర్న్స్:

12 కామన్ బిగినర్స్ మిస్టేక్స్ & ReDoS సైబర్ వాలనరబిలిటీ

• Mistake 1: Raw String ప్రిఫిక్స్ r"" మర్చిపోవడం: దీనివల్ల  అంటే బ్యాక్‌స్పేస్ గా మారి ప్యాటర్న్ ఫెయిల్ అవుతుంది.
• Mistake 2: re.match() మరియు re.search() గందరగోళం: మధ్యలో ఉన్న పదాన్ని వెతకాలంటే search() వాడాలి; match() కేవలం మొదట్లో మాత్రమే చూస్తుంది.
• Security Alert: ReDoS (Regular Expression Denial of Service): నెస్టెడ్ క్వాంటిఫైయర్స్ (ఉదా: (a+)+$) రాసినప్పుడు, మ్యాచ్ అవ్వని పొడవైన స్ట్రింగ్ వస్తే ఇంజిన్ బిలియన్ల కొద్దీ కాంబినేషన్లను బ్యాక్‌ట్రాక్ చేసి CPU ని 100% చేసి సర్వర్‌ను క్రాష్ చేస్తుంది! ఎల్లప్పుడూ నెస్టెడ్ ప్లస్/స్టార్ ప్యాటర్న్స్ నివారించాలి.

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Enterprise Multi-Document KYC Verification Engine"

ఈ పదవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (మెటాక్యారెక్టర్లు, క్వాంటిఫైయర్స్, re.search, findall, sub, నేమ్డ్ గ్రూప్స్, మాస్కింగ్) కలగలిపి — ఒక బ్యాంకింగ్ కస్టమర్ యొక్క ఈమెయిల్, మొబైల్, పాన్‌కార్డ్, ఆధార్ నంబర్లను తనిఖీ చేసి సురక్షితమైన డిజిటల్ KYC సర్టిఫికెట్ తయారుచేసే Enterprise Multi-Document KYC Verification Engine ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 10 మినీ ప్రాజెక్ట్: Enterprise Multi-Document KYC Engine
# కాన్సెప్ట్స్: re.compile(), re.match(), re.sub() Masking,
#             Email, PAN, Mobile, Aadhaar Validation & Compliance Audit
# =====================================================================
import re

# ప్రీ-కంపైల్డ్ Regex ప్యాటర్న్స్ (గరిష్ట వేగం కోసం)
PATTERNS = {
    "email": re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+$"),
    "mobile": re.compile(r"^(\+91[\-\s]?)?[6-9]\d{9}$"),
    "pan": re.compile(r"^[A-Z]{5}[0-9]{4}[A-Z]$"),
    "aadhaar": re.compile(r"^[2-9]\d{3}\s\d{4}\s\d{4}$")
}

def verify_customer_kyc(profile: dict):
    """
    కస్టమర్ పత్రాలను ధృవీకరించి అధికారిక KYC నివేదికను రూపొందిస్తుంది.
    """
    print("\n" + "=" * 74)
    print(f"{'🏛️ మన డిజిటల్ బ్యాంక్ — ఆటోమేటెడ్ KYC ధృవీకరణ నివేదిక 2026':^74}")
    print("=" * 74)
    print(f"దరఖాస్తుదారుని పేరు : {profile['name']}")
    print("-" * 74)
    print(f"{'డాక్యుమెంట్ రకం':<20} {'నమోదైన విలువ':<22} {'ధృవీకరణ ఫలితం':<28}")
    print("-" * 74)

    all_verified = True

    # 1. ఈమెయిల్ చెక్
    email_ok = bool(PATTERNS["email"].match(profile["email"].strip()))
    status_email = "✅ అధీకృత ఈమెయిల్" if email_ok else "❌ చెల్లని ఈమెయిల్ ఫార్మాట్"
    print(f"{'ఈమెయిల్ (Email)':<20} {profile['email']:<22} {status_email:<28}")
    if not email_ok: all_verified = False

    # 2. మొబైల్ చెక్
    mobile_ok = bool(PATTERNS["mobile"].match(profile["mobile"].strip()))
    status_mobile = "✅ సరైన భారతీయ మొబైల్" if mobile_ok else "❌ చెల్లని మొబైల్ నంబర్"
    print(f"{'మొబైల్ నంబర్':<20} {profile['mobile']:<22} {status_mobile:<28}")
    if not mobile_ok: all_verified = False

    # 3. పాన్‌కార్డ్ చెక్
    pan_ok = bool(PATTERNS["pan"].match(profile["pan"].strip().upper()))
    status_pan = "✅ NSDL వెరిఫైడ్ PAN" if pan_ok else "❌ చెల్లని PAN కార్డ్ నంబర్"
    print(f"{'పాన్‌కార్డ్ (PAN)':<20} {profile['pan'].upper():<22} {status_pan:<28}")
    if not pan_ok: all_verified = False

    # 4. ఆధార్ చెక్ & మాస్కింగ్ (UIDAI నిబంధనల ప్రకారం మొదటి 8 అంకెలు దాచాలి)
    aadhaar_raw = profile["aadhaar"].strip()
    aadhaar_ok = bool(PATTERNS["aadhaar"].match(aadhaar_raw))
    masked_aadhaar = re.sub(r"^\d{4}\s\d{4}", "XXXX XXXX", aadhaar_raw) if aadhaar_ok else aadhaar_raw
    status_aadhaar = "✅ UIDAI వెరిఫైడ్ & మాస్క్డ్" if aadhaar_ok else "❌ చెల్లని ఆధార్ నంబర్"
    print(f"{'ఆధార్ కార్డ్':<20} {masked_aadhaar:<22} {status_aadhaar:<28}")
    if not aadhaar_ok: all_verified = False

    print("=" * 74)
    if all_verified:
        print(f"{'🎉 అభినందనలు! మీ KYC విజయవంతంగా ఆమోదించబడింది (KYC_STATUS: APPROVED)':^74}")
    else:
        print(f"{'⚠️ హెచ్చరిక: కొన్ని పత్రాలు చెల్లవు. దయచేసి వివరాలను సరిచూసుకోండి (REJECTED)':^74}")
    print("=" * 74 + "\n")

# లైవ్ రన్ టెస్ట్
test_profile = {
    "name": "బాలాజీ రావు",
    "email": "balaji.tech@ourcompiler.com",
    "mobile": "+91 9876543210",
    "pan": "ABCDE1234F",
    "aadhaar": "4521 8901 2345"
}

verify_customer_kyc(test_profile)

★ ఈ అధ్యాయంపై ప్రాక్టీస్ క్విజ్ (Knowledge Check)