Caracteres de Escape em Python

Este capítulo aborda os caracteres de escape em Python — sequências especiais de dois caracteres que permitem incorporar caracteres de controle, aspas, barras invertidas e pontos de código Unicode diretamente dentro de um literal de string. Você aprenderá todas as sequências de escape padrão, como as strings raw as desativam e as armadilhas mais comuns que os iniciantes encontram.

O que é um Caractere de Escape?

Nos literais de string em Python, a barra invertida (\) atua como um caractere de escape. Quando o analisador encontra uma barra invertida, ele lê o próximo caractere (ou caracteres) em conjunto e interpreta o par como um único caractere especial — não como dois caracteres comuns.

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

Sem \n, a string seria "Line one\nLine two" impressa em uma única linha; com ele, o analisador substitui um caractere de nova linha real (ponto de código Unicode U+000A) antes de a string ser armazenada.

O termo escape vem da ideia de que a barra invertida permite que certos caracteres "escapem" do seu significado normal — por exemplo, uma aspa dentro de uma string delimitada pelo mesmo tipo de aspas.

Tabela de Referência das Sequências de Escape

Python reconhece as seguintes sequências de escape dentro de literais de string com aspas simples e duplas (incluindo strings de aspas triplas):

Maiúsculas e minúsculas importam. \n (nova linha) é completamente diferente de \N{name} (Unicode nomeado). \u e \U também são diferentes. Sempre use exatamente as letras mostradas acima.

Sequências de Escape do Dia a Dia

Nova Linha (\n) e Tabulação (\t)

Estas são as duas sequências de escape mais 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

Incorporando Aspas Dentro de Strings

Você tem duas estratégias: alterar o estilo de aspas externas ou usar uma sequência 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 as estratégias produzem strings idênticas. A abordagem com escape é útil dentro de strings de aspas triplas onde alterar o estilo de aspas é inconveniente.

Barra Invertida (\\)

Como a barra invertida é o próprio caractere de escape, você deve dobrá-la para incluir uma barra invertida literal:

Retorno de Carro (\r) e Retrocesso (\b)

\r move o cursor de volta ao início da linha atual. Qualquer caractere impresso após ele sobrescreve o que já estava na linha. \b move o cursor uma posição para a esquerda.

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

Essas sequências afetam a posição do cursor em vez de inserir caracteres visíveis. O resultado visível depende do emulador de terminal.

Escapes Numéricos e Unicode

Hexadecimal (\xhh)

\x seguido de exatamente dois dígitos hex insere o caractere com aquele ponto de código. Isso funciona tanto em strings de bytes quanto em 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 um a três dígitos octais (0–7) insere o caractere com aquele ponto de código octal:

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

Os escapes octais são herdados do C e raramente são necessários em Python moderno. Prefira \x ou \u para melhor legibilidade.

Unicode (\uxxxx e \Uxxxxxxxx)

\u aceita exatamente quatro dígitos hex; \U aceita exatamente oito. Ambos inserem o caractere Unicode correspondente:

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

Unicode Nomeado (\N{name})

Você também pode referenciar um caractere Unicode pelo seu nome oficial. Esta é a forma mais legível para símbolos incomuns:

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

Os nomes são insensíveis a maiúsculas e minúsculas e provêm do banco de dados de caracteres Unicode.

Strings Raw

Uma string raw é um literal de string prefixado com r (ou R). Dentro de uma string raw, as barras invertidas são tratadas como barras invertidas literais — nenhuma sequência de escape é processada.

# 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

Strings raw são essenciais ao trabalhar com caminhos de arquivo do Windows e expressões regulares, onde barras invertidas aparecem com frequência:

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

Limitação das Strings Raw

Uma string raw não pode terminar com um número ímpar de barras invertidas. A barra invertida final ainda tentaria escapar a aspa de fechamento:

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

Armadilhas Comuns

Sequências de Escape Não Reconhecidas

Uma sequência de escape que não está na tabela padrão produz um aviso ou erro dependendo da versão do Python:

• Python 3.6–3.11: DeprecationWarning (suprimido por padrão; visível com -W all)
• Python 3.12+: SyntaxWarning (mostrado por padrão)
• Uma versão futura tornará isso um 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']

Sequências de Escape em Strings de Bytes

\u, \U e \N{name} não são válidos dentro de literais de bytes (b"..."). Apenas \x, \ooo, \\, \', \", \n, \t, \r, \b, \f, \a, \v e \0 funcionam em strings de bytes:

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

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

Strings de Aspas Triplas Ainda Processam Escapes

Uma string de aspas triplas ("""...""" ou '''...''') abrange múltiplas linhas e ainda processa sequências de escape. Use uma string raw de aspas triplas se precisar das barras invertidas literais:

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

Inspecionando Strings com repr()

A função embutida repr() mostra as sequências de escape brutas dentro de uma string, o que é inestimável para depuração:

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

Use repr() quando uma string "parece certa" na tela mas se comporta de forma inesperada — caracteres ocultos como \r, \x00 ou espaços Unicode invisíveis ficam imediatamente visíveis.

Tópicos Relacionados

• Python Strings — literais de string, estilos de aspas e noções básicas do tipo string
• Slicing Strings — como extrair substrings por índice
• Modify Strings — métodos embutidos de string para transformar texto
• Concatenate Strings — unindo strings com + e join()
• Format Strings — noções básicas de %, .format() e f-strings
• Python F-Strings — literais de string formatados modernos

Prática