Regular Expressions with re

import re

zip_code = "80202"

if re.match(r"^\d{5}$", zip_code):
    print("Looks like a valid 5-digit zip code")
else:
    print("Not a valid zip code shape")

# "Looks like a valid 5-digit zip code"

# Checking a prefix — regex is unnecessary here
if filename.startswith("invoice_"):      # clear
    ...
# vs
if re.match(r"^invoice_", filename):      # works, but adds no value over the line above

# Checking for a substring — same story
if "error" in log_line.lower():           # clear and fast
    ...
# vs
if re.search(r"error", log_line, re.IGNORECASE):   # heavier than it needs to be

import re

re.match(r"\d+", "42 apples")     # matches — "42" is found at position 0
re.match(r"\d+", "I have 42 apples")  # None — the string does not START with digits

re.search(r"\d+", "I have 42 apples")   # matches — finds "42" anywhere in the string
re.search(r"\d+", "no numbers here")     # None — no digits anywhere

re.findall(r"\d+", "I have 42 apples and 7 oranges")
# ['42', '7'] — a plain list of strings, every match found

re.sub(r"\d+", "#", "I have 42 apples and 7 oranges")
# "I have # apples and # oranges"

# Redacting something sensitive — a real, common use
re.sub(r"\d{3}-\d{2}-\d{4}", "XXX-XX-XXXX", "SSN on file: 123-45-6789")
# "SSN on file: XXX-XX-XXXX"

re.split(r"[,;]\s*", "apples, oranges;bananas,  grapes")
# ['apples', 'oranges', 'bananas', 'grapes']
# str.split(",") alone could not handle the mix of commas AND semicolons

re.search(r"cat", "concatenate")   # matches — "cat" appears inside "conCATenate"

re.findall(r"c.t", "cat cot cut cят c t")
# ['cat', 'cot', 'cut', 'c t'] — "cят" is skipped, since я and т are TWO characters, not one

re.findall(r"[aeiou]", "hello world")   # ['e', 'o', 'o']   — any single vowel
re.findall(r"[a-z]", "Hi 123")           # ['i']              — lowercase a through z only
re.findall(r"[A-Za-z0-9]", "Hi 123!")    # ['H','i','1','2','3']  — letters and digits, not '!' or the space
re.findall(r"[^0-9]", "abc123")          # ['a','b','c']       — ^ inside [] means NOT these characters

\d   any digit           — equivalent to [0-9]
\D   any NON-digit        — equivalent to [^0-9]
\w   any "word" character — letters, digits, and underscore, equivalent to [A-Za-z0-9_]
\W   any NON-word character
\s   any whitespace       — space, tab, newline
\S   any NON-whitespace character

re.findall(r"\d", "Room 204, Suite 5B")     # ['2','0','4','5']
re.findall(r"\w+", "user_name-42 field!")   # ['user_name', '42', 'field'] — the dash and ! break \w+

*       zero or more
+       one or more
?       zero or one (optional)
{n}     exactly n times
{n,}    n or more times
{n,m}   between n and m times, inclusive

re.findall(r"\d+", "room 4, hall 12, gate 007")
# ['4', '12', '007'] — \d+ greedily grabs runs of one or more digits

re.match(r"colou?r", "color")    # matches — the 'u' is optional
re.match(r"colou?r", "colour")   # matches too

re.match(r"\d{3}-\d{4}", "555-1234")   # matches — exactly 3 digits, dash, exactly 4 digits
re.match(r"\d{3}-\d{4}", "55-1234")     # None    — only 2 digits before the dash

# WITHOUT anchors — this "validation" actually just checks for digits ANYWHERE
re.match(r"\d{5}", "hello 80202 world extra text")
# matches "80202" — but re.match only pins the START, not the end,
# so trailing junk after a valid-looking prefix is silently accepted

# WITH both anchors — this genuinely validates the ENTIRE string
re.match(r"^\d{5}$", "80202")            # matches — the whole string is exactly 5 digits
re.match(r"^\d{5}$", "80202-extra")      # None    — correctly rejected

import re

text = "Order #4471 placed on 2026-08-13"
match = re.search(r"Order #(\d+) placed on (\d{4}-\d{2}-\d{2})", text)

if match:
    print(match.group(0))   # the FULL match: "Order #4471 placed on 2026-08-13"
    print(match.group(1))   # the FIRST group: "4471"
    print(match.group(2))   # the SECOND group: "2026-08-13"

pattern = r"Order #(?P<order_id>\d+) placed on (?P<order_date>\d{4}-\d{2}-\d{2})"
match = re.search(pattern, text)

print(match.group("order_id"))     # "4471"
print(match.group("order_date"))   # "2026-08-13"

# .groupdict() returns everything at once, as a regular dict
print(match.groupdict())
# {'order_id': '4471', 'order_date': '2026-08-13'}

text = '<b>bold</b> and <i>italic</i>'

re.findall(r"<.+>", text)
# ['<b>bold</b> and <i>italic</i>']
# The greedy .+ matched from the FIRST < all the way to the LAST > —
# almost certainly not what was intended.

re.findall(r"<.+?>", text)
# ['<b>', '</b>', '<i>', '</i>']
# .+? stops at the FIRST > it can, giving four separate, correct matches

import re

ZIP_CODE = re.compile(r"^\d{5}(-\d{4})?$")   # optional +4 extension

candidates = ["80202", "80202-1234", "8020", "abc12"]
for c in candidates:
    if ZIP_CODE.match(c):
        print(f"{c}: valid")
    else:
        print(f"{c}: invalid")

# WITHOUT r-prefix — Python's OWN string escaping interferes first
pattern = "\d+"     # Python sees \d, does not recognize it as a known escape,
                     # and (in modern Python) leaves it as the two characters \ and d —
                     # but this is fragile and inconsistent across escape sequences

# For example, \s is fine, but some sequences ARE meaningful to Python itself:
"\t"    # this is an actual TAB character to Python, not the two characters \ and t —
         # if you meant the regex whitespace escape \s and mistyped \t, you'd get a
         # literal tab character in your pattern instead of what you intended

# WITH r-prefix — completely unambiguous, exactly what you typed, character for character
pattern = r"\d+"    # r"\d+" is guaranteed to be backslash, d, plus — nothing else

2026-08-13 09:14:02 ERROR [order-service] Failed to process order 4471: timeout after 30s
2026-08-13 09:14:07 INFO  [order-service] Order 4472 processed successfully
2026-08-13 09:15:33 ERROR [payment-service] Failed to process order 4473: card declined

import re

LOG_PATTERN = re.compile(
    r"^(?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\s+"
    r"(?P<level>\w+)\s+"
    r"\[(?P<service>[\w-]+)\]\s+"
    r"(?P<message>.+)$"
)

log_lines = [
    "2026-08-13 09:14:02 ERROR [order-service] Failed to process order 4471: timeout after 30s",
    "2026-08-13 09:14:07 INFO  [order-service] Order 4472 processed successfully",
    "2026-08-13 09:15:33 ERROR [payment-service] Failed to process order 4473: card declined",
]

errors = []
for line in log_lines:
    match = LOG_PATTERN.match(line)
    if match and match.group("level") == "ERROR":
        order_match = re.search(r"order (\d+)", match.group("message"))
        errors.append({
            "timestamp": match.group("timestamp"),
            "service": match.group("service"),
            "order_id": order_match.group(1) if order_match else None,
            "message": match.group("message"),
        })

for e in errors:
    print(e)

# {'timestamp': '2026-08-13 09:14:02', 'service': 'order-service', 'order_id': '4471',
#  'message': 'Failed to process order 4471: timeout after 30s'}
# {'timestamp': '2026-08-13 09:15:33', 'service': 'payment-service', 'order_id': '4473',
#  'message': 'Failed to process order 4473: card declined'}

An insurance-quoting startup accepts phone numbers from a web form and needs to validate them before storing them, since downstream systems (SMS notifications, an agent dialer) assume a clean, consistent shape. An engineer writes a quick validation function under deadline pressure.

import re

def is_valid_phone(number):
    return re.match(r"\d{3}-\d{3}-\d{4}", number) is not None

is_valid_phone("303-555-0192")          # True — correct
is_valid_phone("303-555-0192 ext 4")    # True — ALSO accepted, incorrectly

What breaks, three weeks later

The dialer system starts throwing errors on a small but growing fraction of stored numbers. The root cause, once found: exactly the missing-anchor bug from Part 05. re.match only pins the pattern to the start of the string, never the end, so any input that merely begins with a valid-looking phone number — with arbitrary trailing text — was silently accepted and stored as-is.

The fix, and the second issue it uncovers

The immediate fix is exactly Part 05's lesson: add a trailing $ anchor, r"^\d{3}-\d{3}-\d{4}$", so the entire string must match, not just a prefix of it. But the fix also surfaces a second, more interesting question in code review: should the validator reject (303) 555-0192 and 3035550192, both of which are genuinely valid phone numbers in a different but common format? The team ultimately normalizes input first — stripping non-digit characters with re.sub(r"\D", "", number) — and validates the normalized 10-digit result, rather than trying to write one pattern that accepts every real-world formatting style directly.

The lesson generalizes well beyond phone numbers: a regex validator that is not fully anchored on both ends does not fail loudly — it fails by silently accepting more than intended, which is exactly the kind of bug that survives testing and only shows up once real, messy user input reaches it in production.