Caractères d'échappement Python

Ce chapitre traite des caractères d'échappement Python — des séquences spéciales de deux caractères qui permettent d'incorporer des caractères de contrôle, des guillemets, des barres obliques inverses et des points de code Unicode directement dans un littéral de chaîne. Vous apprendrez chaque séquence d'échappement standard, comment les raw strings les désactivent, ainsi que les erreurs les plus courantes que les débutants rencontrent.

Qu'est-ce qu'un caractère d'échappement ?

Dans les littéraux de chaîne Python, la barre oblique inverse (\) joue le rôle de caractère d'échappement. Lorsque l'analyseur rencontre une barre oblique inverse, il lit le caractère suivant (ou les caractères suivants) ensemble et interprète la paire comme un seul caractère spécial — et non comme deux caractères ordinaires.

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

Sans \n, la chaîne serait "Line one\nLine two" affichée sur une seule ligne ; avec lui, l'analyseur substitue un vrai caractère de saut de ligne (point de code Unicode U+000A) avant que la chaîne ne soit stockée.

Le terme échappement vient de l'idée que la barre oblique inverse permet à certains caractères d'« échapper » à leur signification normale — par exemple, un guillemet à l'intérieur d'une chaîne délimitée par le même type de guillemet.

Tableau de référence des séquences d'échappement

Python reconnaît les séquences d'échappement suivantes dans les littéraux de chaîne entre guillemets simples et doubles (y compris les chaînes à triple guillemet) :

La casse est importante. \n (saut de ligne) est complètement différent de \N{name} (Unicode nommé). \u et \U sont également différents. Utilisez toujours la casse exacte indiquée ci-dessus.

Séquences d'échappement courantes

Saut de ligne (\n) et tabulation (\t)

Ce sont les deux séquences d'échappement les plus utilisées :

# \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

Incorporer des guillemets dans des chaînes

Vous disposez de deux stratégies : changer le style du guillemet externe, ou utiliser une séquence d'échappement.

# 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

Les deux stratégies produisent des chaînes identiques. L'approche par échappement est utile dans les chaînes à triple guillemet où changer de style de guillemet est peu pratique.

Barre oblique inverse (\\)

Étant donné que la barre oblique inverse est elle-même le caractère d'échappement, vous devez la doubler pour inclure une barre oblique inverse littérale :

Retour chariot (\r) et retour arrière (\b)

\r déplace le curseur au début de la ligne courante. Les caractères affichés après lui écrasent ce qui était déjà sur la ligne. \b déplace le curseur d'une position vers la gauche.

# \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)

Ces séquences agissent sur la position du curseur plutôt que d'insérer des caractères visibles. Leur résultat visible dépend de votre émulateur de terminal.

Échappements numériques et Unicode

Hexadécimal (\xhh)

\x suivi de exactement deux chiffres hexadécimaux insère le caractère avec ce point de code. Cela fonctionne dans les chaînes d'octets comme dans les chaînes Unicode :

# \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'

Octal (\ooo)

\ suivi d'un à trois chiffres octaux (0–7) insère le caractère avec ce point de code octal :

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

Les échappements octaux sont hérités du C et sont rarement nécessaires en Python moderne. Préférez \x ou \u pour la lisibilité.

Unicode (\uxxxx et \Uxxxxxxxx)

\u prend exactement quatre chiffres hexadécimaux ; \U en prend exactement huit. Les deux insèrent le caractère Unicode correspondant :

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

Unicode nommé (\N{name})

Vous pouvez également référencer un caractère Unicode par son nom officiel. C'est la forme la plus lisible pour les symboles peu courants :

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

Les noms ne sont pas sensibles à la casse et proviennent de la base de données de caractères Unicode.

Raw strings

Une raw string est un littéral de chaîne préfixé par r (ou R). À l'intérieur d'une raw string, les barres obliques inverses sont traitées comme des barres obliques inverses littérales — aucune séquence d'échappement n'est traitée.

# 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

Les raw strings sont indispensables pour les chemins de fichiers Windows et les expressions régulières, où les barres obliques inverses apparaissent fréquemment :

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']

Limitation des raw strings

Une raw string ne peut pas se terminer par un nombre impair de barres obliques inverses. La barre oblique inverse finale tenterait quand même d'échapper au guillemet de fermeture :

# 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\

Erreurs courantes

Séquences d'échappement non reconnues

Une séquence d'échappement qui ne figure pas dans le tableau standard produit un avertissement ou une erreur selon votre version de Python :

• Python 3.6–3.11 : DeprecationWarning (supprimé par défaut ; visible avec -W all)
• Python 3.12+ : SyntaxWarning (affiché par défaut)
• Une future version en fera une SyntaxError

# \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']

Séquences d'échappement dans les chaînes d'octets

\u, \U et \N{name} ne sont pas valides dans les littéraux d'octets (b"..."). Seuls \x, \ooo, \\, \', \", \n, \t, \r, \b, \f, \a, \v et \0 fonctionnent dans les chaînes d'octets :

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

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

Les chaînes à triple guillemet respectent toujours les échappements

Une chaîne à triple guillemet ("""...""" ou '''...''') s'étend sur plusieurs lignes et traite toujours les séquences d'échappement. Utilisez une raw string à triple guillemet si vous avez besoin que les barres obliques inverses soient littérales :

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
"""

Inspecter les chaînes avec repr()

La fonction intégrée repr() vous montre les séquences d'échappement brutes à l'intérieur d'une chaîne, ce qui est précieux pour le débogage :

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

Utilisez repr() quand une chaîne « semble correcte » à l'écran mais se comporte de manière inattendue — les caractères cachés comme \r, \x00 ou les espaces Unicode invisibles deviennent immédiatement visibles.

Sujets connexes

• Python Strings — littéraux de chaîne, styles de guillemets et bases du type string
• Slicing Strings — comment extraire des sous-chaînes par index
• Modify Strings — méthodes de chaîne intégrées pour transformer le texte
• Concatenate Strings — assembler des chaînes avec + et join()
• Format Strings — %, .format() et les bases des f-strings
• Python F-Strings — littéraux de chaîne formatés modernes

Pratique