Introduction

Python raw strings suppress most backslash escape processing, but they do not turn off the parser rules for delimiting the string literal itself. That is why a raw string cannot end with a single backslash.

The short version is this: the parser still has to decide whether the closing quote really closes the string, and a final backslash makes that ambiguous. Raw strings change how backslashes are interpreted inside the literal, not how the lexer recognizes the end of the literal.

What Raw Strings Actually Mean

A raw string such as r"\n" keeps the backslash and the n as literal characters instead of converting them into a newline character.

print(r"\n")
print(len(r"\n"))

The output is a backslash followed by n, and the length is 2.

That often leads people to think “raw means backslash loses all special meaning.” It does not. The parser still has to read the source code correctly.

Why a Trailing Backslash Breaks the Literal

Imagine this source:

r"abc\"

When the parser sees the final backslash before the quote, it cannot treat the quote as an ordinary closing delimiter in the usual lexical way. The backslash is attached to it in the token stream.

So Python rejects that form rather than guessing what you meant.

The same issue exists with single quotes:

r'abc\'

Again, the parser cannot accept it as a valid raw string literal ending in one backslash.

Raw Strings Still Need a Valid Delimited Literal

This is the key idea: a raw string is still a string literal in Python source code. It must obey the grammar for string tokens.

Raw mode affects escape interpretation after tokenization, but it does not allow impossible literal endings that would break tokenization itself.

That is why this works:

print(r"abc\\")

But this does not:

# invalid syntax
# print(r"abc\")

The double backslash gives the parser a valid literal ending and still represents the characters you intended.

Practical Workarounds

If you need a string value that ends in one backslash, use one of these patterns.

Concatenate

path = r"C:\temp" + "\\"
print(path)

Use a Normal String With Escaping

path = "C:\\temp\\"
print(path)

Use Forward Slashes When the Context Allows It

For some path-like uses, avoiding the trailing backslash entirely may be simpler.

The right choice depends on readability and the kind of string you are building.

Why This Matters in Practice

This comes up often in:

• regular expressions
• Windows paths
• generated source strings
• escaping examples in documentation

Raw strings are still extremely useful for regex patterns, but you need to remember that the literal itself must be syntactically valid Python.

Common Pitfalls

A common mistake is thinking raw strings disable all special meaning of backslashes everywhere. They do not; the parser still needs a valid string literal.

Another mistake is trying to fix the problem by adding a backslash before the quote in a raw string. That is exactly what triggers the parse issue.

Developers also sometimes overuse raw strings for cases where a normal escaped string would actually be clearer.

Finally, do not confuse the source-code rule with the runtime string value. The issue is about how Python parses the literal, not about whether runtime strings can contain trailing backslashes. They can.

Summary

• Raw strings do not disable Python’s need to lex a valid string literal.
• A raw string cannot end with a single backslash because the parser cannot read the closing quote cleanly.
• The restriction is about source-code syntax, not runtime string capability.
• Use concatenation or a normal escaped string when you need a trailing backslash.
• Raw strings are still useful, but they are not “escape-free” in the literal grammar itself.