Why are regex patterns in Python written as raw strings like r"\d+"?

## Two layers, one backslash When you write a regex in Python source, the backslashes are read twice. **Layer one: the string literal.** Python's parser processes escape sequences inside a normal literal. `"\n"` becomes one newline character. `"\t"` becomes one tab. `"\b"` becomes one **backspace** (character code 8). **Layer two: the regex compiler.** `re` then reads the characters it was handed and interprets *its own* backslash sequences: `\d` for a digit, `\b` for a word boundary, `\.` for a literal dot. The conflict is that both layers claim the backslash. Whatever layer one consumes never reaches layer two. ```python import re len("\b") # 1 - a backspace character len(r"\b") # 2 - backslash, then 'b' re.search(r"\bcat\b", "a cat sat") # Match: word boundaries re.search("\bcat\b", "a cat sat") # None: literal backspace characters ``` The second search fails silently. Nothing raises; the pattern is perfectly valid, it just describes text containing backspace characters, which the input does not have. This class of bug is invisible in review unless you know to look for it. ## The r prefix Prefixing a literal with `r` — `r"\d+"` — tells Python to skip escape processing and keep the characters exactly as written. The regex compiler then receives `\d+` and interprets `\d` itself. This is why essentially every piece of Python documentation, tutorial and production code writes patterns as raw literals: it removes an entire layer of confusion. The alternative is doubling: `"\\d+"` is an ordinary literal whose *value* is `\d+`, because `\\` is the escape for one backslash. It works identically. It is simply harder to read and easier to get wrong, and it gets worse fast — matching one literal backslash needs `r"\\"` as a raw literal but `"\\\\"` as an ordinary one. ## What changed in 3.12 Not every backslash pair is a recognised Python escape. `\d` is not one, so Python leaves it alone and the value ends up being backslash-plus-d anyway — which is why `"\d+"` *appears* to work. That leniency is being withdrawn: - through Python 3.11, an unrecognised escape emitted a `DeprecationWarning`, hidden by default; - since **Python 3.12** it emits a `SyntaxWarning`, which is visible by default; - it is documented as becoming a hard error in a future release. So `"\d+"` is not merely untidy today; it is code with a scheduled expiry. Meanwhile `\b` is *not* in that lenient category — it is a valid Python escape with a different meaning — so it fails silently rather than warning. The two failure modes together are the argument for making the raw prefix unconditional rather than case-by-case. ## Raw is not "no escapes at all" A raw literal still ends at an unescaped quote, and a backslash before the closing quote still prevents termination — which is why `r"\"` is a syntax error and a raw literal cannot end in a single backslash. The backslash is kept in the value, but it is still seen by the tokeniser. If you need a pattern ending in a backslash, concatenate or use the doubled form. Raw applies only to the literal, not to a value computed elsewhere: a pattern arriving from a config file or built at runtime has already gone through whatever quoting that source imposes, and the `r` prefix has nothing to do with it. Where you are embedding user-supplied text into a pattern, the right tool is `re.escape`, which backslash-escapes everything the engine would treat as special. ```python import re user_input = "clip.720p" pattern = re.compile(re.escape(user_input)) # the dot is literal ``` ## Practical rules 1. Write **every** regex pattern as a raw literal, always, even when it contains no backslash today — the next edit may add one. 2. Never hand-double backslashes in a pattern; if you find yourself counting them, you dropped the `r`. 3. Use `re.escape` for any dynamic fragment rather than trying to quote it yourself. 4. Treat a `SyntaxWarning` about an invalid escape as a bug, not noise. Interviewers ask this because it takes ten seconds to answer and separates people who have read the `re` documentation from people who have copied patterns from search results. The follow-up — "what does `\b` mean in each layer?" — is where it gets interesting.