Python Métodos de String

Esta é a página de consulta rápida dos métodos de string: as funções que todo texto (str) já traz e que você chama com um ponto, como em nome.upper(). O Python 3.14 tem 47 deles, para trocar maiúsculas e minúsculas, procurar, trocar, limpar, dividir, juntar, alinhar, testar e codificar textos. Cada linha traz um exemplo curto e o resultado real. A explicação passo a passo dos mais usados, com exercícios, está na aula Métodos de Texto.

Como ler as tabelas

Exemplo é o que você digitaria depois do >>> do modo interativo; Resultado é o que o Python 3.14.4 respondeu no computador da Ana. O modo interativo mostra textos entre aspas ('Ana'); com print() elas não aparecem.
Quando o exemplo dá erro, o resultado mostra a última linha da mensagem do Python (em inglês).
Espaços que importam estão marcados no texto da explicação. \n é a quebra de linha e \t é a tabulação (veja Caracteres de Escape).
A anatomia de uma chamada: "banana".count("a") = o texto, um ponto, o nome do método e, entre parênteses, os argumentos.

O texto original nunca muda

Strings são imutáveis: nenhum método altera o texto. Cada um devolve um texto novo, e quem quiser guardá-lo precisa de uma atribuição (nome = nome.capitalize()). Veja no terminal:

$ python3 -q
>>> nome = "ana"
>>> nome.upper()
'ANA'
>>> nome
'ana'
>>> nome[0] = "A"
Traceback (most recent call last):
  File "<python-input-3>", line 1, in <module>
    nome[0] = "A"
    ~~~~^^^
TypeError: 'str' object does not support item assignment
>>> nome = nome.capitalize()
>>> nome
'Ana'
>>> exit()

O nome.upper() mostrou 'ANA', mas nome continuou 'ana'. Trocar uma letra direto também não dá: TypeError: 'str' object does not support item assignment = "o objeto str não aceita atribuição a um item". O jeito certo é a última linha: guardar o texto novo na variável.

Pule direto para o grupo que você procura:

Maiúsculas e minúsculas: upper, lower, capitalize, title, swapcase, casefold
Procurar e contar: find, rfind, index, rindex, count, startswith, endswith
Trocar e limpar: replace, strip, lstrip, rstrip, removeprefix, removesuffix, expandtabs, maketrans, translate
Dividir e juntar: split, rsplit, splitlines, partition, rpartition, join
Alinhar e completar: center, ljust, rjust, zfill
Testar (os is…): isalpha, isdigit, isdecimal, isnumeric, isalnum, isspace, islower, isupper, istitle, isascii, isidentifier, isprintable
Formatar e codificar: format, format_map, encode
Operadores e funções que também servem para texto

Maiúsculas e minúsculas

Método	O que faz	Exemplo	Resultado	Aula
`upper()`	Tudo em MAIÚSCULAS (upper case). Acentos funcionam.	`"Conceição".upper()`	`'CONCEIÇÃO'`	Métodos de Texto
`lower()`	Tudo em minúsculas (lower case).	`"JOSÉ RIBAMAR".lower()`	`'josé ribamar'`	Métodos de Texto
`capitalize()`	Só a primeira letra maiúscula; o resto vira minúscula.	`"ana BEATRIZ".capitalize()`	`'Ana beatriz'`	Métodos de Texto
`title()`	A primeira letra de cada palavra maiúscula (como num título).	`"ana beatriz de sousa".title()`	`'Ana Beatriz De Sousa'`
	depois de um apóstrofo também conta como palavra nova	`"pão d'água".title()`	`"Pão D'Água"`
`swapcase()`	Inverte: maiúsculas viram minúsculas e vice-versa (swap = "trocar").	`"Ana".swapcase()`	`'aNA'`
`casefold()`	Minúsculas "fortes", feitas para comparar textos sem ligar para maiúsculas. Diferente do `lower()` em letras como o `ß` alemão.	`"Straße".lower()` `"Straße".casefold()`	`'straße'` `'strasse'`	Comparações
	comparar sem diferenciar maiúsculas	`"ÁGUA".casefold() == "água".casefold()`	`True`

Procurar e contar

As posições começam em 0: em "banana", o b está na posição 0, o primeiro n na 2 (veja Índices e Fatias).

Método	O que faz	Exemplo	Resultado	Aula
`find(sub)`	A posição da primeira vez que `sub` aparece.	`"banana".find("na")`	`2`	Métodos de Texto
	não achou: devolve `-1` (sem erro)	`"banana".find("x")`	`-1`
`find(sub, início)`	Começa a procurar na posição `início`.	`"banana".find("a", 2)`	`3`
`rfind(sub)`	A posição da última vez (procura da direita, right).	`"banana".rfind("na")`	`4`
`index(sub)`	Como o `find`…	`"banana".index("na")`	`2`
	…mas, se não acha, dá erro	`"banana".index("x")`	`ValueError: substring not found`	try e except
`rindex(sub)`	Como o `rfind`, com erro se não acha.	`"banana".rindex("na")`	`4`
`count(sub)`	Quantas vezes `sub` aparece (sem sobrepor).	`"banana".count("a")`, `"banana".count("na")`	`3`, `2`	Métodos de Texto
`startswith(início)`	"Começa com…?" (starts with)	`"Dr. Ana".startswith("Dr.")`	`True`	Métodos de Texto
`endswith(fim)`	"Termina com…?" (ends with)	`"foto.jpg".endswith(".jpg")`	`True`
	aceita uma tupla de opções; diferencia maiúsculas	`"foto.JPG".endswith((".jpg", ".png"))`	`False`
`sub in texto`	Não é método, mas é o jeito mais simples de perguntar "tem?"	`"ana" in "banana"`	`True`	is e in

find ou index?

Use in quando só quer saber se tem. Use find quando quer a posição e "não achou" é normal (teste se deu -1). Use index quando o texto tem que estar lá: se não estiver, o erro avisa logo. O -1 do find é traiçoeiro: texto[texto.find("x")] pega a última letra sem reclamar.

Trocar e limpar

Método	O que faz	Exemplo	Resultado	Aula
`replace(de, para)`	Troca todas as vezes que `de` aparece por `para`.	`"2026-10-18".replace("-", "/")`	`'2026/10/18'`	Métodos de Texto
`replace(de, para, n)`	Troca só as `n` primeiras.	`"banana".replace("a", "o", 1)`	`'bonana'`
	desde o 3.13, o `n` pode ter nome: `count=`	`"banana".replace("a", "o", count=2)`	`'bonona'`
`strip()`	Tira os espaços (e `\n`, `\t`) do começo e do fim (strip = "descascar").	`" Ana ".strip()`	`'Ana'`	Métodos de Texto
`lstrip()`	Só do começo (à esquerda, left).	`" Ana ".lstrip()`	`'Ana '`
`rstrip()`	Só do fim (à direita, right). Muito usado para tirar o `\n` das linhas de um arquivo.	`" Ana ".rstrip()`	`' Ana'`	Lendo Arquivos
`strip(letras)`	Tira das pontas qualquer das letras dadas (não é uma palavra!).	`"--PI--".strip("-")`	`'PI'`
		`"000123".lstrip("0")`	`'123'`
	cuidado: tira `w`, `.`, `m`, `o` e `c` em qualquer ordem	`"www.loja.com".strip("w.moc")`	`'loja'`
`removeprefix(início)`	Tira o começo, se for exatamente esse texto. Se não for, devolve o texto igual.	`"Sr. Davi".removeprefix("Sr. ")` `"Sr. Davi".removeprefix("Dr. ")`	`'Davi'` `'Sr. Davi'`
`removesuffix(fim)`	Tira o fim, se for exatamente esse texto.	`"foto.jpg".removesuffix(".jpg")`	`'foto'`
`expandtabs(n)`	Troca cada `\t` por espaços, até a próxima coluna múltipla de `n` (o padrão é 8).	`"a\tb".expandtabs(4)`	`'a b'`	Caracteres de Escape
`str.maketrans(de, para)`	Monta uma "tabela de troca", letra por letra, para o `translate`. É chamado no tipo `str`, não num texto.	`tabela = str.maketrans("áéç", "aec")` `tabela`	`{225: 97, 233: 101, 231: 99}` (os códigos das letras, veja `ord`)
`translate(tabela)`	Troca cada letra segundo a tabela. Letras fora da tabela ficam.	`"maçã é café".translate(tabela)`	`'macã e cafe'` (o `ã` não estava na tabela)
	com um dicionário: trocar vários sinais de uma vez	`"R$ 1.234,50".translate(str.maketrans({".": "", ",": "."}))`	`'R$ 1234.50'`
	o terceiro argumento do `maketrans` lista o que apagar	`"(11) 9999-0000".translate(str.maketrans("", "", "()- "))`	`'1199990000'`

Dividir e juntar

Método	O que faz	Exemplo	Resultado	Aula
`split()`	Corta o texto nos espaços e devolve uma lista de palavras. Vários espaços seguidos contam como um.	`"arroz feijão café".split()`	`['arroz', 'feijão', 'café']`	Métodos de Texto
`split(sep)`	Corta em cada `sep`. Dois `sep` seguidos dão um texto vazio no meio.	`"arroz,feijão,,café".split(",")`	`['arroz', 'feijão', '', 'café']`	Arquivos CSV
`split(sep, n)`	Corta no máximo `n` vezes, da esquerda.	`"a,b,c,d".split(",", 2)`	`['a', 'b', 'c,d']`
`rsplit(sep, n)`	Corta no máximo `n` vezes, da direita.	`"a,b,c,d".rsplit(",", 1)`	`['a,b,c', 'd']`
`splitlines()`	Corta nas quebras de linha (`\n`, `\r\n`…), sem deixar um item vazio no fim.	`"linha 1\nlinha 2\r\nlinha 3".splitlines()`	`['linha 1', 'linha 2', 'linha 3']`	Lendo Arquivos
	compare com `split("\n")`	`"linha 1\nlinha 2\n".split("\n")`	`['linha 1', 'linha 2', '']`
	`keepends=True` mantém as quebras	`"linha 1\nlinha 2\n".splitlines(keepends=True)`	`['linha 1\n', 'linha 2\n']`
`partition(sep)`	Corta na primeira vez que `sep` aparece e devolve uma tupla de 3: antes, o separador, depois.	`"nome=Ana=Sousa".partition("=")`	`('nome', '=', 'Ana=Sousa')`	Desempacotamento
	se não acha, o texto todo fica na primeira parte	`"sem igual".partition("=")`	`('sem igual', '', '')`
`rpartition(sep)`	Corta na última vez.	`"nome=Ana=Sousa".rpartition("=")`	`('nome=Ana', '=', 'Sousa')`
`sep.join(lista)`	O contrário do `split`: junta os textos da lista, com `sep` entre eles. Repare: o método é chamado no separador.	`", ".join(["arroz", "feijão", "café"])`	`'arroz, feijão, café'`	Juntar e Repetir Textos
	sem separador	`"".join(["A", "n", "a"])`	`'Ana'`
	um texto também é uma sequência	`"-".join("Ana")`	`'A-n-a'`
	só junta textos	`", ".join([1, 2, 3])`	`TypeError: sequence item 0: expected str instance, int found`
	converta antes	`", ".join(str(n) for n in [1, 2, 3])`	`'1, 2, 3'`	Conversão de Tipos

Alinhar e completar

Os quatro recebem a largura final do texto. Se o texto já for maior, ele volta igual.

Método	O que faz	Exemplo	Resultado	Aula
`center(largura)`	Centraliza, completando com espaços dos dois lados.	`"Ana".center(9)`	`' Ana '`	Formatação
`center(largura, letra)`	Completa com outra letra.	`"Ana".center(9, "*")`	`'*Ana*'`
`ljust(largura)`	Alinha à esquerda (completa à direita).	`"Ana".ljust(6) + "\|"`	`'Ana \|'`
`rjust(largura)`	Alinha à direita (completa à esquerda).	`"Ana".rjust(6)`	`' Ana'`
		`"7".rjust(3, "0")`	`'007'`
`zfill(largura)`	Completa com zeros à esquerda (zero fill), respeitando o sinal.	`"42".zfill(5)`, `"-42".zfill(5)`	`'00042'`, `'-0042'`

As f-strings fazem o mesmo com {nome:^9}, {nome:<6}, {nome:>6} e {numero:05}: veja Formatação.

Testar (os métodos `is…`)

Todos respondem True ou False. Para o texto vazio "", quase todos respondem False; só isascii() e isprintable() respondem True.

Método	"O texto todo é…?"	Exemplo	Resultado
`isalpha()`	só letras (acentuadas valem)	`"Conceição".isalpha()` `"".isalpha()`	`True` `False`
`isalnum()`	só letras e algarismos (alphanumeric). Espaço não vale.	`"Ana2026".isalnum()` `"Ana Sousa".isalnum()`	`True` `False`
`isdigit()`	só algarismos. Ponto e sinal de menos não são algarismos!	`"123".isdigit()` `"12.5".isdigit()` `"-5".isdigit()`	`True` `False` `False`
`isdecimal()`	só algarismos de 0 a 9 (os que o `int()` aceita). É o mais rigoroso dos três.	`"123".isdecimal()` `"²".isdecimal()`	`True` `False`
`isnumeric()`	só caracteres numéricos, inclusive frações e expoentes (o mais largo dos três)	`"½".isnumeric()` `"½".isdigit()` `"²".isdigit()`	`True` `False` `True`
`isspace()`	só espaços, `\t` e `\n`	`" \t\n".isspace()` `"".isspace()`	`True` `False`
`islower()`	todas as letras minúsculas	`"ana".islower()`	`True`
`isupper()`	todas as letras maiúsculas	`"ANA".isupper()`	`True`
`istitle()`	escrito como título (cada palavra com a primeira maiúscula)	`"Ana Sousa".istitle()`	`True`
`isascii()`	só caracteres ASCII (sem acentos nem emojis). Responde `True` para `""`.	`"Ana".isascii()` `"Conceição".isascii()`	`True` `False`
`isidentifier()`	um nome válido de variável	`"preco_total".isidentifier()` `"2nome".isidentifier()`	`True` `False`
`isprintable()`	sem caracteres "invisíveis" de controle, como `\n`. Também responde `True` para `""`.	`"Olá".isprintable()` `"Olá\n".isprintable()`	`True` `False`

Para conferir o que a pessoa digitou

Antes de int(texto), texto.isdecimal() diz se a conversão vai dar certo para números inteiros positivos. Para aceitar -5 e 7.5, o melhor caminho é tentar converter com try e except.

Formatar e codificar

Método	O que faz	Exemplo	Resultado	Aula
`format(valores…)`	Troca cada `{}` do texto pelo próximo valor. Hoje, prefira as f-strings, que fazem o mesmo de um jeito mais legível.	`"{} tem {} anos".format("Ana", 30)`	`'Ana tem 30 anos'`	f-strings
	com nomes	`"{nome} tem {idade} anos".format(nome="Ana", idade=30)`	`'Ana tem 30 anos'`
	com número de posição (repetindo)	`"{0} e {0}".format("Ana")`	`'Ana e Ana'`
	com especificação	`"R$ {:.2f}".format(4.5)`	`'R$ 4.50'`	Formatação
`format_map(dicionário)`	Como o `format`, mas pega os nomes de um dicionário.	`dados = {"nome": "Ana", "cidade": "Teresina"}` `"{nome} mora em {cidade}".format_map(dados)`	`'Ana mora em Teresina'`	Dicionários
`encode()`	Transforma o texto em bytes, em UTF-8 se você não disser outra codificação.	`"olá".encode()`	`b'ol\xc3\xa1'`	Abrindo Arquivos
`encode(codificação)`	Em outra codificação.	`"olá".encode("latin-1")`	`b'ol\xe1'`
	uma letra que não existe na codificação dá erro…	`"olá😀".encode("ascii")`	`UnicodeEncodeError: 'ascii' codec can't encode characters in position 2-3: ordinal not in range(128)`
	…a não ser com `errors="replace"`	`"olá😀".encode("ascii", errors="replace")`	`b'ol??'`
`bytes.decode()`	O caminho de volta, de bytes para texto (é um método dos `bytes`, não do `str`).	`b"ol\xc3\xa1".decode()`	`'olá'`

Operadores e funções que também servem para texto

Escrita	O que faz	Exemplo	Resultado	Aula
`a + b`	Junta dois textos.	`"Ana" + " " + "Sousa"`	`'Ana Sousa'`	Juntar e Repetir Textos
`texto * n`	Repete o texto `n` vezes.	`"-" * 10`	`'----------'`	Juntar e Repetir Textos
`len(texto)`	Quantas letras.	`len("Conceição")`	`9`	Strings
`texto[i]`, `texto[a:b]`	Uma letra; uma fatia.	`"Python"[0], "Python"[-1], "Python"[1:4]`	`('P', 'n', 'yth')`	Índices e Fatias
`f"…{valor}…"`	Monta um texto com valores dentro.	veja f-strings e Formatação		f-strings

Experimente

Missão: o nome chegou do formulário com espaços sobrando e maiúsculas misturadas. Use strip() e title() (um depois do outro, na mesma linha) para que a saída fique [Ana Beatriz De Sousa]. Os colchetes mostram se ainda sobrou algum espaço.

entrada = "  ana BEATRIZ de sousa  "
nome = entrada
print(f"[{nome}]")

entrada = "  ana BEATRIZ de sousa  "
nome = entrada.strip().title()
print(f"[{nome}]")

Repare na solução: entrada.strip() devolve um texto novo, e o .title() é chamado nesse texto novo. Encadear métodos assim é muito comum.

Livre: teste qualquer método desta página com a frase, ou troque a frase.

frase = "O rato roeu a roupa do rei de Roma"
print(frase.lower().count("r"))
print(frase.split())
print(" ".join(reversed(frase.split())))
print(frase.replace("rato", "gato"))
print(frase.startswith("O"), frase.endswith("Roma"))
print(frase.upper().center(40, "*"))

No computador da Ana, esse programa mostra:

$ python3 frase.py
5
['O', 'rato', 'roeu', 'a', 'roupa', 'do', 'rei', 'de', 'Roma']
Roma de rei do roupa a roeu rato O
O gato roeu a roupa do rei de Roma
True True
***O RATO ROEU A ROUPA DO REI DE ROMA***

Resumo

Os métodos de string nunca mudam o texto: devolvem um texto novo. Guarde-o com nome = nome.metodo().
Caixa: upper, lower, capitalize, title, swapcase; para comparar, casefold.
Procurar: find (dá -1), index (dá erro), count, startswith, endswith, e o operador in.
Limpar e trocar: strip e companhia (tiram letras das pontas), removeprefix/removesuffix (tiram um texto exato), replace, translate.
Dividir e juntar: split devolve uma lista; sep.join(lista) faz o contrário, e só com textos.
Alinhar: center, ljust, rjust, zfill. Testar: os is…, que dão False para "" (menos isascii e isprintable).