Strings

Texto aparece em quase todo programa que você escreve. Nomes, mensagens, pontuações, rótulos. Em Python, qualquer trecho de texto é chamado de string: qualquer valor que você coloca entre aspas. Aspas simples ou duplas, ambas funcionam da mesma forma.

Strings são o tipo de texto principal do Python. Elas carregam de tudo, de um nome de usuário a um caminho de URL a uma saída formatada. Aspas simples e duplas produzem resultados idênticos; a escolha é apenas estilística.

str está presente em todos os pontos de contato do sistema: entrada e saída no terminal, conteúdo de arquivos, respostas de rede, dados serializados. É o tipo Unicode imutável (não pode ser alterado depois de criado) do Python para sequências de texto. Os dois estilos de aspas produzem o mesmo objeto, então a escolha entre eles é puramente estilística.

greeting = "Hello, world"
username = 'alice'

A única vez em que o tipo de aspas importa é quando seu texto contém marcas de aspas. Use o estilo oposto para não precisar escapar essas marcas:

A convenção da comunidade é usar aspas duplas. O motivo prático para alternar o estilo é evitar escapar caracteres quando o conteúdo contém aquele mesmo caractere:

A convenção é usar aspas duplas, e formatadores como Black e Ruff aplicam isso automaticamente. O único motivo para alternar manualmente é evitar uma barra invertida de escape quando o conteúdo contém o delimitador:

note = "It's a great day"      # apóstrofo dentro do texto, use aspas duplas
message = 'She said "hello"'   # aspas duplas dentro do texto, use aspas simples
escaped = "She said \"hello\""  # ou escape com uma barra invertida

Imutabilidade

Strings são imutáveis: depois que você cria uma, não é possível alterá-la. Pense em uma string como algo permanentemente fixo desde o momento em que é criada. Qualquer operação que pareça estar modificando uma string, na verdade, está produzindo uma string totalmente nova. A original permanece exatamente como estava.

Strings são imutáveis: nenhum método modifica uma string no lugar. Toda operação que transforma texto retorna uma nova string e deixa a original intocada. A consequência prática é que uma chamada de método que você não atribui a nada não tem efeito algum.

Objetos str são imutáveis, o que significa que seu conteúdo é fixo desde a criação e nada pode escrever sobre eles. Isso dá às strings duas propriedades que você realmente usa: elas são hasheáveis (um valor cujo conteúdo nunca muda pode ser catalogado por esse conteúdo, o que é o que permite que uma string funcione como chave de dicionário ou membro de um conjunto), e é seguro passá-las entre diferentes nomes sem que ninguém precise copiá-las, já que nenhuma parte do código pode alterar uma string compartilhada sem você perceber.

name = "alice"
name = name.upper()   # "ALICE" é uma nova string; "alice" continua inalterada

A consequência direta: você não pode alterar um caractere em uma posição específica. Python levantará um erro se você tentar.

name = "alice"
name[0] = "A"   # TypeError: 'str' object does not support item assignment

Para obter uma string modificada, construa uma nova usando slicing ou um método. Ambos são abordados a seguir.

Tentar atribuir um caractere mostra essa restrição diretamente:

name = "alice"
name[0] = "A"   # TypeError: 'str' object does not support item assignment

Quando você precisa de uma versão modificada, as ferramentas padrão são slicing combinado com concatenação para edições posicionais, e replace() para substituições. Ambos produzem uma nova string e deixam a original intocada.

Atribuir a uma posição (name[0] = "A") levanta TypeError sempre, sem exceção. Para uma edição posicional, construa uma nova string fazendo slicing em torno da parte que você quer mudar: name[:1].upper() + name[1:] transforma o primeiro caractere em maiúsculo. Para uma substituição em qualquer ponto da string, use replace().

JunoImutabilidade Uma string nunca muda depois de existir. Qualquer coisa que pareça editá-la na verdade te devolve uma string nova, então atribua o resultado ou ele se perde. O que me pegou no começo: name[0] = "A" não funciona, isso levanta um TypeError.

JunoImutabilidade Nenhum método de string edita no lugar, todos retornam uma string nova e deixam a original intacta. Então name.upper() sozinho não faz nada útil, você tem que atribuir o resultado. E name[0] = "A" levanta TypeError, não existe troca de caractere no lugar.

JunoImutabilidade A imutabilidade é o que torna as strings hasheáveis, permitindo que funcionem como chaves de dict, e seguras para compartilhar sem copiar. Consequência prática: atribua o resultado de todo método transformador, já que nenhum deles altera o original. Para uma edição posicional, faça slicing em torno do ponto e reconstrua, já que atribuição por item sempre levanta TypeError.

Indexação e slicing

Cada caractere em uma string tem uma posição numerada, começando em zero. Você pode ler caracteres individuais colocando esse número de posição entre colchetes. Números negativos contam de trás para frente, a partir do final.

Strings são sequências com indexação baseada em zero. Índices negativos contam a partir do final. O slicing extrai qualquer intervalo contíguo em uma única expressão, e nunca levanta um erro para valores fora do intervalo.

Uma string se comporta como uma sequência ordenada que você pode indexar e fazer slicing. Ler uma única posição (s[i]) levanta IndexError se o índice apontar para além do final. O slicing (s[start:stop:step]) se comporta de forma diferente: limites fora do intervalo são silenciosamente ajustados ao que existe, então um slice nunca pode levantar IndexError. Essa diferença é a que vale a pena guardar: o acesso por índice é rígido, o slicing é tolerante.

word = "Python"
#       012345

print(word[0])    # "P"
print(word[2])    # "t"
print(word[5])    # "n"
print(word[-1])   # "n"  (último caractere)
print(word[-2])   # "o"  (penúltimo caractere)

-1 é sempre o último caractere, -2 o penúltimo, e assim por diante. Eles são úteis quando você quer o final de uma string sem saber seu tamanho exato.

Índices negativos dão a volta: -1 é len(s) - 1, -2 é len(s) - 2. Mais útil para acessos ancorados no final quando você não quer calcular o tamanho manualmente. Um índice negativo que sai do intervalo ainda levanta IndexError, assim como um positivo.

Um índice negativo é convertido para len(s) + i antes da verificação de limites, então -1 cai no último caractere e -2 no anterior a ele. Sair do intervalo levanta IndexError de qualquer forma, positivo ou negativo: só o slicing perdoa isso, a indexação simples não.

Slicing extrai um trecho. [start:stop] inclui start e exclui stop:

word = "Python"

print(word[0:2])   # "Py"     (posições 0 e 1)
print(word[2:])    # "thon"   (posição 2 até o final)
print(word[:3])    # "Pyt"    (do início até a posição 2)
print(word[:])     # "Python" (uma cópia da string toda)
print(word[::2])   # "Pto"    (a cada dois caracteres)
print(word[::-1])  # "nohtyP" (invertida)

Três padrões que você usará mais: word[:n] para os primeiros n caracteres, word[n:] para tudo a partir da posição n, word[-n:] para os últimos n caracteres. word[::-1] inverte uma string. Parece estranho da primeira vez, mas é uma forma idiomática de escrever em Python e você verá isso com frequência.

Diferente da indexação direta, o slicing nunca levanta IndexError. Python ajusta índices fora do intervalo silenciosamente, então word[100:] em uma string curta retorna "" em vez de travar. O argumento de passo controla o intervalo entre elementos: word[::2] pega cada segundo caractere, word[::-1] percorre em sentido inverso.

Em s[start:stop:step], qualquer parte que você omitir assume por padrão "o final natural para a direção em que você está indo", não um 0 e um len() fixos. Com um passo positivo isso significa do início ao fim; com um passo negativo isso se inverte, então start passa a ser o último caractere e stop extrapola o começo. É por isso que s[::-1] percorre a string toda de trás para frente sem você escrever nenhum limite, e pelo mesmo motivo s[::-2] te dá cada segundo caractere de trás para frente.

JunoIndexação e slicing As posições começam em zero, então word[0] é o primeiro caractere e word[-1] é o último. Um slice pega um intervalo: word[start:stop] mantém start e para logo antes de stop. word[::-1] inverte a string, o que parece estranho na primeira vez e depois você usa para sempre.

JunoIndexação e slicing Indexe a partir de zero, ou a partir do final com números negativos, onde word[-1] é o último caractere. Slices pegam um intervalo que inclui start e exclui stop, e um terceiro valor, step, define o intervalo entre elementos, então word[::-1] inverte. O detalhe que vale lembrar: indexar além do final levanta IndexError, mas o slicing além do final retorna o que existe em vez de falhar.

JunoIndexação e slicing A indexação simples é rígida e levanta IndexError fora do intervalo, o slicing é tolerante e ajusta ao que existe, então word[100:] retorna "" em vez de levantar erro. Se você deixar uma parte do slice de fora, ela assume por padrão o final natural para a direção do passo, e é exatamente por isso que word[::-1] inverte sem nenhum limite escrito. Recorra a um slice quando preferir não travar diante de uma entrada vazia ou curta.

Métodos essenciais de string

Strings vêm com um conjunto de métodos embutidos: operações que você chama diretamente em qualquer valor de string. Você escreve a string (ou a variável que a guarda), depois um ponto, depois o nome do método. Cada método retorna uma nova string. A original nunca é alterada.

Métodos de string são funções associadas ao tipo str. Como strings são imutáveis, todo método retorna uma nova string em vez de modificar a original. Uma chamada de método que você não atribui ou passa para algum lugar não tem efeito duradouro.

Todo método transformador retorna um novo str e deixa o original intacto, o que decorre diretamente da imutabilidade. Eles também trabalham em pontos de código (os próprios caracteres, não os bytes brutos usados para armazená-los), então os métodos se comportam corretamente com texto acentuado e não latino sem que você precise fazer nada especial. O trade-off a ter em mente: cada método aloca uma nova string, então encadear muitos deles sobre um texto grande significa muitas alocações.

Maiúsculas e minúsculas

text = "Hello, World"

text.lower()       # "hello, world"
text.upper()       # "HELLO, WORLD"
text.title()       # "Hello, World"  (cada palavra com inicial maiúscula)
text.capitalize()  # "Hello, world"  (apenas a primeira palavra)

lower() e upper() são os dois que você usará mais. lower() é particularmente útil ao comparar textos: "Alice" e "alice" se tornam a mesma coisa depois que você chama .lower() nos dois lados.

lower() é a etapa de normalização padrão antes de comparar ou armazenar. title() coloca em maiúscula a primeira letra de cada palavra usando uma regra aproximada que falha em contrações: "it's" se torna "It'S". Trate-a como formatação apenas para exibição.

lower() aplica a conversão completa de caixa do Unicode. Para comparação sem diferenciar maiúsculas e minúsculas, casefold() é mais correto: ele aplica transformações adicionais (por exemplo, o ß alemão se torna ss) que lower() ignora. title() coloca em maiúscula depois de qualquer caractere não alfanumérico, o que trata mal contrações e nomes com hífen. Para uma capitalização de título correta, implemente a lógica manualmente.

Espaços em branco

text = "  hello  "

text.strip()    # "hello"    (dos dois lados)
text.lstrip()   # "hello  "  (apenas à esquerda)
text.rstrip()   # "  hello"  (apenas à direita)

strip() remove espaços das duas extremidades de uma string. Você o usará quase sempre que lidar com entrada de usuário ou texto de um arquivo, porque espaços perdidos causam falhas silenciosas: "alice" != "alice ".

strip() remove todos os espaços em branco no início e no final: espaços, tabulações e quebras de linha. As variantes direcionais permitem limpar apenas um lado, útil para remover uma quebra de linha final sem tocar na indentação. Os três aceitam um argumento opcional de caracteres para remover caracteres específicos em vez disso.

Sem argumento, strip() remove todo tipo de espaço em branco das duas extremidades, incluindo espaços em branco não ASCII, não apenas o espaço comum. Com um argumento de caracteres, ele remove qualquer um desses caracteres das extremidades, e essa é a pegadinha: o argumento é um conjunto de caracteres a remover, não um prefixo a corresponder. "xxhelloxx".strip("x") retorna "hello", mas "https://".strip("https") não remove o prefixo "https", ele remove cada h, t, p e s das duas extremidades e retorna "://". Para remover um prefixo ou sufixo conhecido, use removeprefix() e removesuffix() em vez disso.

Buscando texto

text = "Hello, world"

text.find("world")         # 7
text.find("Python")        # -1  (não encontrado)
text.count("l")            # 3
text.startswith("Hello")   # True
text.endswith("world")     # True

find() retorna a posição onde um trecho de texto começa dentro da sua string. Se ele não estiver lá, retorna -1. Use startswith() e endswith() quando você só se importa se a string começa ou termina com algo específico.

find() retorna o índice inicial da primeira correspondência, ou -1. Essa convenção do -1 permite usar o resultado diretamente em slicing ou aritmética sem precisar verificar antes. startswith() e endswith() aceitam cada um uma tupla de strings, então você pode testar vários prefixos ou sufixos em uma única chamada.

find() percorre da esquerda para a direita e retorna -1 quando não há correspondência. index() faz a mesma busca, mas levanta ValueError em vez de retornar -1: escolha index() quando uma correspondência ausente significa que seu código tem um bug e você quer que ele pare ali, find() quando a ausência é uma entrada normal que você vai verificar. Para uma pergunta puramente de "isso começa ou termina com isto", startswith() e endswith() expressam exatamente o que você quer dizer e param na primeira divergência, então prefira-os a um find() ou verificação com in para essa tarefa.

Substituindo

text = "Hello, world"

text.replace("world", "Python")   # "Hello, Python"
text.replace("l", "L")            # "HeLLo, worLd"  (todas as ocorrências)
text.replace("l", "L", 1)         # "HeLlo, world"  (apenas a primeira)

replace() troca toda ocorrência de um trecho de texto por outro e devolve uma nova string. A original não é alterada. Passe um terceiro argumento se você quiser substituir apenas a primeira ocorrência.

replace() substitui todas as ocorrências sem sobreposição, por padrão. O argumento de contagem limita quantas serão substituídas. Como ele retorna uma nova string, as chamadas podem ser encadeadas: text.replace("a", "A").replace("e", "E") aplica as duas substituições em sequência.

replace() corresponde a uma substring literal, não a um padrão, então ele não faz regex e trata cada caractere do argumento como ele mesmo. Ele substitui correspondências sem sobreposição, da esquerda para a direita, o que pode te surpreender: "aaa".replace("aa", "b") resulta em "ba", não "bb", porque o segundo aa sobrepõe a primeira correspondência. O argumento de contagem limita quantas ele substitui, e como toda chamada retorna uma nova string, você pode encadeá-las: text.replace(",", "").replace(" ", "_").

Dividindo e juntando

split() corta uma string em pedaços em um separador e retorna esses pedaços como uma lista. Você diz a ele onde cortar:

split() divide em um separador e retorna os segmentos como uma lista. Chamado sem argumento, ele divide em qualquer sequência de espaços em branco e descarta strings vazias resultantes de múltiplos espaços consecutivos:

split(sep) percorre da esquerda para a direita, dividindo em cada ocorrência sem sobreposição de sep. Sem argumento, ele usa um algoritmo diferente: divide em qualquer sequência de espaços em branco e remove os espaços em branco do início e do final do resultado. rsplit(sep, n) divide a partir da direita, útil para isolar o último segmento de um caminho separado por pontos ou de um identificador com namespace.

csv_row = "Alice,28,Brasília"
parts = csv_row.split(",")     # ["Alice", "28", "Brasília"]

"  hello   world  ".split()   # ["hello", "world"]

split() retorna uma lista, uma sequência ordenada de valores. Elas têm seu próprio capítulo, Listas; por ora, trate-as como a sequência de partes que split() produz e join() consome.

join() faz o inverso: ele combina uma lista de strings em uma só. A string antes de .join() é colocada entre cada item:

words = ["Hello", "world"]

" ".join(words)    # "Hello world"
", ".join(words)   # "Hello, world"
"".join(words)     # "Helloworld"

O padrão a lembrar: separador.join(lista_de_strings). O separador fica à esquerda, a lista à direita. " ".join(words) coloca um espaço entre cada palavra. "".join(words) cola tudo sem nada entre os elementos.

join() é a ferramenta certa sempre que você está montando uma única string a partir de várias partes. Ele realiza uma única alocação em vez de criar uma nova string em cada etapa. Para duas ou três strings, + funciona perfeitamente bem. Uma vez que você tem uma lista de tamanho relevante, recorra a join().

join() percorre as partes uma vez, calcula o tamanho total, aloca o resultado uma única vez e escreve tudo de uma vez. Construir a mesma string com + repetido em um loop é o cenário caro: como strings não podem mudar, cada + aloca uma string nova e copia tudo o que já foi montado até ali, então o custo cresce com o quadrado do número de partes. Em algumas poucas strings ninguém percebe, mas em alguns milhares isso transforma uma operação rápida em algo lento. A regra que evita isso: junte as partes em uma lista e use join() uma única vez no final, nunca += uma string dentro de um loop.

JunoMétodos essenciais de string Cada um desses métodos retorna uma nova string, então atribua o resultado ou ele se perde. Os poucos que você vai usar diariamente: .lower() e .upper() para caixa, .strip() para remover espaços perdidos, .find() para localizar texto (retorna -1 quando não encontra), .replace() para trocar texto, e .split() com sep.join() para desmontar uma string e remontá-la.

JunoMétodos essenciais de string Todos esses métodos retornam uma nova string, nenhum modifica no lugar, então encadeie-os ou atribua o resultado. Fique atento às pegadinhas: .strip("x") recebe um conjunto de caracteres para remover, não um prefixo, e .split() sem argumento colapsa sequências de espaços em branco. Para montar várias partes, construa uma lista e use sep.join().

JunoMétodos essenciais de string As duas pegadinhas que mordem no código real: .strip(chars) remove um conjunto de caracteres das extremidades, não um prefixo, então use removeprefix() quando quiser dizer prefixo, e construir uma string com += em um loop é o cenário lento, então junte em uma lista e faça join() uma única vez. Para comparação, normalize com .casefold() em vez de .lower(), e trate .title() como algo apenas para exibição, já que ele estraga contrações.

f-strings

f-strings embutem valores diretamente dentro de um texto. Coloque f antes da aspa de abertura, depois envolva qualquer variável ou expressão em chaves. Python preenche o valor quando o código é executado. Você também pode adicionar dois pontos depois do valor para controlar como ele é exibido.

f-strings avaliam qualquer expressão dentro de {} em tempo de execução e convertem o resultado em uma string. Dois pontos dentro das chaves introduzem uma especificação de formato: uma sintaxe compacta para controlar casas decimais, alinhamento e formatação de números.

Cada {} em uma f-string termina chamando o próprio método __format__ do valor (um dunder, o método de duplo sublinhado que Python chama nos bastidores quando formata um valor), passando o que quer que você tenha escrito depois dos dois pontos. Então qualquer classe que você escreva pode decidir como ela aparece dentro de uma f-string definindo __format__. As flags de conversão !r, !s e !a executam repr(), str() ou ascii() sobre o valor antes; !r é a que vale guardar, porque mostra um valor da forma como você o digitaria em código, com aspas e escapes incluídos, o que é demonstrado na prática abaixo.

name = "Alice"
score = 94.5

print(f"Hello, {name}!")           # "Hello, Alice!"
print(f"Score: {score:.1f}%")      # "Score: 94.5%"
print(f"2 + 2 = {2 + 2}")          # "2 + 2 = 4"
print(f"Name: {name.upper()}")     # "Name: ALICE"

A especificação de formato depois de : controla como o valor é exibido:

Especificação	Significado	Exemplo
.2f	2 casas decimais	f"{3.14159:.2f}" → "3.14"
.0%	porcentagem, sem decimais	f"{0.94:.0%}" → "94%"
,	separador de milhares	f"{1000000:,}" → "1,000,000"
>10	alinha à direita em 10 caracteres	f"{'hi':>10}" → " hi"

Você usará .2f mais: sempre que exibir um decimal e quiser um número organizado em vez de uma longa sequência de dígitos. Tudo o mais na tabela está ali para quando você precisar. Você pode colocar qualquer variável, operação aritmética ou chamada de método dentro de {}.

.2f e .0% cobrem a maior parte da formatação de exibição. Os especificadores de alinhamento (>, <, ^) produzem saída em formato de tabela quando combinados com uma largura. O padrão geral é {value:[align][width][.precision][type]}. Uma vez que você reconhece as partes, qualquer especificação fica legível sem precisar memorizar todas as combinações.

A mesma especificação pode significar coisas diferentes para tipos diferentes, porque cada tipo formata a si mesmo: f"{'hi':5}" preenche o texto pela direita, enquanto f"{42:5}" preenche um número pela esquerda, o mesmo :5, resultado oposto. A flag de conversão que vale transformar em hábito é !r: ela executa repr() antes de formatar, o que envolve strings em aspas e transforma caracteres invisíveis (tabulações, espaços no final, quebras de linha) em sequências de escape visíveis. Quando a saída parece sutilmente errada, trocar {value} por {value!r} é a forma mais rápida de ver o que realmente está lá.

Junof-strings Coloque f antes da aspa de abertura, depois envolva qualquer variável, soma ou chamada de método em {} e Python coloca o resultado ali quando a linha é executada. Dois pontos dentro das chaves controlam a aparência: :.2f para duas casas decimais é o que você vai usar com frequência. Muito mais organizado do que colar texto com +.

Junof-stringsf"..." avalia qualquer expressão dentro de {} e coloca o resultado direto ali, sem precisar de str(). Depois dos dois pontos vem a especificação de formato: :.2f, :,, :>10 e afins, todos seguindo {value:[align][width][.precision][type]}. Aprenda as partes uma vez e você conseguirá ler qualquer especificação sem precisar memorizá-las.

Junof-strings Cada {} chama o próprio __format__ do valor, então a especificação depois dos dois pontos significa o que aquele tipo decidir, e é por isso que :5 preenche texto e números em direções opostas. A flag que vale guardar é !r: ela mostra um valor da forma como você o digitaria, então espaços perdidos e outras coisas invisíveis saltam aos olhos no momento em que a saída parece estranha.

Strings de múltiplas linhas

Para escrever uma string que ocupa mais de uma linha, use aspas triplas: três " no início e três no final. Python preserva todas as quebras de linha e espaçamentos exatamente como você os escreveu.

Strings com aspas triplas preservam todos os espaços em branco e quebras de linha literalmente. São o padrão para blocos longos de texto, como templates de e-mail e consultas SQL, e para docstrings: a documentação embutida colocada no início do corpo de uma função ou classe.

Uma string com aspas triplas mantém cada caractere exatamente, incluindo os espaços no início de cada linha, e essa é a pegadinha: indente o literal para acompanhar seu código e essa indentação acaba dentro do texto. Quando ela é a primeira instrução dentro de uma função, classe ou módulo, Python a mantém como a docstring daquele objeto (a documentação que help() exibe para ele), então a convenção é colocar ali um resumo curto. Para indentar um bloco de aspas triplas para acompanhar o que o rodeia sem que a indentação vaze para dentro do valor, remova-a em tempo de execução com textwrap.dedent(). Aspas triplas ''' e """ funcionam da mesma forma; """ é a convenção.

message = """
Dear Alice,

Thank you for your order.

Best regards,
The Team
"""

JunoStrings de múltiplas linhas Três marcas de aspas em cada extremidade permitem que uma string se estenda por várias linhas, e Python preserva cada quebra de linha e espaço exatamente como você digitou. Recorra a elas sempre que tiver um bloco de texto, como uma mensagem ou um template, que não cabe confortavelmente em uma linha.

JunoStrings de múltiplas linhas Aspas triplas preservam quebras de linha e espaçamento ao pé da letra, então servem bem para templates de e-mail, SQL e qualquer bloco longo. É assim também que funcionam as docstrings: uma string de aspas triplas no topo de uma função ou classe se torna sua documentação embutida. Fique atento à indentação, já que os espaços que você adiciona para alinhá-la acabam dentro do texto.

JunoStrings de múltiplas linhas Tudo dentro de aspas triplas é mantido literalmente, incluindo o espaço em branco no início, e essa é a pegadinha: indente o literal para acompanhar seu código e essa indentação acaba dentro do valor. Coloque um resumo curto no topo de uma função ou classe e ele se torna a docstring que o help() exibe. Quando você precisa dela indentada no código-fonte, mas limpa no valor, passe-a por textwrap.dedent().

Sequências de escape

Alguns caracteres são difíceis de digitar diretamente dentro de uma string. Python usa sequências de escape: uma barra invertida seguida de uma letra que representa algo. As duas que você usará constantemente são \n para uma nova linha e \t para uma tabulação.

Sequências de escape permitem embutir caracteres que, de outra forma, quebrariam a sintaxe ou não podem ser digitados diretamente. As que você vai usar: \n (nova linha), \t (tabulação), \\ (uma barra invertida literal), \" e \' (aspas dentro de uma string com o mesmo delimitador). Caminhos do Windows exigem barras invertidas, o que colide com o processamento de escape. Coloque r antes para desativá-lo.

Além dos cotidianos \n e \t, Python oferece escapes Unicode para caracteres que você não pode digitar diretamente: \uXXXX e \UXXXXXXXX nomeiam um caractere pelo seu número, e \N{nome} o nomeia por palavras, como \N{GREEK SMALL LETTER ALPHA}. O recurso a usar no código real é a string bruta (raw string), escrita r"...", que desativa completamente o processamento de escape e deixa cada barra invertida passar sem alteração. Use-a para caminhos do Windows e para padrões de expressão regular, onde as barras invertidas são destinadas àquele consumidor e não ao Python, e onde esquecer o r produz padrões que silenciosamente casam com a coisa errada.

Sequência	Caractere
\n	Nova linha
\t	Tabulação
\\	Barra invertida literal
\"	Aspas duplas
\'	Aspas simples

print("Line one\nLine two")        # duas linhas de saída
print("Name:\tAlice")              # Name:   Alice
path = r"C:\Users\Alice\Documents" # string bruta, sem processamento de escape

JunoSequências de escape Uma barra invertida dentro de uma string significa "leia o próximo caractere de forma especial": \n começa uma nova linha, \t insere uma tabulação, \\ é uma barra invertida de verdade. Essas duas, \n e \t, são as que você vai realmente digitar. Coloque um r antes da aspa e as barras invertidas voltam a ser simples, útil para caminhos do Windows.

JunoSequências de escape\n, \t, \\ e \" cobrem os escapes do dia a dia. O que evita dores de cabeça: uma string bruta, r"...", desativa o processamento de escape, então cada barra invertida permanece literal. Use-a para caminhos do Windows e padrões de regex, onde as barras invertidas são destinadas a outra coisa, não ao Python.

JunoSequências de escape Além de \n e \t existem escapes Unicode como \N{nome}, mas o cavalo de batalha é a string bruta r"...", que deixa cada barra invertida passar intocada. Recorra a ela em padrões de regex e caminhos do Windows, já que esquecê-la te dá um padrão que silenciosamente casa com a coisa errada, em vez de um erro que te avisa.

Verificando o conteúdo de uma string

Python tem métodos que respondem a perguntas de sim/não sobre o que uma string contém. Eles retornam True ou False. O mais útil no começo: isdigit() permite verificar se uma string é composta só por números antes de convertê-la, para você evitar uma quebra em uma entrada inesperada.

Os métodos is* testam cada um uma propriedade específica da string toda e retornam True apenas se todo caractere satisfizer a condição. O uso principal deles é a validação de entrada: verificar antes de converter para evitar uma quebra em uma entrada inesperada. isdigit() antes de int() é o padrão clássico, uma alternativa a capturar o ValueError abordado no capítulo Arquivos e exceções.

Essas verificações perguntam "todo caractere é desse tipo" considerando todo o Unicode, não apenas as letras e dígitos ASCII comuns. Isso significa que "2".isdigit() é True tanto para o dois sobrescrito quanto para o "2" comum, o que pode deixar entradas surpreendentes passarem por uma verificação de validação. Quando você se refere estritamente aos dígitos de 0 a 9, combine s.isascii() and s.isdigit(). isnumeric() é ainda mais amplo, contando frações e outros caracteres com valor numérico, então recorra à verificação mais restrita que corresponda ao que você realmente aceita, em vez da primeira que parecer correta.

"42".isdigit()       # True
"hello".isalpha()    # True
"hello42".isalnum()  # True
"   ".isspace()      # True
"Hello".islower()    # False
"HELLO".isupper()    # True

JunoVerificando o conteúdo de uma string Os métodos is* respondem perguntas de sim ou não e retornam True só quando todo caractere se encaixa. O que você vai usar primeiro: chame isdigit() antes de int() para garantir que o texto realmente é um número, assim uma entrada estranha não quebra seu programa.

JunoVerificando o conteúdo de uma string Cada método is* só é True se a string toda passar, o que os torna úteis para validar entrada antes de converter. isdigit() antes de int() é a guarda clássica. Lembre-se de que ele testa a string toda, então uma string vazia retorna False em todos eles.

JunoVerificando o conteúdo de uma string Essas verificações abrangem todo o Unicode, não apenas ASCII puro, então isdigit() deixa passar sobrescritos e outros caracteres numéricos que você não pretendia aceitar. Quando você se refere aos dígitos de 0 a 9, combine: s.isascii() and s.isdigit(). Escolha a verificação mais restrita que corresponda à sua entrada real, em vez da primeira que parecer próxima.

Na prática

Remova espaços em branco, normalize a caixa e depois extraia o que você precisa. Essa sequência lida com quase qualquer texto fornecido pelo usuário:

raw_input = "  [email protected]  "
email = raw_input.strip().lower()   # "[email protected]"

at_pos = email.find("@")
username = email[:at_pos]
domain = email[at_pos + 1:]

print(f"User:   {username}")    # "alice"
print(f"Domain: {domain}")      # "example.com"

Construindo uma URL a partir de partes e imediatamente validando e analisando ela:

BASE_URL = "https://api.example.com"
version = "v2"
resource = "users"
user_id = 42

url = f"{BASE_URL}/{version}/{resource}/{user_id}"
# "https://api.example.com/v2/users/42"

parts = url.split("://")              # ["https", "api.example.com/v2/users/42"]
protocol = parts[0]                   # "https"
secured = url.startswith("https")
domain = parts[1].split("/")[0]       # "api.example.com"

print(f"Protocol : {protocol}")
print(f"Secure   : {secured}")
print(f"Domain   : {domain}")

Analisando uma linha de log estruturada usando find(), slicing e alinhamento com f-string:

log_entry = "[2024-01-15 09:42:11] ERROR: File not found: report.csv"

timestamp = log_entry[1:20]
rest = log_entry[22:]                # "ERROR: File not found: report.csv"
colon_pos = rest.find(":")
level = rest[:colon_pos]             # "ERROR"
message = rest[colon_pos + 2:]       # "File not found: report.csv"

print(f"[{timestamp}] {level:>8}: {message}")
# [2024-01-15 09:42:11]    ERROR: File not found: report.csv

find() localiza o limite, o slicing extrai as partes, e a especificação de formato >8 alinha à direita o rótulo de severidade para que as colunas permaneçam consistentes quando os nomes dos níveis têm tamanhos diferentes.

Referência de métodos

Método	O que faz
.lower() / .upper()	Converte para tudo minúsculo / tudo maiúsculo
.title() / .capitalize()	Coloca em maiúscula cada palavra / apenas a primeira
.strip() / .lstrip() / .rstrip()	Remove espaços em branco ao redor
.find(sub)	Índice da primeira correspondência, ou -1
.count(sub)	Quantas vezes sub aparece
.startswith(s) / .endswith(s)	Verificação de prefixo / sufixo
.replace(old, new)	Substitui ocorrências
.split(sep)	Divide em uma lista
sep.join(iterable)	Junta itens em uma string
.isdigit() / .isalpha() / .isalnum()	Verificações de tipo de caractere