Before you can read the parent note, you must be able to read every squiggle it throws at you. This page introduces each symbol one at a time, in an order where nothing appears before it is built. We start with the single most important picture: the row of boxes the engine walks across. To keep things honest, the very first thing we define below is where the engine actually stands — the position and the cursor — before we lean on those words anywhere else.
Figure 1 (alt text): the string the dog drawn as seven character boxes, with the between-character positions numbered 0–7 underneath. An orange arrow marks the cursor sitting at position 0 with the caption "match starting here?"; a blue arrow along the top shows the cursor sliding rightward when a match fails.
At position 0 the engine asks "starting here, does my pattern fit?" If not, it moves to position 1, then 2, … until the string ends. This single mental model explains the difference between the two most confused functions in the whole topic (we meet them below): one function only asks at position 0; the other slides all the way along.
Picture: the pattern dog is three literal boxes that must line up, in order, with three text boxes. This is the "shape" in its simplest form — an exact copy.
The backslash does two jobs, and you must keep them apart.
Job A — turn a plain letter into a special code.d is the literal d; \d (backslash-d) is "any digit". Here the backslash says "read the next letter as a special code, not as itself."
Job B — turn a special symbol back into a literal. Symbols like .*+?()[]{}^$|\ are metacharacters — they mean something to the engine. To match one of them literally you put a backslash in front. So \. matches a real dot, \* a real star, \( a real open-paren, \\ a real backslash.
Picture: [ ] is a box with a little menu taped inside — the character in that text box must be on the menu. \d is just a built-in shortcut for the menu [0-9], and \D is its negated shortcut [^0-9].
A quantifier attaches to the atom immediately before it and says how many copies to allow.
Figure 3 (alt text): a table with three rows — patterns a*, a+, a? — and four test columns — empty string, a, aa, aaa. Green ticks and red crosses show what each pattern accepts: a* accepts all four; a+ accepts everything except the empty string; a? accepts only the empty string and a single a.
Read the figure across: for the atom a, the * lane accepts the empty string and any run of as; the + lane rejects empty but accepts one-or-more; the ? lane accepts only "" or a single a.
Picture: on "<a><b>" the greedy <.*> shoots its marker all the way to the last >, matching <a><b> in one gulp; the lazy <.*?> stops at the first >, giving <a> then <b> separately.
Picture: parentheses are little labelled boxes drawn on the rule card. When the engine matches, it writes down what landed inside each box. group(0) is by convention the whole match; group(1), group(2), … are the boxes.
These symbols all match a position, not a character — they are zero-width assertions. They check where the cursor stands and consume no box.
Figure 2 (alt text): the string a dog! drawn as character boxes. Each box is labelled \w (green) for word chars or "not w" (gray) otherwise. Vertical red seams mark every \b word boundary: at the string start before a, on both sides of the space, and at the seam between g and !. The caption notes these seams are zero-width — they mark positions, not characters.
Look at the seams described in Figure 2: \b matches the gap at the edge of a word, exactly where a \w box touches a non-\w box. \B is the opposite — it matches the gaps that are not edges (between two letters of the same word). Both consume no box; they only assert where you stand.
Anchors check for the string edge. Lookaround lets you check for any pattern to the right or left of the cursor, again without eating any characters. There are four, split by direction (ahead/behind) and polarity (must match / must not match).
Picture: lookaround is like the cursor peeking through a window without stepping forward. Example: \d+(?= dollars) matches the digits in "50 dollars" but the match is just 50 — the word dollars was only checked, not captured. And (?<=\$)\d+ matches the digits in "$50" only because a $ sits just behind.
This feeds straight into the parent topic. If you also want the string-slicing side of text handling, see String methods — split, join, format; and for where you apply all this, Python Intermediate — File I/O and parsing logs. Under the hood the engine that walks these positions is a finite state machine.
