Learn PythonStrings
Texto aparece em quase todos os programas que você escreve. Nomes, mensagens, pontuações, rótulos. Em Python, qualquer pedaço de texto é chamado de string: qualquer valor que você envolve em aspas. Simples ou duplas, ambas funcionam da mesma forma.
greeting = "Hello, world"
username = 'alice'A única vez que a escolha de aspas importa é quando seu texto contém aspas. Use o estilo oposto para não ter que escapá-las:
note = "It's a great day" # apóstrofo dentro, use aspas duplas
message = 'She said "hello"' # aspas duplas dentro, use aspas simples
escaped = "She said \"hello\"" # ou escape com uma barra invertidaImutabilidade
Strings são imutáveis: uma vez que você cria uma, não pode mudá-la. Pense em uma string como permanentemente fixa no momento em que é criada. Qualquer operação que pareça modificar uma string está na verdade produzindo uma completamente nova. A original permanece exatamente como era.
name = "alice"
name = name.upper() # "ALICE" é uma nova string; "alice" fica inalteradaA consequência direta: você não pode alterar um caractere em uma posição específica. Python vai lançar um erro se você tentar.
name = "alice"
name[0] = "A" # TypeError: 'str' object does not support item assignmentPara obter uma string modificada, construa uma nova usando fatiamento ou um método. Ambos são cobertos abaixo.
name[0] = "A" não funciona, lança um TypeError. Indexação e fatiamento
Todo caractere em uma string tem uma posição numerada, começando no zero. Você pode ler caracteres individuais colocando aquele número de posição entre colchetes. Números negativos contam para trás a partir do final.
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)-1 é sempre o último caractere, -2 é o penúltimo, e assim por diante. São úteis quando você quer o final de uma string sem saber seu comprimento exato.
Fatiamento extrai um pedaço. [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" (início até posição 2)
print(word[:]) # "Python" (uma cópia de toda a string)
print(word[::2]) # "Pto" (cada segundo caractere)
print(word[::-1]) # "nohtyP" (invertida)Três padrões para alcançar na maioria das vezes: word[:n] pelos primeiros n caracteres, word[n:] por tudo a partir da posição n em diante, word[-n:] pelos últimos n caracteres. word[::-1] inverte uma string. Parece estranho na primeira vez, mas é Python idiomático e você vai ver frequentemente.
word[0] é o primeiro caractere e word[-1] é o último. Um fatiamento 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. Métodos essenciais de string
Strings vêm com um conjunto de métodos integrados: operações que você chama diretamente em qualquer valor de string. Você escreve a string (ou a variável que a contém), depois um ponto, depois o nome do método. Cada método retorna uma nova string. A original nunca é alterada.
Maiúsculas e minúsculas
text = "Hello, World"
text.lower() # "hello, world"
text.upper() # "HELLO, WORLD"
text.title() # "Hello, World" (cada palavra capitalizada)
text.capitalize() # "Hello, world" (apenas primeira palavra)lower() e upper() são os dois que você vai usar mais. lower() é particularmente útil ao comparar texto: "Alice" e "alice" ficam iguais uma vez que você chama .lower() em ambos os lados.
Espaço em branco
text = " hello "
text.strip() # "hello" (ambos os lados)
text.lstrip() # "hello " (apenas esquerda)
text.rstrip() # " hello" (apenas direita)strip() remove espaços de ambas as extremidades de uma string. Você vai usá-lo quase sempre que lidar com entrada do usuário ou texto de um arquivo, porque espaços perdidos causam falhas silenciosas: "alice" != "alice ".
Localização
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") # Truefind() retorna a posição onde um pedaço de texto começa dentro de sua string. Se não está lá, retorna -1. Use startswith() e endswith() quando você só se importa se a string começa ou termina com algo específico.
Substituição
text = "Hello, world"
text.replace("world", "Python") # "Hello, Python"
text.replace("l", "L") # "HeLLo, worLd" (todas ocorrências)
text.replace("l", "L", 1) # "HeLlo, world" (apenas primeira)replace() troca toda ocorrência de um pedaço de texto por outro e lhe devolve uma nova string. A original não é alterada. Passe um terceiro argumento se você só quer substituir a primeira ocorrência.
Dividindo e juntando
split() corta uma string em pedaços em um separador e retorna-os como uma lista. Você diz a ele no que cortar:
csv_row = "Alice,28,São Paulo"
parts = csv_row.split(",") # ["Alice", "28", "São Paulo"]
" hello world ".split() # ["hello", "world"]split() retorna uma lista, uma sequência ordenada de valores. Eles ganham seu próprio capítulo Lists; por enquanto trate-os como a sequência de partes que split() produz e join() consome.
join() faz o inverso: combina uma lista de strings em uma. 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: separator.join(list_of_strings). O separador vai à esquerda, a lista à direita. " ".join(words) coloca um espaço entre cada palavra. "".join(words) cola-os com nada entre.
.lower() e .upper() para maiúsculas/minúsculas, .strip() para aparar espaços perdidos, .find() para localizar texto (retorna -1 quando não está lá), .replace() para trocar texto, e .split() com sep.join() para separar uma string e montá-la de novo. f-strings
f-strings embutem valores diretamente dentro de texto. Coloque f antes da aspas de abertura, depois envolva qualquer variável ou expressão em chaves. Python a preenche quando o código roda. Você também pode adicionar dois-pontos depois do valor para controlar como ele é exibido.
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 após : controla como o valor é exibido:
| Spec | Significado | Exemplo |
|---|---|---|
.2f | 2 casas decimais | f"{3.14159:.2f}" → "3.14" |
.0% | percentual, sem decimais | f"{0.94:.0%}" → "94%" |
, | separador de milhares | f"{1000000:,}" → "1.000.000" |
>10 | alinhado à direita em 10 caracteres | f"{'hi':>10}" → " hi" |
Você vai usar .2f na maioria das vezes: toda vez que exibe um decimal e quer um número arrumado em vez de um longo fluxo de dígitos. Tudo o mais na tabela está lá quando você precisa. Você pode colocar qualquer variável, aritmética ou chamada de método dentro do {}.
f antes da aspas de abertura, depois envolva qualquer variável, soma ou chamada de método em {} e Python coloca o resultado quando a linha roda. Dois-pontos dentro das chaves controlam a aparência: :.2f por duas casas decimais é aquele em que você vai confiar. Muito mais arrumado que colar texto junto com +. Strings multilinhas
Para escrever uma string que se estende por 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çamento exatamente como você as escreveu.
message = """
Dear Alice,
Thank you for your order.
Best regards,
The Team
"""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 por uma letra que representa algo. As duas que você vai usar constantemente são \n para uma nova linha e \t para uma aba.
| Sequência | Caractere |
|---|---|
\n | Nova linha |
\t | Aba |
\\ | 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" # raw string, sem processamento de escape\n começa uma nova linha, \t insere uma aba, \\ é uma verdadeira barra invertida. Aquelas duas, \n e \t, são aquelas que você realmente digitará. Coloque um r antes da aspas e barras invertidas voltam a ser simples, útil para caminhos Windows. Verificando conteúdo de string
Python tem métodos que respondem perguntas sim/não sobre o que uma string contém. Eles retornam True ou False. O mais útil no início: isdigit() deixa você verificar se uma string é todos números antes de convertê-la, então você pode evitar uma queda em entrada inesperada.
"42".isdigit() # True
"hello".isalpha() # True
"hello42".isalnum() # True
" ".isspace() # True
"Hello".islower() # False
"HELLO".isupper() # Trueis* respondem perguntas sim-ou-não e retornam True apenas quando cada caractere se encaixa. Aquele que você vai usar primeiro: chame isdigit() antes de int() para ter certeza de que o texto realmente é um número, então entrada estranha não o derruba. Na prática
Remova espaço em branco, normalize maiúsculas/minúsculas, depois puxe o que você precisa. Esta sequência cuida de 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"Referência de métodos
| Método | O que faz |
|---|---|
.lower() / .upper() | Converte para todo minúsculo / todo maiúsculo |
.title() / .capitalize() | Capitaliza cada palavra / apenas a primeira |
.strip() / .lstrip() / .rstrip() | Remove espaço 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 |