Python re.match Anchoring — Silent Null Cost 3 Hours

import re

log_line = "2024-06-15 ERROR: Disk quota exceeded on /dev/sda1"

# re.match only checks the START of the string.
# Our pattern is looking for 'ERROR' — but that's not at position 0.
match_result = re.match(r"ERROR", log_line)
print("re.match result:", match_result)  # None — won't find it mid-string

# re.search scans the whole string — finds 'ERROR' wherever it lives.
search_result = re.search(r"ERROR", log_line)
print("re.search result:", search_result)  # Match object
print("Found at position:", search_result.start())  # character index

# re.findall with NO groups — returns plain list of matched strings.
log_block = """
2024-06-15 ERROR: Disk quota exceeded
2024-06-16 INFO: Backup completed
2024-06-17 ERROR: Connection timeout
2024-06-17 ERROR: Retry limit reached
"""

# Find every date stamp in the log block.
dates_found = re.findall(r"\d{4}-\d{2}-\d{2}", log_block)
print("All dates:", dates_found)

# re.findall WITH capture groups — returns list of TUPLES, one per match.
# Each tuple contains the text captured by each group in order.
date_and_level = re.findall(r"(\d{4}-\d{2}-\d{2}) (\w+):", log_block)
print("Date + level tuples:", date_and_level)

import re
from dataclasses import dataclass
from typing import Optional

# A realistic nginx-style access log line
access_log_line = '192.168.1.42 - alice [15/Jun/2024:10:23:45 +0000] "GET /api/users HTTP/1.1" 200 1523'

# Named groups make each field self-documenting.
# (?P<name>pattern) — name must be a valid Python identifier.
nginx_pattern = re.compile(
    r'(?P<client_ip>\d+\.\d+\.\d+\.\d+)'   # IP address
    r' - (?P<username>\S+)'                   # dash then username
    r' \[(?P<timestamp>[^\]]+)\]'             # timestamp inside brackets
    r' "(?P<method>\w+) (?P<path>\S+)'        # HTTP method and path
    r'.*?" (?P<status_code>\d{3})'            # status code
    r' (?P<bytes_sent>\d+)'                    # response size
)

match = nginx_pattern.search(access_log_line)

if match:
    # groupdict() returns all named groups as a plain dict — great for further processing
    fields = match.groupdict()
    print("Parsed fields:")
    for field_name, value in fields.items():
        print(f"  {field_name}: {value}")

    # You can also access individual named groups directly
    print(f"\nClient: {match.group('username')} from {match.group('client_ip')}")
    print(f"Request: {match.group('method')} {match.group('path')}")
    print(f"Response: {match.group('status_code')} ({match.group('bytes_sent')} bytes)")

# Bonus — using groupdict() to feed a dataclass directly
@dataclass
class AccessLogEntry:
    client_ip: str
    username: str
    timestamp: str
    method: str
    path: str
    status_code: str
    bytes_sent: str

if match:
    log_entry = AccessLogEntry(**match.groupdict())
    print(f"\nDataclass status_code field: {log_entry.status_code}")

import re
import time

# ── Compiled Pattern Performance Demo ──────────────────────────────────────

# Compile ONCE outside any loop — the pattern object is reusable and thread-safe
email_pattern = re.compile(
    r'[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}'
)

sample_emails = [
    "reach us at support@thecodeforge.io for help",
    "no email here, move on",
    "forward to admin@company.co.uk immediately",
    "billing@startup.dev is the right contact",
]

extracted_emails = []
for line in sample_emails:
    # .search() called on the compiled object — no recompilation
    result = email_pattern.search(line)
    if result:
        extracted_emails.append(result.group())

print("Emails found:", extracted_emails)

# ── Lookahead Examples ─────────────────────────────────────────────────────

# POSITIVE LOOKAHEAD: match a number only if it's followed by 'px'
# The 'px' itself is NOT included in the match
css_values = "margin: 16px; opacity: 0.8; padding: 24px; font-size: 14px;"

# (?=px) asserts 'px' must follow, but stays out of the match
px_numbers = re.findall(r'\d+(?=px)', css_values)
print("Pixel values:", px_numbers)  # only the numbers, no 'px' attached

# NEGATIVE LOOKAHEAD: match 'http' only when NOT followed by 's'
# Useful for finding insecure URLs in config files
url_list = "http://insecure.com and https://secure.com and http://also-bad.net"

# (?!s) means: 'http' must NOT be followed by 's'
insecure_urls = re.findall(r'http(?!s)://\S+', url_list)
print("Insecure URLs:", insecure_urls)

# LOOKBEHIND: match a number only when preceded by '$'
price_text = "Cost is $49.99, weight is 2.5kg, discount $10.00"

# (?<=\$) asserts '$' must precede — dollar sign not included in match
prices = re.findall(r'(?<=\$)[\d.]+', price_text)
print("Prices (no $ sign):", prices)

# ── re.sub with a function — dynamic replacement ───────────────────────────

def redact_digits(match_obj):
    """Replace every digit in a matched SSN with an asterisk."""
    return '*' * len(match_obj.group())  # preserve length for formatting

record = "Patient SSN: 123-45-6789, DOB: 1990-03-21"
# Match the SSN pattern and apply our custom replacement function
redacted = re.sub(r'\d{3}-\d{2}-\d{4}', redact_digits, record)
print("Redacted record:", redacted)

import re

# ── re.sub with backreferences — reformatting dates ────────────────────────

# Dates from a US-style data export: MM/DD/YYYY
# We want ISO format: YYYY-MM-DD
raw_export = "Invoice date: 06/15/2024, Due date: 07/01/2024, Paid: 06/20/2024"

# Capture groups: group 1=month, group 2=day, group 3=year
# Replacement uses \g<name> syntax — more readable than \3\1\2 positional
date_pattern = re.compile(r'(?P<month>\d{2})/(?P<day>\d{2})/(?P<year>\d{4})')
iso_formatted = date_pattern.sub(r'\g<year>-\g<month>-\g<day>', raw_export)
print("ISO dates:", iso_formatted)

# ── re.sub with a callable — smart title-casing ────────────────────────────

def title_case_word(match_obj):
    """Capitalise the matched word, but skip common articles."""
    word = match_obj.group()
    skip_words = {'a', 'an', 'the', 'in', 'on', 'at', 'of', 'and', 'but', 'or'}
    # Only lowercase the word if it's not the first word (position > 0)
    if word.lower() in skip_words and match_obj.start() > 0:
        return word.lower()
    return word.capitalize()

article_title = "the quick brown fox jumps over a lazy dog and wins"
proper_title = re.sub(r'\b\w+\b', title_case_word, article_title)
print("Title cased:", proper_title)

# ── re.split — splitting on multiple delimiters at once ────────────────────

# A user typed tags in whatever format they felt like.
# We want a clean list regardless of separator style.
user_tags_input = "python,  regex ;  web-dev | data-science,parsing"

# Split on: comma, semicolon, pipe, or any surrounding whitespace
tag_list = re.split(r'[\s,;|]+', user_tags_input.strip())
print("Tags:", tag_list)

# ── re.split with a capture group preserves the delimiter in output ─────────

sentence = "First point. Second point! Third point? Fourth point."

# Wrapping the delimiter in a group keeps punctuation in the result list
parts_with_punctuation = re.split(r'([.!?])', sentence)
print("Split with delimiters:", parts_with_punctuation)

# Pair each sentence fragment back with its punctuation mark
sentences = [
    parts_with_punctuation[i].strip() + parts_with_punctuation[i + 1]
    for i in range(0, len(parts_with_punctuation) - 1, 2)
    if parts_with_punctuation[i].strip()
]
print("Reconstructed sentences:", sentences)

import re

# ── Validation: Exact ZIP code match ───────────────────────────────────────

# Without anchors, r'\d{5}' matches inside a longer string
bad_pattern = re.compile(r'\d{5}')
print("Bad match:", bad_pattern.search('My zip is 12345-6789'))  # matches '12345'

# With anchors, only exact 5-digit strings match
good_pattern = re.compile(r'^\d{5}$')
print("Good match:", good_pattern.search('12345-6789'))  # None
print("Good match:", good_pattern.search('12345'))  # Match

# ── Extraction with finditer for position info ─────────────────────────────

text = "Report generated on 2024-06-15 for batch job 4321. Next scheduled run: 2024-06-20."

date_pattern = re.compile(r'\d{4}-\d{2}-\d{2}')
for match in date_pattern.finditer(text):
    print(f"Found '{match.group()}' at position {match.start()}-{match.end()}")

# ── Sanitization with callable and logging ─────────────────────────────────

import logging
logging.basicConfig(level=logging.INFO)

password_hint = "My password is Hunter2! Use the same for bank?"

def redact_sensitive(match):
    word = match.group()
    # Only redact if it looks like a password (context heuristic)
    if match.start() > 0 and text[match.start() - 1] == ' ':
        logging.info(f"Redacted sensitive word at position {match.start()}")
        return '*' * len(word)
    return word

# Redact words that follow 'password is ' — not perfect but demonstrates callable
sanitized = re.sub(r'\b\w+\b', redact_sensitive, password_hint)
print("Sanitized:", sanitized)

# ── Do NOT use regex for HTML parsing ─────────────────────────────────────

html = "<div class='content'>Hello <b>World</b></div>"
# This regex breaks on nested tags:
result = re.findall(r'<b>(.*)</b>', html)
print("Regex inside HTML:", result)  # works here, but fails with nested <b> tags

# Better: use BeautifulSoup or html.parser