Regular Expressions in Python

Regular expressions (regex) are a powerful mini-language for describing text patterns. Python's built-in re module gives you everything you need to search, extract, replace, and split strings.

Raw Strings for Patterns

Always write regex patterns as raw strings with the r prefix:

The r prefix tells Python not to process backslash escape sequences, so r"\d" is literally backslash-d — exactly what the regex engine expects.

re.match vs re.search

These two functions look similar but behave very differently:

• re.match(pattern, string) — only matches at the start of the string (anchored)
• re.search(pattern, string) — scans the entire string, returns the first match anywhere

Both return None when there is no match — always check before calling .group().

re.findall — All Matches as a List

re.findall returns all non-overlapping matches as a list of strings:

When the pattern contains a capturing group, findall returns a list of the captured text instead of full matches. With multiple groups it returns a list of tuples.

re.finditer — Iterator of Match Objects

re.finditer is like findall but returns an iterator of Match objects, giving you position information too:

Use finditer instead of findall whenever you need match positions or other Match object attributes.

re.sub — Replace Matches

re.sub(pattern, replacement, string) replaces every match with replacement:

You can also pass a callable as the replacement — it receives the Match object and returns the replacement string.

re.split — Split on a Pattern

re.split splits a string on every occurrence of the pattern:

re.compile — Reuse Patterns

Compiling a pattern once and reusing it is faster when the same pattern is used many times:

A compiled pattern has the same methods as the re module (.match, .search, .findall, etc.).

Capturing Groups

Parentheses () create capturing groups that you can extract individually:

Named Groups — (?P<name>...)

Named groups make patterns self-documenting and let you access captures by name:

Non-Capturing Groups — (?:...)

Use (?:...) when you need grouping for alternation or repetition but don't need to capture:

Flags

Flags modify how the pattern engine behaves:

Common Patterns

Greedy vs Non-Greedy

By default, quantifiers (*, +, ?, {n,m}) are greedy — they match as much as possible. Add ? to make them non-greedy (lazy):

Non-greedy quantifiers are essential when parsing structured text like HTML, XML, or log lines where you need the shortest possible match.