Trabalhando com strings em Python

Uma string é uma sequência de caracteres do tipo str. Ela pode conter um nome, uma frase, um código ou nenhum caractere. O Python mantém os caracteres em ordem, incluindo espaços e pontuação.

Escreva o valor entre aspas correspondentes

Aspas simples e duplas criam o mesmo tipo de valor: 'hello' e "hello" são iguais. As aspas externas marcam os limites; elas não são caracteres do valor. Escolha aspas que deixem fáceis de ler as aspas internas:

message = "It's late"
reply = 'She said "yes"'
empty = ""

Em 'It's late', o apóstrofo fecha a string cedo demais, causando um SyntaxError. Aspas duplas resolvem isso, ou você pode escrever 'It\'s late'. Use aspas retas no código.

Armazene quebras de linha e barras invertidas

Uma sequência de escape começa com uma barra invertida. O Python lê \n como uma nova linha, \t como uma tabulação e \\ como uma barra invertida. As aspas com escape, \' e \", inserem caracteres de aspas no texto.

text = "a\nb"
print(len(text))  # 3
print(text)

A última chamada imprime a e b em linhas separadas. O valor tem três caracteres: a, uma nova linha e b. As sequências de escape são processadas quando o Python lê o literal. O interpretador interativo exibe uma representação com aspas e sequências de escape onde necessário; print() exibe os próprios caracteres. Por exemplo, "\x41" se torna "A", portanto o interpretador interativo não precisa mostrar a sequência de escape original.

Aspas triplas permitem que um literal ocupe várias linhas. Cada quebra de linha interna se torna um caractere de nova linha:

notice = """Door closed
Use side entrance"""

Uma string bruta tem um r antes das aspas. Em r"C:\new", a barra invertida e n permanecem separados, resultando em seis caracteres. Em "C:\new", \n se torna uma nova linha, resultando em cinco. Literais brutos são úteis quando as barras invertidas fazem parte do texto.

Meça e combine textos

len() conta cada caractere, incluindo espaços: len("Hi there!") é 9, e len("") é 0. Mais precisamente, conta pontos de código Unicode. len("café") é 4 quando é é um ponto de código; len("👍🏽") é 2, embora o emoji pareça um único símbolo.

Use + para concatenar strings e * para repetir uma delas:

first = "Ada"
last = "Lovelace"
full = first + " " + last  # "Ada Lovelace"
rule = "-" * 10           # ten dashes

A concatenação não insere nada automaticamente. Sem " ", os nomes se tornam "AdaLovelace". Repetir "ab" zero vezes resulta na string vazia.

Decida se os dígitos são texto ou números

Os dois operandos da concatenação de strings devem ser strings. "Age: " + 30 gera TypeError; "Age: " + str(30) resulta em "Age: 30". Por outro lado, input() retorna texto: "3" + "4" resulta em "34". Para somar seus valores numéricos, converta-os primeiro: int("3") + int("4") resulta em 7.

Um índice seleciona um caractere por sua posição. O Python começa a contar em zero, portanto a posição de um caractere é uma unidade menor que sua posição em uma contagem comum da esquerda para a direita.

Represente as posições

Para word = "Python", cada caractere tem um índice não negativo e um índice negativo:

word = "Python"
print(word[0])   # P
print(word[1])   # y
print(word[-1])  # n

Os colchetes após a string selecionam o caractere. O resultado é uma string de comprimento um: o Python não tem um tipo separado para caracteres. Você pode unir caracteres selecionados, portanto word[0] + word[-1] resulta em "Pn".

Para um comprimento n, os índices válidos vão de -n até n - 1 quando n > 0. Índices não negativos contam a partir do início; índices negativos contam a partir do fim. Um índice -k seleciona o mesmo caractere que n - k; nessa palavra de seis caracteres, -2 e 4 selecionam "o".

Distinga o comprimento do último índice

len(word) é 6, mas word[6] gera IndexError: não há um sétimo caractere. O último caractere é word[len(word) - 1], ou simplesmente word[-1]. Ultrapassar qualquer extremidade causa uma falha; word[-7] também gera IndexError.

Um índice deve ser um número inteiro. word[1.0] gera TypeError mesmo que o número de ponto flutuante tenha um valor inteiro. Use // ao calcular uma posição central:

word = "Pyt"
middle = len(word) // 2  # 1
print(word[middle])      # y

O operador / produziria 1.5, que não pode ser usado como índice de uma string. Para um comprimento ímpar, len(word) // 2 seleciona o caractere central. Para um comprimento par, seleciona o caractere central à direita: "Python"[3] é "h".

Forme iniciais a partir dos primeiros caracteres

first = "Grace"
last = "Hopper"
initials = first[0] + last[0]
print(initials)  # GH

Cada nome contribui com seu caractere no índice 0. Usar first[-1] contribuiria com "e", a última letra. Esse método exige que cada nome tenha pelo menos um caractere.

Verifique entradas vazias antes de usar índices

A string vazia tem comprimento zero e nenhum índice de caractere válido. ""[0] gera IndexError. Uma verificação de comprimento pode impedir que um programa leia um caractere inexistente:

line = input("Comment: ")
if len(line) > 0 and line[0] == "#":
    print("Comment line")

O Python avalia and da esquerda para a direita. Se a verificação de comprimento for falsa, ele ignora line[0]. Inverter os dois testes tentaria primeiro o acesso pelo índice sem proteção. Quando você só precisa saber se uma linha começa com "#", line.startswith("#") também funciona com uma entrada vazia e retorna False.

Uma fatia seleciona uma sequência de caracteres e a retorna como uma string. Ela permite selecionar um prefixo, remover uma terminação ou separar campos que ocupam posições fixas.

O início é incluído; o limite de parada é excluído

Escreva text[start:stop]. Com s = "Monty Python", s[0:5] resulta em "Monty", e s[6:12] resulta em "Python". O espaço está no índice 5, portanto a segunda fatia começa em 6.

Imagine os números da fatia como espaços entre caracteres. O espaço 0 fica antes do primeiro caractere, e o espaço 5 fica depois dos cinco primeiros. Selecionar tudo entre eles fornece cinco caracteres. Para 0 <= start <= stop <= len(text), o comprimento é stop - start.

word = "Monty"
print(word[0:4])  # Mont
print(word[0:5])  # Monty

A posição de parada é a primeira posição excluída. Somar um ao último índice desejado inclui esse último caractere.

Omita um limite

Em qualquer posição de divisão k, s[:k] + s[k:] retorna s. As fatias se encontram no mesmo espaço, sem caracteres ausentes ou repetidos.

Limites de fatia além das extremidades são ajustados a elas. "cat"[1:100] é "at"; "cat"[5:] é "". Para uma fatia percorrida para a frente, um início na posição de parada ou depois dela resulta em uma string vazia, como em s[4:2]. Diferentemente de um índice de caractere individual, uma fatia fora do intervalo não gera IndexError.

Escolha um passo

A terceira posição em text[start:stop:step] define a distância entre as posições selecionadas:

letters = "abcdefgh"
print(letters[::2])   # aceg
print(letters[1::2])  # bdfh
print(letters[::-1])  # hgfedcba

Um passo negativo percorre a string de trás para a frente. Com os dois limites omitidos, [::-1] começa no último caractere e visita cada caractere em ordem inversa. Um passo zero gera ValueError. A direção deve ser compatível com os limites: a regra acima, de resultado vazio quando o início está na posição de parada ou depois dela, vale para um passo positivo.

Aplique fatias a um formato fixo

d = "2026-07-04"
year = d[:4]
month = d[5:7]
day = d[8:10]
print(month + "/" + day + "/" + year)  # 07/04/2026

As posições funcionam porque esse formato sempre usa quatro dígitos para o ano e dois para o mês e o dia. Um texto com campos de comprimentos variados precisa de uma busca ou divisão.

A inversão também permite testar um palíndromo: word == word[::-1]. "level" passa no teste, mas "Level" falha porque maiúsculas e minúsculas fazem diferença. Atribua clean = word.lower() e teste clean == clean[::-1] para ignorar essa diferença.

Use um laço quando for necessário tomar uma decisão sobre cada caractere. O laço pode contar correspondências, usar suas posições, parar na primeira correspondência ou reunir os caracteres que devem fazer parte de um resultado.

Visite os caracteres diretamente

for ch in "hi!":
    print(ch)

O corpo é executado três vezes, com ch igual a "h", "i" e "!", nessa ordem. Para a string vazia, o corpo é executado zero vezes. Um laço direto sobre caracteres dispensa índice quando você usa apenas o caractere atual.

Para uma contagem, inicialize o contador antes do laço e aumente-o somente quando o teste for satisfeito:

text = "Programming in Python"
count = 0
for ch in text.lower():
    if ch in "aeiou":
        count += 1
print(count)  # 5

Converter para minúsculas também permite encontrar vogais maiúsculas. A string do teste define as vogais contadas; ela não inclui y. Redefinir count dentro do laço faria o total das passagens anteriores se perder.

Use posições quando os caracteres vizinhos forem relevantes

range(len(text)) fornece os índices de zero até o último índice válido. Para uma tarefa que exige a posição e o caractere, enumerate(text) fornece os dois juntos:

for i, ch in enumerate("abc"):
    print(i, ch)

Isso imprime 0 a, depois 1 b, depois 2 c. As duas variáveis do laço recebem o índice e o caractere de cada par.

Para comparar vizinhos, o último índice não pode ser a posição atual, pois não há um próximo caractere:

text = "bookkeeper"
pairs = 0
for i in range(len(text) - 1):
    if text[i] == text[i + 1]:
        pairs += 1
print(pairs)  # 3

As correspondências são oo, kk e ee. Com range(len(text)), a última passagem tentaria acessar text[len(text)] e geraria IndexError.

Controle uma posição com while

i = 0
while i < len(text):
    print(text[i])
    i += 1

O teste usa estritamente <: a posição len(text) está além do fim. O incremento aproxima o laço do término; omiti-lo faz com que o mesmo caractere seja lido para sempre em um texto não vazio. Para percorrer de trás para a frente, comece em len(text) - 1, continue enquanto i >= 0 e subtraia um em cada passagem.

Busque ou reúna caracteres

Para o primeiro dígito em "Room 42B", pare assim que uma correspondência tiver sido usada:

for ch in "Room 42B":
    if ch.isdigit():
        print(ch)  # 4
        break

Sem break, os dois dígitos seriam impressos. Para um teste simples de presença, "4" in text já responde sim ou não.

Para reunir texto, comece com result = "" e adicione cada caractere desejado. Para "a b c", adicionar somente quando ch != " " constrói "abc". Atribuir ch = ch.upper() dentro de um laço altera apenas a variável do laço; isso não altera os caracteres armazenados em text.

Strings são imutáveis: seus caracteres não podem ser alterados depois que a string existe. Um programa que parece editar texto está criando outra string e escolhendo a qual delas uma variável se referirá.

Leia um caractere, mas não faça uma atribuição a ele

name = "Jane"
name[0] = "D"  # TypeError

O índice pode ler "J", mas não pode ser o destino de uma atribuição. del name[0] também gera TypeError. Para obter "Dane", combine o primeiro caractere desejado com a terminação inalterada:

name = "Jane"
name = "D" + name[1:]
print(name)  # Dane

O Python primeiro avalia o lado direito, produzindo uma nova string. Em seguida, faz name se referir a esse resultado.

Substitua ou insira em uma posição conhecida

Para um índice não negativo válido i, estas expressões usam fatias diferentes à direita:

A substituição pula o caractere antigo; a inserção o mantém. Com text = "cat", i = 1 e new = "X", a substituição resulta em "cXt", enquanto a inserção resulta em "cXat".

Converta um índice negativo em seu equivalente não negativo antes de usar esse padrão de substituição. Para o último caractere de "cat", i = len(text) - 1 é 2. Se você colocar -1 diretamente em text[i + 1:], ele se torna text[0:], que acrescenta a string antiga inteira e resulta em "caXcat".

Guarde o resultado de um método

Métodos de transformação seguem a mesma regra de imutabilidade:

msg = "hello"
msg.upper()
print(msg)       # hello
msg = msg.upper()
print(msg)       # HELLO

A primeira chamada calcula um resultado que o programa descarta. A atribuição guarda o segundo resultado. Métodos de string nunca alteram a string original, mas seus tipos de retorno são diferentes: upper() retorna uma string, find() um número inteiro e isdigit() um valor booleano.

Acompanhe dois nomes para um valor

Após a = "cat" e b = a, ambas as variáveis se referem a "cat". Executar a = a + "s" atribui a a o novo valor "cats"; b ainda se refere a "cat". Nenhum caractere na string antiga compartilhada mudou. a += "s" realiza o mesmo tipo de reatribuição para uma string.

Crie um valor alterado em um laço

word = "secret"
masked = ""
for ch in word:
    if ch in "aeiou":
        masked += "*"
    else:
        masked += ch
print(masked)  # s*cr*t
print(word)    # secret

Cada passagem acrescenta a masked um caractere escolhido. Colocar cada caractere na frente, com result = ch + result, inverte o texto: as passagens por "drawer" constroem "d", "rd", "ard", "ward", "eward" e "reward".

A concatenação repetida é conveniente para exemplos curtos. Quando os trechos já estão em uma lista, "".join(pieces) constrói um resultado diretamente e também pode colocar um separador entre eles.

Um método é uma função associada a um valor. Métodos de string realizam tarefas comuns, como alterar maiúsculas e minúsculas, remover caracteres das extremidades de uma entrada e substituir texto. Cada chamada retorna um resultado e deixa a string original inalterada.

Chame um método com a notação com ponto

Escreva value.method(arguments), como em "hello".upper(). Os parênteses fazem a chamada acontecer. name.upper sem parênteses se refere ao próprio método; não produz texto em maiúsculas. Escrever upper(name) não encontra uma função independente chamada upper. Use dir("") para listar os métodos de string e help(str.upper) para ler sobre um deles.

Escolha uma operação de maiúsculas e minúsculas

capitalize() altera o primeiro caractere e coloca o restante em minúsculas; title() inicia palavras novamente após caracteres que não são letras. Isso faz "they're".title() se tornar "They'Re", portanto pode ser necessário verificar o uso automático de maiúsculas em títulos.

Para comparações que não distinguem maiúsculas de minúsculas, casefold() trata mais casos em diferentes idiomas do que lower(). "Straße".lower() é "straße", enquanto "Straße".casefold() é "strasse". Normalize maiúsculas e minúsculas nas duas strings antes de compará-las.

Limpe as extremidades do texto

strip() remove caracteres em branco do início e do fim, incluindo espaços, tabulações e novas linhas. Ele preserva o espaçamento interno: " New York \n".strip() é "New York". lstrip() limpa apenas a extremidade esquerda; rstrip() limpa apenas a direita.

Com um argumento, a remoção retira repetidamente qualquer um desses caracteres das extremidades. Ela não remove uma palavra exata:

print("...Wow!!!".strip(".!"))          # Wow
print("report.txt".rstrip(".txt"))     # repor
print("report.txt".removesuffix(".txt"))  # report

O t final de report também pertence ao conjunto de caracteres removidos, portanto desaparece. removeprefix() e removesuffix() removem texto exato de uma extremidade; estão disponíveis no Python 3.9 e em versões posteriores.

Substitua correspondências e encadeie alterações

replace(old, new) substitui cada correspondência exata. Um terceiro argumento limita quantas correspondências são alteradas: "a-b-c".replace("-", "", 1) resulta em "ab-c". Uma substituição vazia exclui as correspondências. Maiúsculas e minúsculas fazem diferença, portanto "Cat cat".replace("cat", "dog") resulta em "Cat dog".

answer = "  YES \n"
answer = answer.strip().lower()
print(answer == "yes")  # True

As chamadas são executadas da esquerda para a direita: strip() retorna "YES", depois lower() retorna "yes". Um encadeamento funciona quando o próximo método é adequado ao tipo do resultado anterior. Um resultado de busca é um número inteiro, portanto não aceita métodos de limpeza de string.

Para preenchimento, "7".zfill(3) resulta em "007", "Total".ljust(8) adiciona três espaços à direita, e "Hi".center(8, "*") resulta em "***Hi***". rjust() preenche à esquerda. Essas larguras são mínimas; textos mais longos são mantidos por inteiro.

Uma busca pode responder a três perguntas diferentes: se um texto ocorre, onde começa e quantas vezes ocorre. Escolha o resultado adequado à decisão que seu programa precisa tomar.

Escolha um resultado de busca

Uma subcadeia de caracteres é uma sequência consecutiva de caracteres. "py" in "happy" é True, mas "hpy" in "happy" é False. A correspondência distingue maiúsculas de minúsculas: "Py" in "python" é False. not in inverte o teste de presença. A string vazia ocorre em toda string.

Encontre a ocorrência desejada

text = "banana"
print(text.find("an"))     # 1
print(text.find("an", 2))  # 3
print(text.rfind("an"))    # 3

A posição inicial opcional ignora candidatos anteriores. O índice retornado continua contando a partir do início da string inteira. index() retorna a mesma posição quando há uma correspondência, mas seu erro quando não há correspondência o torna útil quando a ausência indica um problema inesperado.

Verifique uma posição antes de extrair uma fatia

email = "maria.lopez@example.org"
at = email.find("@")
if at != -1:
    user = email[:at]
    domain = email[at + 1:]
    print(user)    # maria.lopez
    print(domain)  # example.org

A busca retorna 11. A primeira fatia para antes de @; a segunda começa um caractere depois dele. Se o marcador estivesse ausente, at seria -1. Usá-lo como limite de fatia selecionaria texto perto do fim sem avisar, portanto trate a ausência do marcador antes de extrair as partes.

Não use if text.find("x"): como teste de presença. Uma correspondência no índice 0 é considerada falsa em uma condição, enquanto o valor -1, que indica ausência, é considerado verdadeiro. Use if "x" in text: ou compare explicitamente a posição com -1.

Busque a partir de um marcador conhecido

Para line = "Order #4521 shipped", o número vem depois de # e termina no próximo espaço:

start = line.find("#") + 1
end = line.find(" ", start)
number = line[start:end]
print(number)  # 4521

Aqui os dois marcadores existem. Começar a segunda busca em start ignora o espaço anterior, depois de Order. Se os marcadores puderem estar ausentes, verifique cada resultado da busca antes de somar um ou extrair uma fatia; somar um a -1 ocultaria a falha da busca ao transformá-lo em 0.

Conte correspondências completas

"banana".count("a") é 3, e "banana".count("ana") é 1. As duas correspondências possíveis de ana se sobrepõem, portanto count() não conta ambas. Da mesma forma, "aaaa".count("aa") é 2.

Para ignorar maiúsculas e minúsculas, busque em uma versão convertida, como em "python" in sentence.lower(). A busca ainda procura correspondências exatas nessa versão. Contagens e testes de presença podem usar a string convertida diretamente; um índice pertence à string específica em que foi feita a busca.

Testes de string retornam valores booleanos que podem orientar uma condição. Eles ajudam você a aceitar entradas que atendem a uma regra e a comparar textos de forma consistente.

Teste as extremidades ou os caracteres

startswith() e endswith() testam textos exatos nas extremidades. Uma tupla permite que um teste aceite várias terminações: name.endswith((".jpg", ".png")). "photo.PNG", com a extensão em maiúsculas, falha nesse teste, a menos que você a converta para minúsculas primeiro.

Todos os cinco retornam False para "". As letras não precisam ser inglesas: "café".isalpha() é True. O espaço em "hello world" faz isalpha() retornar falso.

isupper() e islower() examinam caracteres que têm maiúsculas e minúsculas e exigem pelo menos um deles. "ABC1".isupper() é True; o dígito não interfere nas letras maiúsculas. "123" não tem caracteres com maiúsculas e minúsculas, portanto ambos os testes são falsos.

Valide antes da conversão

Um teste de dígitos não descreve todos os números que o Python consegue ler. "-5".isdigit(), "3.5".isdigit() e " 42".isdigit() são falsos porque um sinal, um ponto ou um espaço não é um dígito. Além disso, "²".isdigit() é verdadeiro, embora int("²") falhe. isdecimal() rejeita esse sobrescrito e é adequado para uma entrada de número inteiro não negativo escrita somente com dígitos.

text = input("Tickets: ").strip()
if text.isdecimal() and int(text) > 0:
    print("Accepted")
else:
    print("Enter a positive whole number")

O teste da string é executado primeiro. Quando é falso, and ignora a conversão, protegendo entradas vazias ou não numéricas. " 12 " se torna "12" e passa no teste; "0" é convertido com segurança, mas falha no teste de valor positivo. Essa regra rejeita deliberadamente entradas com sinal ou ponto decimal.

Uma regra para nome de usuário pode combinar verificações de comprimento e caracteres: 3 <= len(name) <= 12 and name.isalnum(). "ada99" passa, "ada 99" falha no teste de caracteres e "ad" falha no teste de comprimento.

Compare textos limpos

A igualdade exige os mesmos caracteres na mesma ordem. "Yes" == "yes" e "yes " == "yes" são falsos. Para respostas em que maiúsculas, minúsculas e caracteres em branco nas extremidades devem ser ignorados, compare typed.strip().casefold() com expected.strip().casefold().

A ordenação funciona caractere por caractere. O primeiro ponto de código Unicode diferente decide o resultado. ord("A") é 65, ord("Z") é 90 e ord("a") é 97; chr(97) resulta em "a". Assim, "Zebra" < "apple" é verdadeiro. Quando uma string é prefixo da outra, a mais curta vem primeiro: "app" < "apple".

Strings de dígitos também usam a ordem dos caracteres: "10" < "9" é verdadeiro porque "1" vem antes de "9". Converta para números ao comparar quantidades. Letras acentuadas também exigem atenção: ord("é") é 233, portanto "école" > "zoo" é verdadeiro. Essa ordem embutida segue os pontos de código, não a ordem de um dicionário do idioma.

split() transforma uma string em uma lista de strings. Uma lista é uma coleção ordenada escrita entre colchetes. Você pode ler um item pelo índice, percorrer os itens ou contá-los com len().

Escolha caracteres em branco ou um separador exato

Sem argumento, split() trata uma sequência de caracteres em branco como um único limite e ignora esses caracteres nas duas extremidades:

words = "  the quick  brown fox ".split()
print(words)       # ['the', 'quick', 'brown', 'fox']
print(len(words))  # 4
print(words[0])    # the

Com um separador explícito, cada ocorrência exata produz uma divisão. Separadores consecutivos preservam um campo vazio:

fields = "red,green,,blue".split(",")
# ["red", "green", "", "blue"]

O terceiro item vazio pode representar um valor que foi deixado em branco. Ele ainda conta como um item da lista.

Um separador pode conter vários caracteres, mas todos devem corresponder exatamente. Se nenhum separador ocorrer, o resultado contém a string original inteira como um item. Portanto, dividir usando vírgula e espaço é diferente de dividir usando uma vírgula.

Limite as divisões do texto

O segundo argumento, maxsplit, limita o número de divisões, não o número de itens resultantes:

print("key=value=more".split("=", 1))
# ["key", "value=more"]
print("archive.tar.gz".rsplit(".", 1))
# ["archive.tar", "gz"]

split() começa pela esquerda; rsplit() começa pela direita. Uma divisão pela direita separa a última extensão do arquivo sem dividir nos pontos anteriores.

Leia campos e converta quantidades

line = "Lovelace,Ada,1815"
parts = line.split(",")
if len(parts) == 3:
    last = parts[0]
    first = parts[1]
    year = int(parts[2])
    print(f"{first} {last} was born in {year}.")

A saída é "Ada Lovelace was born in 1815.". A verificação de comprimento impede que um item ausente cause IndexError. Ela não verifica se o ano é numérico; isso exige uma regra de entrada separada quando os dados podem ser inválidos.

Cada parte da divisão começa como uma string. Para somar "3 14 15", inicialize total = 0, percorra line.split() e adicione int(part). O resultado é 32; concatenar os trechos sem convertê-los uniria os dígitos.

Um separador explícito mantém os espaços ao redor. "a, b".split(",") resulta em ["a", " b"]. Chame strip() em cada parte se esses espaços forem indesejados.

Reconheça dois resultados relacionados

splitlines() divide nas quebras de linha: "line one\nline two".splitlines() resulta em duas strings. partition("=") sempre retorna uma tupla de três partes: o texto antes do primeiro separador, o separador e o texto depois dele. "user=ada".partition("=") resulta em ("user", "=", "ada"); com "user", resulta em ("user", "", "").

join() cria uma string a partir de uma sequência de strings. A string antes do ponto fornece o separador, que aparece entre itens adjacentes.

Coloque o separador primeiro

colors = ["red", "green", "blue"]
text = ", ".join(colors)
print(text)  # red, green, blue

Leia isso como “use vírgula e espaço para unir as cores”. Não há separador antes do primeiro item nem depois do último. Você pode alterar o formato da saída mudando apenas o separador:

join() pertence à string separadora. Escrever ["a", "b"].join(",") gera AttributeError porque a lista não tem um método join. Uma única chamada também se adapta ao número de trechos; você não precisa escrever uma nova sequência de operações + para cada comprimento de lista.

Converta primeiro os trechos que não são strings

Todos os trechos já devem ser strings. ", ".join([1, 2, 3]) gera TypeError. map(str, items) aplica str() a cada item, portanto isto funciona:

items = [1, 2, 3]
text = " ".join(map(str, items))
print(text)  # 1 2 3

O str passado a map() é a função de conversão. join() recebe os trechos convertidos e retorna uma string.

Uma string é uma sequência de strings de um caractere, portanto " ".join("ABC") resulta em "A B C". Isso pode ser útil, mas passar uma palavra quando você pretendia passar uma lista de palavras coloca separadores entre seus caracteres.

Reorganize espaços e separadores

text = "too   many    spaces"
cleaned = " ".join(text.split())
print(cleaned)  # too many spaces

Primeiro, a divisão por caracteres em branco produz as três palavras. Uni-las com um espaço cria uma separação consistente e não deixa espaços nas extremidades. O espaçamento original se perde na etapa de divisão.

Com um separador explícito, os campos vazios preservam informações suficientes para reconstruir o texto exato. Se s = "a,,b,", então s.split(",") resulta em ["a", "", "b", ""], e ",".join(...) resulta novamente em "a,,b,". O separador deve ser o mesmo para essa reconstrução exata.

Mudar o separador altera o formato: "-".join("2026/07/04".split("/")) resulta em "2026-07-04". Aqui replace("/", "-") também é uma solução direta.

Reúna um resultado curto a partir de palavras

Para formar uma sigla, divida "portable network graphics", comece com acronym = "" e adicione word[0].upper() para cada palavra. A divisão por caracteres em branco fornece palavras não vazias, portanto seus primeiros caracteres existem. Isso constrói "PNG". Se as letras já estiverem em uma lista, ".".join(["P", "N", "G"]) constrói "P.N.G" sem ponto final.

Uma f-string é um literal de string com f ou F antes das aspas de abertura. Dentro dela, as chaves contêm expressões cujos valores são inseridos no texto.

Insira variáveis e expressões

name = "Ada"
age = 36
message = f"{name} is {age} years old."
print(message)  # Ada is 36 years old.

Números se tornam texto automaticamente dentro de um campo. A mesma mensagem poderia usar concatenação e str(age), mas a f-string mantém o formato final visível em um só lugar.

As chaves podem conter operações aritméticas, chamadas de métodos ou chamadas de funções:

price = 4.5
qty = 3
print(f"Cost: {price * qty}")  # Cost: 13.5
print(f"Name: {name.upper()}")  # Name: ADA
word = "Python"
print(f"{len(word)} letters")  # 6 letters

O Python avalia cada expressão quando a linha é executada. Uma string armazenada não permanece ligada às variáveis usadas para criá-la. Se qty mudar depois que message tiver sido criada, essa string mantém seus caracteres existentes.

Distinga texto comum de campos

Sem o prefixo, "Hello {name}" é texto comum e mantém suas chaves. A falta do f é um motivo comum para um programa imprimir o nome da variável em vez de seu valor. Com o prefixo, um nome ao qual ainda não foi atribuído um valor gera NameError quando a expressão é executada.

Para exibir uma chave literal, duplique-a:

x = 5
print(f"{{x}} = {x}")  # {x} = 5

As chaves duplicadas fornecem o texto literal {x}. O par simples em torno do x final fornece seu valor.

Mantenha legíveis as expressões com aspas

Use o outro tipo de aspas dentro de um campo:

print(f"Shout: {'hi'.upper()}")  # Shout: HI

Esse estilo funciona em todas as versões do Python com f-strings, introduzidas na versão 3.6. O Python 3.12 e versões posteriores também permitem reutilizar o tipo de aspas externas dentro do campo. Sequências de escape continuam funcionando em f-strings: f"Name: {name}\nAge: {age}" imprime em duas linhas.

Para uma exibição rápida de depuração, o Python 3.8 e versões posteriores aceitam = após uma expressão. Com x = 5, f"{x=}" resulta em "x=5"; com total = 12, f"{total = }" resulta em "total = 12". Os espaços digitados ao redor da expressão e do sinal de igual aparecem na exibição.

Leia estilos de formatação mais antigos

Código Python existente pode criar o mesmo texto de outras formas:

str.format() preenche campos entre chaves com seus argumentos. Campos numerados podem reutilizar um argumento: "{0} {1} {0}".format("a", "b") resulta em "a b a". Na formatação com porcentagem, %s insere texto e %d um número inteiro. Reconhecer esses campos ajuda a ler um programa mesmo que ele tenha sido escrito antes de as f-strings se tornarem comuns.

Um especificador de formato controla como um valor é exibido. Coloque dois-pontos depois da expressão e, em seguida, as instruções: f"{value:spec}". A formatação retorna texto e deixa o valor numérico original inalterado.

Defina casas decimais e entenda o arredondamento

.Nf exibe exatamente N dígitos após o ponto decimal. f"{3.14159:.2f}" resulta em "3.14", f"{2/3:.3f}" resulta em "0.667", e f"{5:.2f}" resulta em "5.00". .0f não exibe ponto decimal: f"{7.6:.0f}" resulta em "8".

O arredondamento usa o valor realmente armazenado. A maioria das frações decimais é armazenada como aproximações binárias muito próximas. O número de ponto flutuante 2.675 é ligeiramente menor que esse decimal exato, portanto f"{2.675:.2f}" resulta em "2.67". Valores exatamente na metade são arredondados para o dígito final par: 0.125 é exibido como "0.12", enquanto 0.375 é exibido como "0.38" com duas casas decimais. f"{2.5:.0f}" resulta em "2". Programas que precisam de cálculos monetários exatos frequentemente armazenam centavos como números inteiros.

Adicione agrupamento e porcentagens

Uma vírgula agrupa milhares; o ponto introduz a precisão decimal. Para um valor em dólares, mantenha o símbolo de dólar fora do campo: com amount = 1250.5, f"${amount:,.2f}" resulta em "$1,250.50".

O tipo % multiplica por 100 e adiciona %. Use uma fração como 0.256 para exibir 25.6%. Se você fornecer 25.6, a porcentagem exibida será multiplicada novamente. Sem uma precisão explícita, % mostra seis casas decimais.

Formate números inteiros e partes de datas

d é usado para números inteiros. f"{42:d}" funciona, mas f"{3.0:d}" gera ValueError porque um número de ponto flutuante não é um inteiro. Um zero antes da largura adiciona preenchimento com zeros; um sinal de mais solicita um sinal visível:

print(f"{7:03d}")   # 007
print(f"{5:+d}")    # +5
print(f"{-5:+d}")   # -5

Para o mês 7, o dia 4 e o ano 2026, f"{month:02d}/{day:02d}/{year}" constrói "07/04/2026". Para a hora 9 e o minuto 5, f"{hour}:{minute:02d}" constrói "9:05". O preenchimento com zero impede que um minuto de um dígito apareça como "9:5".

Combine instruções em ordem

A ordem é preenchimento, alinhamento, sinal, zero, largura, agrupamento, precisão e tipo. Você pode omitir partes desnecessárias. f"{12345.678:>12,.2f}" usa alinhamento à direita, largura 12, agrupamento com vírgula e duas casas decimais, resultando em " 12,345.68".

A precisão pode vir de outra variável: com places = 3, f"{3.14159:.{places}f}" resulta em "3.142". Os mesmos especificadores funcionam em format(value, spec) e em campos de str.format(). Mantenha o número original para cálculos; round(value, 2) retorna um número arredondado quando é isso que o cálculo exige.

Uma largura de campo reserva um número mínimo de posições de caracteres para um valor. Combinar larguras torna pequenas tabelas e recibos legíveis em um terminal.

Escolha largura e alinhamento

Por padrão, strings são alinhadas à esquerda e números à direita. f"{'cat':6}" resulta em "cat ", enquanto f"{42:6}" resulta em " 42". Use um caractere de alinhamento para escolher explicitamente:

Quando a centralização deixa um número ímpar de espaços, o alinhamento da f-string coloca o espaço extra à direita: f"{'hi':^7}" resulta em " hi ".

A largura é um mínimo. f"{'elephant':4}" ainda resulta em "elephant"; ela não corta a palavra. Uma entrada longa pode, portanto, deslocar as colunas seguintes.

Adicione um caractere de preenchimento ou limite o texto

Um caractere de preenchimento fica imediatamente antes do alinhamento. f"{'hi':*^10}" resulta em "****hi****", e f"{7:0>3}" resulta em "007". O preenchimento precisa de um caractere de alinhamento. f"{'':-^20}" preenche um campo vazio com vinte traços.

A precisão de string limita o número de caracteres exibidos:

place = "Washington"
print(f"{place:.4}")      # Wash
print(f"|{place:10.4}|")  # |Wash      |

A precisão primeiro limita o texto exibido a quatro caracteres; depois, a largura o preenche até dez. Use largura e precisão correspondentes quando o texto precisar permanecer dentro de uma coluna fixa. O place original ainda é "Washington".

Crie uma linha de recibo

item = "Apples"
qty = 3
price = 4.50
row = f"{item:<8}{qty:>4}{qty * price:>9.2f}"
print(row)

O resultado é "Apples 3 13.50". O campo do item tem seis letras e dois espaços. O campo da quantidade adiciona três espaços antes de 3. O campo do custo adiciona quatro espaços antes de 13.50, que tem cinco caracteres. Juntos, os campos ocupam 21 caracteres.

Reutilize essas larguras para pão (1 a 2,25) e café (2 a 11,00). Suas linhas são "Bread 1 2.25" e "Coffee 2 22.00". Uma linha de total pode combinar os dois primeiros campos:

print(f"{'Total':<12}{37.75:>9.2f}")
# "Total           37.75"

O campo de custo começa na mesma posição e tem a mesma precisão decimal, portanto os valores ficam alinhados.

Adapte o formato à exibição

Escolha larguras que deixem espaço para as entradas mais longas e para o espaçamento, ou encurte o texto deliberadamente. Uma variável pode fornecer uma largura: com w = 10, f"{name:<{w}}" preenche name até dez caracteres.

Colunas baseadas em caracteres precisam de uma fonte monoespaçada, como a usada em um terminal. Para preenchimento simples fora de uma f-string, ljust() e rjust() se comportam como < e >. center() e ^ centralizam o texto, mas podem dividir um preenchimento ímpar de modo diferente: "hi".center(7) resulta em " hi ", enquanto f"{'hi':^7}" resulta em " hi ".