Quantifiers, Anchors, and Flags

### What a quantifier actually decides A quantifier in a Python regular expression says how many times the preceding element may repeat. `*` means zero or more, `+` means one or more, `?` means zero or one, and `{m,n}` means between `m` and `n` times inclusive (`{m,}` is at least `m`, `{,n}` is at most `n`, `{m}` is exactly `m`). By default every one of these is **greedy**. Appending a `?` to the quantifier itself — `*?`, `+?`, `??`, `{m,n}?` — makes it **lazy** (the docs call it non-greedy). Note the pun that trips people up: the `?` in `a?` is a quantifier meaning "optional", while the `?` in `a*?` is a modifier on the `*` that already sits there. ### How the engine resolves the choice CPython's `re` is a backtracking engine. It scans for the leftmost position at which the whole pattern can succeed, and at that position it walks the pattern left to right. When it reaches a greedy quantifier it takes as many repetitions as it possibly can — for `.*` that is every remaining character on the line — and only then tries to match what follows. If that fails, it *backtracks*: it hands one character back and retries the rest of the pattern, over and over, until either something matches or it runs out of characters to return. A lazy quantifier inverts the order of attempts: it first tries zero repetitions, tries the rest of the pattern, and only if that fails does it consume one more character and try again. So greedy and lazy are not two different answers to "what is the match" — they are two different **orders in which candidate matches are tried**. Both start at the same leftmost position; they differ in which candidate they reach first. ```python import re text = "<a> text <b>" re.search(r"<.*>", text).group() # '<a> text <b>' re.search(r"<.*?>", text).group() # '<a>' ``` The greedy version does not stop at the first `>` because nothing in `<.*>` forbids `.` from matching `>`. It runs to the end of the string, backtracks to the *last* `>`, and succeeds there. The lazy version stops at the first `>` it can. ### The leftmost rule beats laziness A very common misconception is that `.*?` yields "the shortest match in the string". It does not. The engine's first commitment is to the earliest possible starting position; laziness only chooses among the candidates that start there. If a shorter match exists further right, greedy and lazy alike will ignore it, because the leftmost start already succeeded. ### Bounded repeats `{m,n}` participates in the same rule: `\d{2,4}` prefers four digits and backs down to three, then two; `\d{2,4}?` prefers two and grows. `re.findall(r"\d{2,4}", "1 12 123 12345")` returns `['12', '123', '1234']` — note the last one is truncated at four digits, which is exactly the upper bound doing its job. Write `{m,n}` with no spaces; `{2, 4}` is not a quantifier at all, it is four literal characters. ### The alternative that is usually right When you are extracting a field delimited by some character, neither greedy nor lazy is the best tool — a negated character class is. `<[^>]*>` cannot cross a `>` under any circumstances, so it stops for a structural reason rather than by trial and error. It expresses the intent ("everything up to but not including the delimiter") directly, it is immune to the reader misreading the appetite of the quantifier, and it does far less work at match time because each character is decided once. The same shape applies to quoted strings (`"[^"]*"`) and to key=value fragments (`=([^;]*)`). ### Where the dot itself gets in the way One detail that changes the answer entirely: `.` does not match a newline unless the `re.DOTALL` flag is set. On multi-line input a greedy `.*` is therefore bounded by the end of its line, which is why the same pattern behaves very differently once someone adds that flag. If your subject text can contain newlines, decide deliberately whether `.` should cross them. ### What to say in an interview Define greedy and lazy as *orders of preference under backtracking*, show the `<.*>` versus `<.*?>` contrast, state clearly that both matches start at the same place, and finish by pointing at the negated character class as the version you would actually commit. That sequence — mechanism, demonstration, and the better alternative — is what separates someone who has memorised a rule from someone who writes patterns other people can maintain.