Python Escape-Zeichen

Dieses Kapitel behandelt Python Escape-Zeichen — spezielle zweistellige Zeichenfolgen, mit denen Sie Steuerzeichen, Anführungszeichen, Backslashes und Unicode-Codepunkte direkt in ein String-Literal einbetten können. Sie lernen alle standardmäßigen Escape-Sequenzen kennen, erfahren, wie Raw Strings sie deaktivieren, und erhalten Einblick in die häufigsten Fallstricke für Einsteiger.

Was ist ein Escape-Zeichen?

In Python-String-Literalen fungiert der Backslash (\) als Escape-Zeichen. Wenn der Parser einen Backslash erkennt, liest er das nächste Zeichen (oder die nächsten Zeichen) gemeinsam und interpretiert das Paar als ein einziges Sonderzeichen — nicht als zwei gewöhnliche Zeichen.

msg = "Line one\nLine two"
print(msg)
# Line one
# Line two

Ohne \n würde der string "Line one\nLine two" in einer einzigen Zeile ausgegeben; mit ihm ersetzt der Parser ein echtes Zeilenumbruchzeichen (Unicode-Codepunkt U+000A), bevor der string gespeichert wird.

Der Begriff Escape leitet sich von der Idee ab, dass der Backslash bestimmten Zeichen ermöglicht, ihrer normalen Bedeutung zu „entkommen" — zum Beispiel einem Anführungszeichen innerhalb eines strings mit demselben Anführungszeichen.

Referenztabelle der Escape-Sequenzen

Python erkennt die folgenden Escape-Sequenzen in einfach und doppelt angeführten String-Literalen (einschließlich dreifach angeführter strings):

Groß- und Kleinschreibung ist wichtig. \n (Zeilenumbruch) ist völlig verschieden von \N{name} (benanntes Unicode). \u und \U sind ebenfalls unterschiedlich. Verwenden Sie stets die exakte Schreibweise wie oben angegeben.

Häufig verwendete Escape-Sequenzen

Zeilenumbruch (\n) und Tabulator (\t)

Dies sind die beiden am häufigsten verwendeten Escape-Sequenzen:

# \n inserts a line break
poem = "Roses are red,\nViolets are blue."
print(poem)
# Roses are red,
# Violets are blue.

# \t inserts a horizontal tab (usually 8 spaces wide in a terminal)
header = "Name\tAge\tCity"
row    = "Alice\t30\tBerlin"
print(header)
print(row)
# Name    Age     City
# Alice   30      Berlin

Anführungszeichen in Strings einbetten

Es gibt zwei Strategien: das äußere Anführungszeichen wechseln oder eine Escape-Sequenz verwenden.

# Strategy 1 — different outer quote
msg1 = 'She said "hello"'
msg2 = "it's fine"

# Strategy 2 — escape the quote
msg3 = "She said \"hello\""
msg4 = 'it\'s fine'

print(msg1)  # She said "hello"
print(msg4)  # it's fine

Beide Strategien erzeugen identische strings. Der Escape-Ansatz ist nützlich innerhalb dreifach angeführter strings, wo ein Wechsel des Anführungszeichenstils umständlich wäre.

Backslash (\\)

Da der Backslash selbst das Escape-Zeichen ist, müssen Sie ihn verdoppeln, um einen literalen Backslash einzufügen:

Wagenrücklauf (\r) und Rücktaste (\b)

\r bewegt den Cursor zurück an den Anfang der aktuellen Zeile. Alle danach ausgegebenen Zeichen überschreiben das, was bereits in der Zeile stand. \b bewegt den Cursor eine Position nach links.

# \r — carriage return
s = "ABCDE\rXY"
print(s)     # XYcde  (XY overwrites the first two characters)
print(repr(s))  # 'ABCDE\rXY'

# \b — backspace (moves cursor back one position)
s2 = "abc\bd"
print(repr(s2))  # 'abc\x08d'
# terminal may render as: abd  (b erased, d written in its place)

Diese Sequenzen beeinflussen die Cursorposition, anstatt sichtbare Zeichen einzufügen. Ihr sichtbares Ergebnis hängt von Ihrem Terminal-Emulator ab.

Numerische und Unicode-Escapes

Hexadezimal (\xhh)

\x gefolgt von genau zwei Hex-Stellen fügt das Zeichen mit diesem Codepunkt ein. Dies funktioniert sowohl in Byte-strings als auch in Unicode-strings:

# \x41 = 65 decimal = 'A'
print("\x41\x42\x43")  # ABC

# Useful for non-printable control codes
nul = "\x00"
print(len(nul))    # 1
print(repr(nul))   # '\x00'

Oktal (\ooo)

\ gefolgt von einer bis drei Oktalstellen (0–7) fügt das Zeichen mit diesem oktalen Codepunkt ein:

print("\101\102\103")  # ABC  (101 octal = 65 decimal = 'A')

Oktal-Escapes wurden von C geerbt und werden in modernem Python selten benötigt. Bevorzugen Sie \x oder \u für bessere Lesbarkeit.

Unicode (\uxxxx und \Uxxxxxxxx)

\u nimmt genau vier Hex-Stellen; \U nimmt genau acht. Beide fügen das entsprechende Unicode-Zeichen ein:

print("é")          # é  (Latin small letter e with acute)
print("π")          # π  (Greek small letter pi)
print("\U0001F600")      # 😀  (grinning face emoji)

Benanntes Unicode (\N{name})

Sie können auch ein Unicode-Zeichen über seinen offiziellen Namen referenzieren. Dies ist die lesbarste Form für seltene Symbole:

print("\N{SNOWFLAKE}")                      # ❄
print("\N{LATIN SMALL LETTER E WITH ACUTE}") # é
print("\N{BLACK HEART SUIT}")               # ♥

Die Namen unterscheiden nicht zwischen Groß- und Kleinschreibung und stammen aus der Unicode-Zeichendatenbank.

Raw Strings

Ein Raw String ist ein String-Literal mit dem Präfix r (oder R). Innerhalb eines Raw Strings werden Backslashes als literale Backslashes behandelt — es werden keine Escape-Sequenzen verarbeitet.

# Regular string — backslash starts an escape sequence
normal = "C:\new_folder\table.csv"
print(normal)
# C:
# ew_folder	able.csv   ← \n and \t were interpreted!

# Raw string — backslashes are literal
raw = r"C:\new_folder\table.csv"
print(raw)
# C:\new_folder\table.csv

Raw Strings sind unverzichtbar bei der Arbeit mit Windows-Dateipfaden und regulären Ausdrücken, wo Backslashes häufig vorkommen:

import re

# Without raw string — need to double every backslash
pattern1 = re.compile("\\d+\\.\\d+")

# With raw string — much more readable
pattern2 = re.compile(r"\d+\.\d+")

print(pattern2.findall("pi is 3.14159"))  # ['3.14159']

Einschränkung bei Raw Strings

Ein Raw String darf nicht mit einer ungeraden Anzahl von Backslashes enden. Der letzte Backslash würde dennoch versuchen, das abschließende Anführungszeichen zu escapen:

# SyntaxError: EOL while scanning string literal
# path = r"C:\folder\"    ← the \" at the end escapes the quote

# Workaround — concatenate a regular string
path = r"C:\folder" + "\\"
print(path)  # C:\folder\

Häufige Fallstricke

Nicht erkannte Escape-Sequenzen

Eine Escape-Sequenz, die nicht in der Standardtabelle vorhanden ist, erzeugt je nach Python-Version eine Warnung oder einen Fehler:

• Python 3.6–3.11: DeprecationWarning (standardmäßig unterdrückt; sichtbar mit -W all)
• Python 3.12+: SyntaxWarning (standardmäßig angezeigt)
• Eine zukünftige Version wird es zu einem SyntaxError machen

# \d is not a valid Python escape sequence
# python3 -W all script.py  => DeprecationWarning: invalid escape sequence '\d'
s = "\d+"
print(repr(s))     # '\\d+'  — backslash is kept literally for now

# Always use a raw string for regex patterns
import re
print(re.findall(r"\d+", "abc 123"))  # ['123']

Escape-Sequenzen in Byte-Strings

\u, \U und \N{name} sind nicht gültig innerhalb von Byte-Literalen (b"..."). Nur \x, \ooo, \\, \', \", \n, \t, \r, \b, \f, \a, \v und \0 funktionieren in Byte-strings:

b = b"\x41\x42"   # valid — b'AB'
print(b)

# b"é"       # SyntaxError — \u not allowed in bytes

Dreifach angeführte Strings verarbeiten weiterhin Escapes

Ein dreifach angeführter string ("""...""" oder '''...''') erstreckt sich über mehrere Zeilen und verarbeitet weiterhin Escape-Sequenzen. Verwenden Sie einen dreifach angeführten Raw String, wenn Sie die Backslashes literal benötigen:

sql = """
SELECT *
FROM users
WHERE name LIKE '%O\'Brien%'
"""
print(sql)

regex_pattern = r"""
(?x)            # verbose mode
\d{4}           # year
-\d{2}          # month
-\d{2}          # day
"""

Strings mit repr() untersuchen

Die eingebaute Funktion repr() zeigt Ihnen die rohen Escape-Sequenzen innerhalb eines strings an, was beim Debuggen unschätzbar wertvoll ist:

s = "line1\nline2\ttabbed"
print(s)         # prints with actual newline and tab
print(repr(s))   # 'line1\nline2\ttabbed'

Verwenden Sie repr(), wenn ein string auf dem Bildschirm „richtig aussieht", sich aber unerwartet verhält — versteckte Zeichen wie \r, \x00 oder unsichtbare Unicode-Leerzeichen werden sofort sichtbar.

Verwandte Themen

• Python Strings — String-Literale, Anführungszeichenstile und Grundlagen des string-Typs
• Slicing Strings — So extrahieren Sie Teilstrings nach Index
• Modify Strings — Eingebaute string-Methoden zur Texttransformation
• Concatenate Strings — Strings mit + und join() verbinden
• Format Strings — %, .format() und f-string-Grundlagen
• Python F-Strings — Moderne formatierte String-Literale

Übungen