Regular expressions

Understand the concept

Match the operation to the question

A regular expression describes a text pattern. re.fullmatch asks whether the entire supplied string matches. re.search looks for a match somewhere inside it. re.findall collects matched text or captured groups, depending on the pattern. These operations answer different questions even when they use the same pattern.

If a field must be a session ID consisting of S and exactly three ASCII digits, fullmatch expresses the whole-field requirement. Searching for that pattern would also succeed inside unrelated surrounding text. A successful search therefore does not establish that the complete field is a valid ID.

Regex is useful for a bounded structure. It is not a substitute for a date parser, a JSON parser, or a full HTML parser. A date-shaped string can still contain February 30. A pattern match establishes syntax under the chosen pattern, not the meaning of every field.

Raw literals and regex syntax are separate layers

Raw strings make backslashes easier to read in many patterns by reducing Python literal escape interpretation. The regex engine still interprets its own escapes. r'\b' gives the engine a word-boundary escape, while a nonraw string spelling can introduce a backspace character instead.

Use [0-9] when the contract requires ASCII digits. \d in Python's ordinary Unicode matching can cover other decimal digits too. Neither choice is universally better; they express different accepted domains. State the domain for an identifier rather than assuming “digit” has only one interpretation.

Groups extract parts of an established match

Parentheses define capturing groups. After a successful match, group(0) is the entire matched text and group(1) is the first captured group. A failed match returns None, so check it before calling group. Named groups can make a multi-field pattern easier to read.

Quantifiers specify repetition: {3} means exactly three, + means one or more, and * means zero or more. Character classes select allowed characters. A dot has its own matching rules and is not automatically a literal period. Escape a literal period when your pattern requires one.

Worked example

import re

pattern = re.compile(r"S([0-9]{3})")
valid = pattern.fullmatch("S007")
assert valid is not None
assert valid.group(0) == "S007"
assert valid.group(1) == "007"
assert pattern.fullmatch("prefix S007") is None
assert pattern.fullmatch("S0079") is None

text = "Recorded S007 and S123; not S0079."
ids = re.findall(r"\bS[0-9]{3}\b", text)
assert ids == ["S007", "S123"]
collapsed = re.sub(r"\s+", " ", " read\n  code\t review ").strip()
assert collapsed == "read code review"
print("IDs:", ids)
print("Collapsed text:", collapsed)

The digit group stays text, preserving its leading zeros. Converting it to 7 would lose the exact identifier spelling. The whitespace substitution is a policy for a single-line display, not a general safe transformation for a file whose line boundaries carry meaning.

Guided practice

1. Predict: compare findall with no capture, one capture, and two captures. Observe how its result shape changes. Do not assume it always returns the full matched text.
2. Modify: allow IDs beginning with S or T while keeping exactly three ASCII digits. Test a lowercase s, a fourth digit, and an embedded prefix to confirm the boundaries remain deliberate.
3. Reconstruct: parse an ASCII label of three uppercase letters, a hyphen, and two digits. Use fullmatch and a named group for the numeric text. Test near misses, not just one accepted label.

Keep a small negative-case list next to every pattern. It documents the intended language more effectively than a long comment saying “validates everything.”

Daily challenge

Implement parse_session_code(text). Accept exactly DAY- followed by two ASCII digits representing a day from 01 through 30. Return the integer day. Reject surrounding spaces, lowercase prefixes, extra characters, 00, and 31. Raise ValueError for any string that fails syntax or range.

The explicit range check demonstrates the boundary between regex structure and application meaning. A two-digit match alone cannot establish that the day exists in this course.

Reference solution

import re

def parse_session_code(text):
    match = re.fullmatch(r"DAY-([0-9]{2})", text)
    if match is None:
        raise ValueError("expected DAY- plus two ASCII digits")
    day = int(match.group(1))
    if not 1 <= day <= 30:
        raise ValueError("day must be between 01 and 30")
    return day

assert parse_session_code("DAY-01") == 1
assert parse_session_code("DAY-30") == 30
for text in ["DAY-00", "DAY-31", "day-01", "DAY-1", " DAY-01", "DAY-01x"]:
    try:
        parse_session_code(text)
    except ValueError:
        pass
    else:
        raise AssertionError("Near miss should be rejected")
print("Pattern and semantic range passed")

Debug and explain

If group access fails, check whether the match was None. If an invalid field passes, inspect search versus fullmatch. If captured results have an unexpected shape, inspect the number of groups. If the pattern behaves differently in a browser tool, remember that JavaScript and Python regex engines have differences.

Explain why DAY-31 needs a numeric rule after matching, why surrounding spaces are rejected here but trimmed in an earlier label policy, and why leading zeros are preserved until the numeric day interpretation becomes appropriate.

Review and next step

Save the accepted and near-miss cases. This checkpoint completes objects, date types, and text patterns. Day 25 introduces JSON, where a real parser and explicit shape validation replace ad hoc string matching.