Python: Caracteres de Escape (`\n`, `\t`)

Como você escreve, num texto de uma linha só, uma quebra de linha? Ou um Tab? Ou um apóstrofo e aspas duplas ao mesmo tempo? Você já viu uma pista na aula Strings: o modo interativo mostrou 'linha 1\nlinha 2'. Aquele \n é um caractere de escape: uma barra invertida (\) seguida de uma letra, que juntas querem dizer um caractere especial. Esta aula mostra os mais usados, as strings cruas (r"…"), que desligam esse efeito, e um aviso que o Python 3.12 começou a dar e que pega muita gente.

Você vai aprender

O que a barra invertida \ faz dentro de um texto.
A quebrar linhas com \n e a pôr tabulações com \t.
A escrever a própria barra (\\) e aspas dentro de aspas (\' e \").
A escrever uma letra pelo seu código Unicode: \u00e7 é o ç.
As strings cruas, r"C:\novo", e quando usá-las.
Os problemas reais: o caminho do Windows que se desmancha, o SyntaxError de "C:\Users" e o SyntaxWarning de "\d".

A ideia: a barra que avisa "o próximo é especial"

Nos bilhetes, às vezes a gente escreve "(pular linha)" para avisar quem vai passar a limpo. A palavra entre parênteses não é para ser copiada: ela é uma instrução. No Python, quem faz esse papel é a barra invertida. Quando ele encontra uma \ dentro de um texto, entende: "o caractere seguinte não é para ser lido ao pé da letra". A barra e a letra seguinte formam uma sequência de escape (o caractere "escapa" do seu sentido normal), e as duas juntas viram um caractere só.

Você escreve	Vira	Nome
`\n`	Uma quebra de linha	newline, "linha nova"
`\t`	Uma tabulação (a tecla Tab)	tab
`\\`	Uma barra invertida `\`	barra invertida (backslash)
`\'`	Um apóstrofo `'`	aspa simples
`\"`	Aspas duplas `"`	aspa dupla

1. `\n`: quebra de linha

print("Mãe,\nfui à padaria.\nVolto às 8.")
print("---")
print("Linha 1\n\nLinha 3")
print(len("\n"))

$ python3 quebra.py
Mãe,
fui à padaria.
Volto às 8.
---
Linha 1

Linha 3
1

"Mãe,\nfui à padaria.\nVolto às 8.": Um texto de uma linha só no código, mas com duas quebras dentro. Na tela, viraram três linhas.
\n\n: Duas quebras seguidas: uma linha em branco no meio.
len("\n"): Deu 1: a barra e o n são dois símbolos no código, mas um caractere só no texto.

O resultado é o mesmo das aspas triplas da aula Strings. Na verdade, o texto de aspas triplas guarda as quebras como \n, e é isso que o modo interativo mostra quando você pede o valor sem print:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> texto = "Ana\nBia"
>>> texto
'Ana\nBia'
>>> print(texto)
Ana
Bia
>>> exit()

Sem print, o modo interativo mostra o texto "como ele seria escrito no código", com aspas e com o \n à vista. Com print, mostra o texto "como ele é", com a quebra de verdade. (Você também já usou um \n sem saber: o print põe um no fim de tudo o que mostra. É o end="\n" da aula As Opções sep e end.)

Missão: o programa mostra a lista de compras numa linha só. Ponha \n no lugar dos espaços para que cada item fique numa linha, ainda com um único print.

print("pão leite café")

print("pão\nleite\ncafé")

2. `\t`: tabulação

O \t é a tecla Tab: ele empurra o que vem depois até a próxima "parada" da linha. No terminal, as paradas ficam a cada 8 colunas.

print("Produto\tPreço")
print("Pão\t0,80")
print("Café\t4,50")
print("Bolo de fubá\t25,00")

$ python3 tab.py
Produto Preço
Pão     0,80
Café    4,50
Bolo de fubá    25,00

As três primeiras linhas ficaram alinhadas: "Produto", "Pão" e "Café" têm menos de 8 letras, e o Tab levou todos para a coluna 8. Mas "Bolo de fubá" tem 12, passou da primeira parada, e o Tab o levou até a próxima, a coluna 16. A coluna dos preços entortou.

Para tabelas, prefira as f-strings

O \t é ótimo para separar campos num arquivo (muitas planilhas abrem textos separados por Tab), mas, para alinhar na tela, a largura das f-strings é mais confiável: f"{'Bolo de fubá':<15}{25:>8.2f}" (aula f-strings). Lá, você escolhe a largura de cada coluna, e ela não muda com o tamanho da palavra.

Missão: separe o nome e a nota com um \t, no lugar dos espaços, nas duas linhas.

print("Nome Nota")
print("Ana 9.5")

print("Nome\tNota")
print("Ana\t9.5")

3. `\'` e `\"`: aspas dentro de aspas

Na aula Strings, a saída para um apóstrofo era usar aspas duplas por fora. E quando o texto tem os dois? A barra resolve: \' e \" são aspas que não fecham o texto.

print('Copo d\'água')
print("Ela disse \"bom dia\"")
print("Copo d'água e \"bom dia\"")

$ python3 aspas-escape.py
Copo d'água
Ela disse "bom dia"
Copo d'água e "bom dia"

A terceira linha tem os dois tipos: o apóstrofo entra direto (o texto abriu com aspas duplas), e as aspas duplas de dentro vão com barra.

4. `\\`: a própria barra

Se a barra é especial, como escrever uma barra de verdade? Com duas: a primeira avisa, a segunda é a barra.

print("Use a barra invertida: \\")
print("C:\\Users\\ana")
print(len("\\"))

$ python3 barra.py
Use a barra invertida: \
C:\Users\ana
1

De novo, len("\\") é 1: duas barras no código, uma no texto.

5. Letras pelo código: `\u` e `\N{…}`

Todo caractere tem um número no padrão Unicode. Com \u seguido de 4 algarismos hexadecimais (de 0 a 9 e de a a f), você escreve um caractere pelo número; com \N{…}, pelo nome oficial, em inglês:

print("Cora\u00e7\u00e3o")
print("\N{LATIN SMALL LETTER C WITH CEDILLA}")
print("Caf\u00e9 \u2615")

$ python3 unicode.py
Coração
ç
Café ☕

\u00e7 é o ç, \u00e3 é o ã, \u00e9 é o é e \u2615 é uma xícara de café. No dia a dia, você digita as letras com acento direto, e funciona; o \u é útil para símbolos que não estão no teclado. O que importa aqui é saber que \u (e \U, com 8 algarismos) existe, porque ele causa um dos erros da seção Quando dá errado.

6. Strings cruas: `r"…"`

Às vezes você quer as barras ao pé da letra, sem efeito nenhum. Os dois casos clássicos são os caminhos de pastas do Windows (C:\Users\ana) e as expressões regulares, que usam barras o tempo todo. Para isso existem as strings cruas (em inglês, raw strings): um r antes das aspas.

print(r"C:\novo\teste")
print(r"C:\Users\ana")
print(r"Um \n de verdade")
print(len(r"\n"))

$ python3 cru.py
C:\novo\teste
C:\Users\ana
Um \n de verdade
2

r: De raw, "cru". Colado antes das aspas, como o f das f-strings.
"C:\novo\teste": Com o r, o \n e o \t não são quebra de linha nem Tab: são uma barra seguida de uma letra.
len(r"\n"): Deu 2: numa string crua, a barra e o n são dois caracteres de verdade.

A string crua é só um jeito diferente de escrever o texto no código. O resultado é um str comum: r"C:\Users" e "C:\\Users" são exatamente o mesmo texto.

Formas diferentes de escrever o mesmo texto

Você quer…	Opções	Qual usar
um texto de várias linhas	`"linha 1\nlinha 2"` · `"""linha 1 linha 2"""` · dois `print`	`\n` para textos curtos; aspas triplas para textos longos, que ficam mais fáceis de ler
apóstrofo no texto	`"Copo d'água"` · `'Copo d\'água'`	Aspas duplas por fora: sem barra nenhuma
apóstrofo e aspas duplas	`"d'água e \"oi\""` · `"""d'água e "oi\""""`	A barra (`\"`)
um caminho do Windows	`r"C:\Users\ana"` · `"C:\\Users\\ana"` · `"C:/Users/ana"`	A string crua; ou barras normais (`/`), que o Python aceita no Windows também. A aula pathlib mostra o jeito mais moderno
um padrão de expressão regular	`r"\d+"` · `"\\d+"`	Sempre a string crua

Quando dá errado

O caminho do Windows que se desmancha

Uma amiga da Ana, que usa Windows, mandou o caminho de uma pasta: C:\novo\teste. A Ana colou no programa:

print("C:\novo\teste")

$ python3 caminho.py
C:
ovo     este

Nenhuma mensagem de erro, e o caminho saiu destruído. O \n de \novo virou uma quebra de linha (sumiu o n), e o \t de \teste virou um Tab (sumiu o t). O Python fez exatamente o que está escrito. Como consertar: string crua, r"C:\novo\teste", ou barras dobradas, "C:\\novo\\teste".

"C:\Users": o erro unicodeescape

print("C:\Users\ana")

$ python3 caminho-users.py
  File "/home/ana/caminho-users.py", line 1
    print("C:\Users\ana")
          ^^^^^^^^^^^^^^
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \UXXXXXXXX escape

Agora o programa nem rodou. A mensagem assusta, mas dá para ler por partes:

SyntaxError:: "Erro de sintaxe": o Python achou o problema só de ler o código.
(unicode error) 'unicodeescape' codec: Quem reclamou foi a parte do Python que entende as sequências \u e \U (seção 5).
can't decode bytes in position 2-3: "Não consegui entender os caracteres das posições 2 e 3" do texto: o \U de \Users (contando do zero: C é 0, : é 1, a barra é 2, o U é 3).
truncated \UXXXXXXXX escape: "Sequência \U incompleta": depois de \U, o Python esperava 8 algarismos hexadecimais (o XXXXXXXX) com o número de um caractere, e encontrou sers.

É o erro mais famoso de quem usa Windows, porque todo caminho de usuário começa com C:\Users. Como consertar: r"C:\Users\ana".

"\d": o SyntaxWarning do Python 3.12 em diante

E se a letra depois da barra não for nenhuma das especiais? A Ana copiou da internet um padrão de expressão regular (aula Expressões Regulares) que procura algarismos:

padrao = "\d+"
print(padrao)

$ python3 aviso-d.py
/home/ana/aviso-d.py:1: SyntaxWarning: "\d" is an invalid escape sequence. Such sequences will not work in the future. Did you mean "\\d"? A raw string is also an option.
  padrao = "\d+"
\d+

O programa funcionou (a última linha mostra \d+, com a barra), mas veio um aviso. Por partes:

/home/ana/aviso-d.py:1:: Arquivo e linha (a 1).
SyntaxWarning:: "Aviso de sintaxe": não é um erro, o programa continua. Mas é um aviso sério.
"\d" is an invalid escape sequence.: "\d é uma sequência de escape inválida": \d não quer dizer nada para o Python.
Such sequences will not work in the future.: "Sequências assim não vão funcionar no futuro." Hoje, o Python deixa a barra no texto, de favor. Numa versão futura, isso vai virar erro.
Did you mean "\\d"? A raw string is also an option.: "Você quis dizer \\d? Uma string crua também é uma opção." As duas saídas certas.

Como consertar: string crua, que é o costume para expressões regulares:

padrao = r"\d+"
print(padrao)
print("\\d+")

$ python3 aviso-d-cru.py
\d+
\d+

Sem aviso, e o texto é o mesmo nas duas formas.

Em versões mais antigas

Até o Python 3.11, o mesmo "\d" dava um DeprecationWarning, um aviso que fica escondido quando você roda o programa normalmente. Por isso tanto código antigo, e tanto exemplo na internet, tem "\d" sem r. Desde o 3.12, o aviso virou SyntaxWarning e aparece para todo mundo, como você viu no Python 3.14 da Ana; a documentação oficial avisa que, no futuro, vai virar SyntaxError. (O comportamento do 3.11 está descrito conforme a documentação; não deu para rodá-lo no laboratório.)

String crua terminando em barra

pasta = r"C:\pasta\"
print(pasta)

$ python3 cru-fim.py
  File "/home/ana/cru-fim.py", line 1
    pasta = r"C:\pasta\"
            ^
SyntaxError: unterminated string literal (detected at line 1); perhaps you escaped the end quote?

Uma pegadinha das strings cruas: elas não podem terminar com uma barra. Mesmo crua, a barra ainda impede que a aspa seguinte feche o texto (a barra fica no texto, mas a aspa também). Por isso o texto nunca fecha: unterminated string literal, e o Python pergunta, com razão: perhaps you escaped the end quote?, "será que você 'escapou' a aspa do fim?". Como consertar: tire a barra do fim (r"C:\pasta"), ou use barras dobradas num texto normal: "C:\\pasta\\".

Referência rápida

Escrita	Vira	Exemplo → resultado
`\n`	Quebra de linha	`len("a\nb")` → `3`
`\t`	Tabulação	`"a\tb".split("\t")` → `['a', 'b']`
`\\`	Uma barra invertida	`print("x\\y")` → `x\y`
`\'`	Apóstrofo	`'d\'água'` → `d'água`
`\"`	Aspas duplas	`"\"oi\""` → `"oi"`
`\u00e7`	O caractere de código Unicode 00e7	`ç`
`\N{nome}`	O caractere com esse nome Unicode	`"\N{LATIN SMALL LETTER C WITH CEDILLA}"` → `ç`
`r"…"`	String crua: barras ao pé da letra	`len(r"a\nb")` → `4`

Sintoma	Causa provável
Um caminho saiu quebrado em duas linhas, ou com espaços no meio	`\n` ou `\t` sem querer: use `r"…"`
`SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes … truncated \UXXXXXXXX escape`	`\U` num caminho (`C:\Users`): use `r"…"`
`SyntaxWarning: "\d" is an invalid escape sequence`	Barra seguida de uma letra sem sentido: `r"\d"` ou `"\\d"`
`SyntaxError: unterminated string literal … perhaps you escaped the end quote?`	Texto terminando em `\"` (até numa string crua)

Exercícios

1. Pular linha

Complete para que "Ana" e "Bia" saiam em linhas separadas:

print("AnaBia")

2. Contando

Quanto vale len("a\tb")?

3. A letra do cru

Complete para que as barras fiquem ao pé da letra:

print("C:\Users\ana")

4. O que print("C:\novo") mostra?

C:\novo C: numa linha e ovo na seguinte Dá SyntaxError C:novo

5. Quanto vale len(r"a\nb")?

3 2 Dá erro 4: na string crua, a barra e o n são dois caracteres

6. No Python 3.14, padrao = "\d+" faz o quê?

Funciona, mas dá um SyntaxWarning: o certo é r"\d+" Dá SyntaxError e o programa não roda Funciona, sem aviso nenhum Vira um algarismo

Missão final: o caminho das notas

Missão: a Ana quer mostrar o caminho de uma pasta do computador da escola, que usa Windows, mas o programa dá SyntaxError. Conserte, para que apareça exatamente C:\Users\ana\notas.

pasta = "C:\Users\ana\notas"
print(pasta)

pasta = r"C:\Users\ana\notas"
print(pasta)

Funcionou com r"…"? Tente também com as barras dobradas ("C:\\Users\\ana\\notas"): o resultado é o mesmo.

Resumo

Dentro de um texto, a barra invertida \ avisa que o próximo caractere é especial. Juntos, eles viram um caractere.
\n quebra a linha, \t é um Tab, \\ é uma barra, \' e \" são aspas que não fecham o texto, \u00e7 é um caractere pelo código Unicode.
Sem print, o modo interativo mostra os escapes ('Ana\nBia'); com print, mostra o efeito.
Strings cruas, r"…", deixam as barras ao pé da letra: use em caminhos do Windows e em expressões regulares. Elas não podem terminar com uma barra só.
"C:\Users" dá SyntaxError … unicodeescape, e "\d" dá SyntaxWarning desde o Python 3.12 (e um dia vai dar erro). A saída é sempre a mesma: r"…" ou \\.