Python Strings: Textos

Desde o primeiro programa você escreve textos: print("Olá, mundo!"). Em programação, um texto se chama string (em inglês, "cordão", "fileira": uma fileira de letras, uma atrás da outra). No Python, o tipo dos textos se chama str, de string. Nomes, endereços, mensagens, senhas, a lista de compras da Ana: tudo isso é string. Esta aula abre o grupo Textos e mostra o básico: como escrever um texto, como contar as letras dele e por que um texto, depois de criado, não muda.

Você vai aprender

A escrever textos com aspas simples ('), duplas (") e triplas ("""), e quando usar cada uma.
A pôr um apóstrofo ou aspas dentro do texto, como em Copo d'água.
Por que "10" e 10 são coisas diferentes.
A contar os caracteres com len() (acentos e espaços contam).
Que um texto é imutável: não dá para trocar uma letra dele. E o que fazer no lugar.
Os erros reais: aspas sem fechar, texto sem aspas, len() de um número.

A ideia: um colar de contas

Imagine um colar de contas, cada conta com uma letra pintada: A, n, a. A string é esse colar: uma fileira de caracteres em ordem. "Caractere" é qualquer símbolo que se escreve: uma letra (a, Ç), um algarismo (7), um espaço, uma pontuação (!), até um emoji. As aspas são o fecho do colar: mostram ao Python onde o texto começa e onde termina.

Sem as aspas, o Python acharia que Ana é o nome de uma variável. Com as aspas, "Ana" é um valor: o texto A-n-a.

1. Aspas simples ou duplas

Você pode escrever um texto entre aspas duplas (") ou simples ('). Para o Python, tanto faz:

nome = "Ana"
cidade = 'Teresina'

print(nome)
print(cidade)
print("Olá, mundo!")

$ python3 aspas.py
Ana
Teresina
Olá, mundo!

"Ana": Um texto entre aspas duplas. As aspas não fazem parte do texto: o print mostra só Ana.
'Teresina': Um texto entre aspas simples. Mesmo tipo, mesmo comportamento.
nome = "Ana": Guarda o texto numa variável, como qualquer outro valor (aula Variáveis).

No modo interativo dá para conferir que os dois jeitos dão o mesmo texto, e que o tipo é str (a função type(), da aula Descobrindo o Tipo):

$ 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.
>>> nome = "Ana"
>>> nome
'Ana'
>>> print(nome)
Ana
>>> type(nome)
<class 'str'>
>>> 'Ana' == "Ana"
True
>>> exit()

Repare numa diferença. Quando você digita só nome, o modo interativo mostra 'Ana', com aspas (simples, mesmo que você tenha escrito duplas). Ele está dizendo "isto é um texto". O print(nome) mostra o texto como ele é, sem aspas, para uma pessoa ler. É o mesmo texto; só a apresentação muda.

Escolha um jeito e mantenha

O Python aceita os dois, mas misturar à toa deixa o código bagunçado. Este guia usa aspas duplas no dia a dia, como a maioria dos projetos (e como a ferramenta de formatação mais usada, o Black, deixa o código). As simples ficam para quando o texto tem aspas duplas dentro, como você vai ver agora.

2. Apóstrofo e aspas dentro do texto

Por que existem os dois tipos de aspas? Para você poder escrever um tipo dentro do texto, usando o outro por fora:

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

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

"Copo d'água": o texto abre com aspas duplas, então o Python só considera o texto terminado na próxima aspa dupla. O apóstrofo (') no meio é só mais um caractere.
'Ela disse "bom dia"': o contrário. Abre com simples, e as duplas de dentro são caracteres comuns.

E se o texto tiver os dois, apóstrofo e aspas duplas? Aí entra a barra invertida (\' e \"), assunto da aula Caracteres de Escape. Ou as aspas triplas, logo abaixo.

Missão: a placa da lanchonete da Ana dá erro de sintaxe. Troque as aspas de fora para que o apóstrofo possa ficar dentro do texto.

print('Copo d'água: R$ 2')

print("Copo d'água: R$ 2")

3. Aspas triplas: textos de várias linhas

Um texto entre aspas simples ou duplas precisa caber numa linha só. Para um texto com várias linhas, como um bilhete, use três aspas seguidas para abrir e três para fechar:

bilhete = """Mãe,
fui à padaria.
Volto às 8."""

print(bilhete)

$ python3 triplas.py
Mãe,
fui à padaria.
Volto às 8.

""": Três aspas duplas, coladas: abrem o texto. (Três simples, ''', também funcionam; o costume é o das duplas.)
Mãe, … Volto às 8.: O texto, com as quebras de linha que você digitou. Elas fazem parte do texto.
""": Mais três aspas: fecham o texto.

Como o Python guarda essas quebras de linha? No modo interativo dá para espiar:

$ 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 = """linha 1
... linha 2"""
>>> texto
'linha 1\nlinha 2'
>>> print(texto)
linha 1
linha 2
>>> exit()

O ... é o modo interativo avisando "o texto ainda não fechou, continue". E o \n que aparece em 'linha 1\nlinha 2' é o jeito de escrever a quebra de linha num texto de uma linha só; o print a transforma numa linha nova de verdade. É o assunto da aula Caracteres de Escape.

Aspas triplas sem variável

Você vai ver aspas triplas logo no começo de funções e de arquivos, explicando o que o código faz. São as docstrings, que têm aula própria: Docstrings.

4. `"10"` não é `10`

Tudo o que está entre aspas é texto, mesmo que pareça um número. Olhe o que o + faz com cada um:

$ 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.
>>> "10" + "5"
'105'
>>> 10 + 5
15
>>> type("10")
<class 'str'>
>>> exit()

Com números, o + soma: 15. Com textos, ele emenda um no outro: o texto "10" seguido do texto "5" dá o texto "105". Isso tem nome, concatenação, e é assunto da aula Juntar e Repetir Textos. Quando o input() lê o teclado, ele sempre devolve texto; é por isso que a aula Conversão de Tipos ensina a transformar "10" em 10 com int().

Por que um número às vezes deve ficar como texto? Telefone, CEP, CPF: você não faz conta com eles, e um CEP como "01310-100" tem até traço. Guarde como texto.

5. `len()`: quantos caracteres?

A função len() (de length, "comprimento") conta quantos caracteres o texto tem:

print(len("Ana"))
print(len("pão"))
print(len("Ana Maria"))
print(len(""))

nome = "Ana Beatriz"
print("O nome tem", len(nome), "caracteres")

$ python3 tamanho.py
3
3
9
0
O nome tem 11 caracteres

len("Ana") é 3: A, n, a.
len("pão") também é 3. A letra com acento, ã, conta como um caractere só, como você esperaria.
len("Ana Maria") é 9: 3 letras, mais o espaço, mais 5 letras. O espaço conta.
len("") é 0. Duas aspas sem nada no meio são o texto vazio: um texto que existe, mas não tem caractere nenhum.

Um uso comum: conferir se uma senha tem o tamanho mínimo, ou se o usuário deixou um campo em branco (aí o tamanho é 0). Você vai fazer essas perguntas com o if, em breve.

Missão: o programa deveria mostrar quantos caracteres tem a senha, mas está escrito o número na mão (e errado). Troque o 5 por len(senha).

senha = "pão-2026"
print("A senha tem", 5, "caracteres")

senha = "pão-2026"
print("A senha tem", len(senha), "caracteres")

6. Um texto não muda: imutabilidade

Cada caractere de um texto tem uma posição, chamada índice, que começa no zero: em "Ana", o A está na posição 0. Você lê um caractere com colchetes: nome[0] (a aula Índices e Fatias é toda sobre isso).

$ 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.
>>> nome = "Ana"
>>> nome[0]
'A'
>>> exit()

Ler, pode. Mas e trocar o A por um B?

nome = "Ana"
nome[0] = "B"
print(nome)

$ python3 imutavel.py
Traceback (most recent call last):
  File "/home/ana/imutavel.py", line 2, in <module>
    nome[0] = "B"
    ~~~~^^^
TypeError: 'str' object does not support item assignment

Traceback (most recent call last):: O Python vai contar onde o erro aconteceu (a aula Lendo uma Mensagem de Erro explica cada parte).
File "/home/ana/imutavel.py", line 2: No arquivo imutavel.py, linha 2.
~~~~^^^: As marcas apontam o nome[0]: os ~ sublinham o texto, os ^ a posição que você tentou mudar.
TypeError:: "Erro de tipo": esse tipo de valor não aceita essa operação.
'str' object does not support item assignment: "Um objeto str não aceita atribuição a um item": não dá para pôr outro caractere numa posição do texto.

As strings do Python são imutáveis: depois de criado, um texto nunca muda. É como uma palavra gravada numa placa de metal: você não troca uma letra da placa; se quiser outra palavra, faz uma placa nova. No Python, a "placa nova" é um texto novo guardado na mesma variável:

nome = "Ana"
print(nome)

nome = "Bia"
print(nome)

$ python3 imutavel2.py
Ana
Bia

Aqui nada foi alterado: o texto "Ana" continua igual; a variável nome é que passou a apontar para outro texto, "Bia". A variável pode mudar de valor à vontade; o texto, não. E quando você quiser "trocar o A por B" de verdade, existem jeitos que fabricam um texto novo a partir do antigo: o método replace() (aula Métodos de Texto) e as fatias com + (aula Índices e Fatias). Por que o Python foi feito assim é assunto da aula Mutável × Imutável.

Formas diferentes de escrever um texto

Forma	Exemplo	Quando usar
Aspas duplas	`"Ana"`	O normal, no dia a dia (e o padrão deste guia)
Aspas simples	`'Ela disse "oi"'`	Quando o texto tem aspas duplas dentro
Aspas duplas com apóstrofo	`"Copo d'água"`	Quando o texto tem apóstrofo
Aspas triplas	`"""linha 1 linha 2"""`	Textos de várias linhas e docstrings
Texto vazio	`""`	Um texto sem nada, para começar e ir preenchendo depois

Quando dá errado

Esqueceu de fechar as aspas

print("Olá, Ana)

$ python3 sem-fechar.py
  File "/home/ana/sem-fechar.py", line 1
    print("Olá, Ana)
          ^
SyntaxError: unterminated string literal (detected at line 1)

File "/home/ana/sem-fechar.py", line 1: O problema está na linha 1. Repare que não há Traceback: o Python nem começou a rodar. Ele achou o erro só de ler o código.
^: Aponta a aspa que abriu o texto.
SyntaxError:: "Erro de sintaxe": o código não está escrito do jeito que o Python entende.
unterminated string literal: "Texto sem terminar": a aspa abriu e a linha acabou sem a aspa que fecha. O ) virou parte do texto.
(detected at line 1): "Percebido na linha 1".

Como consertar: feche as aspas antes do parêntese: print("Olá, Ana").

Apóstrofo dentro de aspas simples

print('Copo d'água')

$ python3 apostrofo.py
  File "/home/ana/apostrofo.py", line 1
    print('Copo d'água')
                      ^
SyntaxError: unterminated string literal (detected at line 1)

O mesmo erro, mas o ^ está no fim da linha. Por quê? O Python leu o texto 'Copo d' (o apóstrofo fechou o texto), depois a palavra água, e então a última aspa, que abriu um texto novo que nunca fecha. Como consertar: aspas duplas por fora, print("Copo d'água").

Aspas duplas dentro de aspas duplas

print("Ela disse "oi"")

$ python3 aspas-duplas.py
  File "/home/ana/aspas-duplas.py", line 1
    print("Ela disse "oi"")
                      ^^
SyntaxError: invalid syntax. Is this intended to be part of the string?

Agora a mensagem é outra. O Python leu o texto "Ela disse ", que terminou na segunda aspa; depois encontrou oi solto, colado no texto, e isso não faz sentido (invalid syntax, "sintaxe inválida"). Os ^^ sublinham o oi, e a dica pergunta: "isto era para fazer parte do texto?". Era! Como consertar: aspas simples por fora, print('Ela disse "oi"').

Aspas triplas sem fechar

bilhete = """Mãe,
fui à padaria.

print(bilhete)

$ python3 triplas-aberta.py
  File "/home/ana/triplas-aberta.py", line 1
    bilhete = """Mãe,
              ^
SyntaxError: unterminated triple-quoted string literal (detected at line 4)

unterminated triple-quoted string literal: "texto de aspas triplas sem terminar". O Python leu até o fim do arquivo (linha 4) procurando as três aspas que fecham, e não achou; até o print(bilhete) virou parte do bilhete. O ^ aponta onde o texto abriu, na linha 1. Como consertar: feche com """ no fim do bilhete.

Texto sem aspas

print(Ana)

$ python3 sem-aspas.py
Traceback (most recent call last):
  File "/home/ana/sem-aspas.py", line 1, in <module>
    print(Ana)
          ^^^
NameError: name 'Ana' is not defined. Did you mean: 'any'?

NameError: name 'Ana' is not defined: "o nome Ana não está definido". Sem aspas, Ana é o nome de uma variável, e nenhuma variável com esse nome foi criada. O Python ainda tenta ajudar, com Did you mean: 'any'? ("você quis dizer any?", uma função do Python de nome parecido), mas aqui a dica não serve: o que faltou foram as aspas. Como consertar: print("Ana").

len() de um número

telefone = 86999990000
print(len(telefone))

$ python3 len-numero.py
Traceback (most recent call last):
  File "/home/ana/len-numero.py", line 2, in <module>
    print(len(telefone))
          ~~~^^^^^^^^^^
TypeError: object of type 'int' has no len()

object of type 'int' has no len(): "um objeto do tipo int não tem len()". Um número não é uma fileira de caracteres, então não tem "comprimento". Como consertar: guarde o telefone como texto, telefone = "86999990000", como dito na seção 4. (Ou, se ele vier como número, len(str(telefone)).)

Referência rápida

Escrita	O que faz	Exemplo → resultado
`"texto"` ou `'texto'`	Cria um texto (tipo `str`)	`type("Ana")` → `<class 'str'>`
`"""…"""`	Texto de várias linhas	`"""linha 1 linha 2"""`
`""`	Texto vazio	`len("")` → `0`
`len(texto)`	Quantos caracteres (espaços e acentos contam)	`len("Ana Maria")` → `9`
`texto[0]`	Lê o primeiro caractere	`"Ana"[0]` → `'A'`
`texto[0] = "B"`	Não funciona: textos são imutáveis	`TypeError`

Sintoma	Causa provável
`SyntaxError: unterminated string literal`	Aspas sem fechar, ou um apóstrofo dentro de aspas simples
`SyntaxError: invalid syntax. Is this intended to be part of the string?`	Aspas iguais às de fora dentro do texto: troque as de fora
`SyntaxError: unterminated triple-quoted string literal`	Faltou o `"""` que fecha
`NameError: name 'Ana' is not defined`	Texto escrito sem aspas
`TypeError: 'str' object does not support item assignment`	Tentou trocar um caractere: crie um texto novo
`TypeError: object of type 'int' has no len()`	`len()` de um número
`"10" + "5"` deu `'105'`	Eram textos, não números: converta com `int()`

Exercícios

1. Contando

Quanto vale len("café")?

2. O espaço conta

Quanto vale len("Ana Maria")?

3. O tipo

Complete: type("10") mostra <class '…'>.

4. Qual destas linhas mostra Ela disse "oi" sem dar erro?

print("Ela disse "oi"") print(Ela disse "oi") print('Ela disse "oi"') print("""Ela disse "oi"""")

5. Quanto vale "2" + "2"?

4 '22' Dá TypeError '4'

6. Com nome = "Ana", o que acontece em nome[0] = "B"?

nome passa a valer "Bna" nome passa a valer "B" Nada: a linha é ignorada TypeError: textos não podem ser alterados

Missão final: a lista de compras

Missão: a Ana quer guardar a lista de compras numa variável só, com um item por linha, e mostrar com um único print. Hoje o programa mostra tudo numa linha. Reescreva o texto com aspas triplas para sair assim: pão, leite e café, um embaixo do outro.

compras = "pão leite café"
print(compras)

compras = """pão
leite
café"""
print(compras)

Resumo

Uma string (tipo str) é um texto: uma fileira de caracteres entre aspas.
Aspas simples e duplas funcionam igual; use uma por fora quando a outra aparece dentro ("Copo d'água"). Aspas triplas (""") servem para textos de várias linhas.
Tudo entre aspas é texto: "10" + "5" dá '105'.
len() conta os caracteres; espaços contam, letras com acento contam como um, e len("") é 0.
Textos são imutáveis: nome[0] = "B" dá TypeError. Para mudar, crie um texto novo e guarde na variável.
Aspas sem fechar dão SyntaxError: unterminated string literal; texto sem aspas dá NameError.