Caracteres de Escape en Python

Este capítulo cubre los caracteres de escape de Python — secuencias especiales de dos caracteres que te permiten insertar caracteres de control, comillas, barras invertidas y puntos de código Unicode directamente dentro de un literal de string. Aprenderás todas las secuencias de escape estándar, cómo los strings sin procesar las desactivan y los errores más comunes que cometen los principiantes.

¿Qué Es un Carácter de Escape?

En los literales de string de Python, la barra invertida (\) actúa como un carácter de escape. Cuando el analizador encuentra una barra invertida, lee el siguiente carácter (o caracteres) junto con ella e interpreta el par como un único carácter especial — no como dos caracteres ordinarios.

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

Sin \n, el string sería "Line one\nLine two" impreso en una sola línea; con él, el analizador sustituye un carácter de nueva línea real (punto de código Unicode U+000A) antes de que el string se almacene.

El término escape proviene de la idea de que la barra invertida permite que ciertos caracteres "escapen" de su significado normal — por ejemplo, una comilla dentro de un string delimitado por el mismo tipo de comillas.

Tabla de Referencia de Secuencias de Escape

Python reconoce las siguientes secuencias de escape dentro de literales de string con comillas simples y dobles (incluidos los strings de triple comilla):

Las mayúsculas importan. \n (nueva línea) es completamente diferente de \N{name} (Unicode con nombre). \u y \U también son diferentes. Utiliza siempre las mayúsculas exactas indicadas arriba.

Secuencias de Escape de Uso Cotidiano

Nueva Línea (\n) y Tabulación (\t)

Estas son las dos secuencias de escape más utilizadas:

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

Insertar Comillas Dentro de Strings

Tienes dos estrategias: cambiar el estilo de comilla exterior, o usar una secuencia de 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

Ambas estrategias producen strings idénticos. El enfoque de escape es útil dentro de strings de triple comilla donde cambiar el estilo de comilla resulta incómodo.

Barra Invertida (\\)

Dado que la barra invertida es el propio carácter de escape, debes duplicarla para incluir una barra invertida literal:

Retorno de Carro (\r) y Retroceso (\b)

\r mueve el cursor al inicio de la línea actual. Los caracteres impresos después de él sobrescriben lo que ya estaba en la línea. \b mueve el cursor una posición a la izquierda.

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

Estas secuencias afectan la posición del cursor en lugar de insertar caracteres visibles. Su resultado visible depende de tu emulador de terminal.

Escapes Numéricos y Unicode

Hexadecimal (\xhh)

\x seguido de exactamente dos dígitos hexadecimales inserta el carácter con ese punto de código. Esto funciona tanto en strings de bytes como en strings 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)

\ seguido de uno a tres dígitos octales (0–7) inserta el carácter con ese punto de código octal:

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

Los escapes octales se heredaron de C y raramente se necesitan en Python moderno. Prefiere \x o \u para mayor legibilidad.

Unicode (\uxxxx y \Uxxxxxxxx)

\u toma exactamente cuatro dígitos hexadecimales; \U toma exactamente ocho. Ambos insertan el carácter Unicode correspondiente:

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

Unicode con Nombre (\N{name})

También puedes referenciar un carácter Unicode por su nombre oficial. Esta es la forma más legible para símbolos poco comunes:

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

Los nombres no distinguen entre mayúsculas y minúsculas y provienen de la base de datos de caracteres Unicode.

Strings Sin Procesar

Un string sin procesar es un literal de string prefijado con r (o R). Dentro de un string sin procesar, las barras invertidas se tratan como barras invertidas literales — no se procesa ninguna secuencia de escape.

# 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

Los strings sin procesar son esenciales cuando se trabaja con rutas de archivo de Windows y expresiones regulares, donde las barras invertidas aparecen con frecuencia:

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

Limitación de los Strings Sin Procesar

Un string sin procesar no puede terminar con un número impar de barras invertidas. La barra invertida final intentará escapar la comilla de cierre:

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

Errores Comunes

Secuencias de Escape No Reconocidas

Una secuencia de escape que no está en la tabla estándar produce una advertencia o error dependiendo de la versión de Python:

• Python 3.6–3.11: DeprecationWarning (suprimida por defecto; visible con -W all)
• Python 3.12+: SyntaxWarning (mostrada por defecto)
• Una versión futura la convertirá en 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']

Secuencias de Escape en Strings de Bytes

\u, \U y \N{name} no son válidos dentro de literales de bytes (b"..."). Solo \x, \ooo, \\, \', \", \n, \t, \r, \b, \f, \a, \v y \0 funcionan en strings de bytes:

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

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

Los Strings de Triple Comilla También Procesan Escapes

Un string de triple comilla ("""...""" o '''...''') abarca múltiples líneas y sigue procesando secuencias de escape. Usa un string de triple comilla sin procesar si necesitas que las barras invertidas sean literales:

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

Inspeccionar Strings con repr()

La función incorporada repr() te muestra las secuencias de escape sin procesar dentro de un string, lo que resulta invaluable para depurar:

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

Usa repr() cuando un string "se ve bien" en pantalla pero se comporta de forma inesperada — los caracteres ocultos como \r, \x00 o espacios Unicode invisibles quedan visibles de inmediato.

Temas Relacionados

• Python Strings — literales de string, estilos de comillas y conceptos básicos del tipo string
• Slicing Strings — cómo extraer subcadenas por índice
• Modify Strings — métodos de string integrados para transformar texto
• Concatenate Strings — unir strings con + y join()
• Format Strings — conceptos básicos de %, .format() y f-strings
• Python F-Strings — literales de string formateados modernos

Práctica