Caratteri di Escape in Python

Questo capitolo tratta i caratteri di escape in Python — speciali sequenze di due caratteri che ti permettono di incorporare caratteri di controllo, virgolette, barre rovesciate e code point Unicode direttamente all'interno di un letterale stringa. Imparerai ogni sequenza di escape standard, come le raw string le disattivano e gli errori più comuni in cui incorrono i principianti.

Cos'è un Carattere di Escape?

Nei letterali stringa di Python, la barra rovesciata (\) funge da carattere di escape. Quando il parser vede una barra rovesciata, legge il carattere successivo (o i caratteri successivi) insieme e interpreta la coppia come un singolo carattere speciale — non come due caratteri ordinari.

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

Senza \n, la stringa sarebbe "Line one\nLine two" stampata su una sola riga; con esso, il parser sostituisce un vero carattere di a capo (code point Unicode U+000A) prima che la stringa venga memorizzata.

Il termine escape deriva dall'idea che la barra rovesciata permetta a certi caratteri di "sfuggire" al loro significato normale — per esempio, una virgoletta all'interno di una stringa delimitata dalla stessa virgoletta.

Tabella di Riferimento delle Sequenze di Escape

Python riconosce le seguenti sequenze di escape all'interno dei letterali stringa sia con virgolette singole che doppie (incluse le stringhe con virgolette triple):

Le maiuscole contano. \n (newline) è completamente diverso da \N{name} (Unicode con nome). Anche \u e \U sono diversi. Usa sempre esattamente il formato mostrato sopra.

Sequenze di Escape di Uso Quotidiano

Newline (\n) e Tab (\t)

Queste sono le due sequenze di escape più comunemente utilizzate:

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

Incorporare Virgolette nelle Stringhe

Hai due strategie: cambiare il tipo di virgolette esterne, oppure usare una sequenza di escape.

# 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

Entrambe le strategie producono stringhe identiche. L'approccio con l'escape è utile all'interno delle stringhe con virgolette triple, dove cambiare il tipo di virgolette risulta scomodo.

Barra Rovesciata (\\)

Poiché la barra rovesciata è il carattere di escape stesso, devi raddoppiarla per includere una barra rovesciata letterale:

Ritorno a Capo (\r) e Backspace (\b)

\r sposta il cursore all'inizio della riga corrente. Qualsiasi carattere stampato dopo di esso sovrascrive quanto già presente sulla riga. \b sposta il cursore di una posizione verso sinistra.

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

Queste sequenze influenzano la posizione del cursore anziché inserire caratteri visibili. Il risultato visibile dipende dal tuo emulatore di terminale.

Escape Numerici e Unicode

Esadecimale (\xhh)

\x seguito da esattamente due cifre esadecimali inserisce il carattere con quel code point. Questo funziona sia nelle stringhe di byte che nelle stringhe 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'

Ottale (\ooo)

\ seguito da una fino a tre cifre ottali (0–7) inserisce il carattere con quel code point ottale:

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

Gli escape ottali sono ereditati dal C e raramente necessari nel Python moderno. Preferisci \x o \u per maggiore leggibilità.

Unicode (\uxxxx e \Uxxxxxxxx)

\u accetta esattamente quattro cifre esadecimali; \U ne accetta esattamente otto. Entrambi inseriscono il corrispondente carattere Unicode:

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

Unicode per Nome (\N{name})

Puoi anche fare riferimento a un carattere Unicode tramite il suo nome ufficiale. È la forma più leggibile per i simboli non comuni:

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

I nomi non fanno distinzione tra maiuscole e minuscole e provengono dal database dei caratteri Unicode.

Raw String

Una raw string è un letterale stringa con il prefisso r (o R). All'interno di una raw string, le barre rovesciate vengono trattate come barre rovesciate letterali — nessuna sequenza di escape viene elaborata.

# 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

Le raw string sono essenziali quando si lavora con percorsi di file Windows e espressioni regolari, dove le barre rovesciate compaiono frequentemente:

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

Limitazione delle Raw String

Una raw string non può terminare con un numero dispari di barre rovesciate. L'ultima barra rovesciata cercherebbe comunque di effettuare l'escape della virgoletta di chiusura:

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

Errori Comuni

Sequenze di Escape Non Riconosciute

Una sequenza di escape non presente nella tabella standard produce un avviso o un errore a seconda della versione di Python:

• Python 3.6–3.11: DeprecationWarning (soppressa per impostazione predefinita; visibile con -W all)
• Python 3.12+: SyntaxWarning (mostrata per impostazione predefinita)
• Una versione futura la renderà un 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']

Sequenze di Escape nelle Stringhe di Byte

\u, \U e \N{name} non sono validi all'interno dei letterali di byte (b"..."). Solo \x, \ooo, \\, \', \", \n, \t, \r, \b, \f, \a, \v e \0 funzionano nelle stringhe di byte:

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

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

Le Stringhe con Virgolette Triple Rispettano Comunque gli Escape

Una stringa con virgolette triple ("""...""" o '''...''') si estende su più righe e continua a elaborare le sequenze di escape. Usa una raw string con virgolette triple se hai bisogno delle barre rovesciate letterali:

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

Ispezione delle Stringhe con repr()

La funzione built-in repr() mostra le sequenze di escape grezze all'interno di una stringa, il che è prezioso per il debug:

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

Usa repr() quando una stringa "sembra giusta" sullo schermo ma si comporta in modo inaspettato — caratteri nascosti come \r, \x00 o spazi Unicode invisibili diventano immediatamente visibili.

Argomenti Correlati

• Python Strings — letterali stringa, stili di virgolette e basi del tipo stringa
• Slicing Strings — come estrarre sottostringhe per indice
• Modify Strings — metodi string built-in per trasformare il testo
• Concatenate Strings — unire stringhe con + e join()
• Format Strings — basi di %, .format() e f-string
• Python F-Strings — letterali stringa formattati moderni

Pratica