Master Python Regular Expressions: Syntax, Quantifiers, and Advanced Techniques

1. Regular Expression Syntax

1.1 Characters and Character Classes

Special characters: .^$?+*{}[]()|. To use them literally, escape them.

Character classes are defined inside [] and match one character unless a quantifier is applied. Ranges like [a-zA-Z0-9] match any letter or digit. A leading ^ inside [] negates the class, e.g., [^0-9] matches any non‑digit. Inside a class, most metacharacters lose their special meaning; ^ at the start means negation, - denotes a range unless placed first.

Shorthand character classes: . matches any character except newline (or any character with re.DOTALL). d matches a Unicode digit (or 0‑9 with re.ASCII). D matches a non‑digit. s matches Unicode whitespace (or ASCII space with re.ASCII). S matches non‑whitespace. w matches Unicode word characters (or [a-zA-Z0-9_] with re.ASCII). W matches non‑word characters.

1.2 Quantifiers

?, *, +, {m}, {m,}, {,n}, {m,n} – with greedy behavior by default; append ? for non‑greedy.

1.3 Groups and Capturing

Parentheses () capture matched subpatterns; use (?:…) for non‑capturing groups. Captured groups can be referenced by number or by name using (?P …) and (?P=name). Note: backreferences cannot be used inside character classes.

1.4 Assertions and Anchors

Assertions impose constraints without consuming characters. Common assertions: \b word boundary, \B non‑word boundary, \A start of string, ^ start of line (with MULTILINE), $ end of line (with MULTILINE), \Z end of string, \A start, (?=…) positive look‑ahead, (?!…) negative look‑ahead, (?<=…) positive look‑behind, (?

1.5 Conditional Matching

(?(id)yes|no) chooses the yes pattern if group id matched, otherwise the no pattern.

1.6 Regex Flags

Flags can be passed to re.compile() combined with |, e.g., re.compile(r"#[da-f]{6}", re.IGNORECASE|re.MULTILINE) , or embedded in the pattern with (?flags). Common flags: re.ASCII (or re.A), re.IGNORECASE (re.I), re.MULTILINE (re.M), re.DOTALL (re.S), re.VERBOSE (re.X). Example of VERBOSE with comments and whitespace.

2. Python re Module

2.1 Core Functions

Matching, searching, finding all, splitting, and substituting strings using regular expressions.

2.2 Using re.compile()

Compile a pattern into a regex object for repeated use, or use module-level functions for one‑off patterns.

2.3 Common Methods of a Regex Object

rx.findall(s, start, end)

– returns a list of matches or tuples if groups exist. rx.finditer(s, start, end) – returns an iterator of match objects. rx.search(s, start, end) – returns the first match object or None. rx.match(s, start, end) – matches at the beginning of the string. rx.sub(repl, s, count) – returns a new string with replacements; repl can be a function. rx.subn(repl, s, count) – like sub() but also returns the number of substitutions. rx.split(s, maxsplit) – splits the string by the pattern; captured groups appear in the result list. rx.flags() – returns the compiled flags. rx.pattern – the original pattern string.

2.4 Match Object Attributes and Methods

m.group(...)

– returns the captured text. m.groupdict(default=None) – returns a dict of named groups. m.groups(default=None) – returns a tuple of all captured groups. m.lastgroup, m.lastindex – name or index of the last matched group. m.start(g), m.end(g), m.span(g) – positions of the group. m.re – the compiled pattern object. m.string – the original searched string. m.pos, m.endpos – start and end positions of the search.

2.5 Summary

Python’s re module provides match/search functions that return None when no match is found, iterative finditer for multiple matches, sub/subn for replacements (with optional callable), and split that includes captured groups in the result.