Modificar Strings

Strings em Python são sequências de caracteres delimitadas por aspas. Embora as strings sejam imutáveis — você não pode alterá-las diretamente — Python oferece um rico conjunto de operadores e métodos que retornam strings novas e modificadas. Este capítulo aborda as técnicas mais importantes: concatenação, repetição, conversão de capitalização, fatiamento, substituição de substrings, remoção de espaços em branco, divisão e junção, e muito mais.

Conceito Principal: Strings São Imutáveis

Antes de começar, é importante entender que todo método de "modificação" retorna uma nova string. A string original nunca é alterada.

greeting = "hello"
upper_greeting = greeting.upper()

print(greeting)        # hello  (unchanged)
print(upper_greeting)  # HELLO  (new string)

Isso significa que você deve atribuir o resultado a uma variável (ou usá-lo diretamente) para manter a alteração.

Concatenação de Strings

A concatenação combina duas ou mais strings em uma usando o operador +. Você pode encadear quantas strings precisar.

Concatenar strings em Python

Concatenando Variáveis com Literais

Você pode misturar variáveis de string com literais de string:

first_name = "Ada"
last_name  = "Lovelace"
full_name  = first_name + " " + last_name
print(full_name)  # Ada Lovelace

Para quantidades maiores de texto, considere usar format strings ou f-strings, que são mais fáceis de ler do que longas cadeias de +.

Repetição de Strings

O operador * repete uma string um determinado número de vezes. Isso é útil para gerar separadores, preenchimento ou padrões simples.

Repetir uma string em Python

Alterando a Capitalização

Python oferece vários métodos para alterar a capitalização de uma string.

Converter uma string para maiúsculas ou minúsculas em Python

Os métodos de capitalização são comumente usados ao comparar entradas do usuário, independentemente de como foram digitadas:

answer = input("Type yes or no: ")
if answer.lower() == "yes":
    print("You said yes!")

Fatiamento de Strings

O fatiamento extrai parte de uma string usando a sintaxe [start:stop:step]. O resultado é uma nova string contendo os caracteres do índice start até, mas não incluindo, o índice stop.

 H  e  l  l  o  ,     W  o  r  l  d  !
 0  1  2  3  4  5  6  7  8  9 10 11 12
-13-12-11-10-9 -8 -7 -6 -5 -4 -3 -2 -1

Fatiar strings em Python

Quando Usar Índices Negativos

Índices negativos contam a partir do final da string. O índice -1 é o último caractere, -2 é o penúltimo, e assim por diante. Isso é prático quando você quer o final de uma string sem saber seu comprimento:

filename = "report_2024.csv"
extension = filename[-3:]
print(extension)  # csv

Para um aprofundamento dedicado, veja o capítulo Slicing Strings.

Substituindo Substrings

O método replace(old, new) retorna uma cópia da string com todas as ocorrências de old substituídas por new. Passe um terceiro argumento count para limitar quantas substituições são feitas.

Substituir parte de uma string em Python

text = "I like cats. Cats are great. Cats!"
print(text.replace("Cats", "Dogs"))         # replaces all occurrences
print(text.replace("Cats", "Dogs", 1))      # replaces first occurrence only

I like cats. Dogs are great. Dogs!
I like cats. Dogs are great. Cats!

Note que replace() diferencia maiúsculas de minúsculas: "cats" e "Cats" são tratadas como substrings diferentes.

Removendo Espaços em Branco

Caracteres de espaço em branco (espaços, tabulações, quebras de linha) no início ou no final de uma string frequentemente precisam ser removidos, especialmente ao processar entradas do usuário ou ler arquivos.

raw = "   hello world   "
print(repr(raw.strip()))   # 'hello world'
print(repr(raw.lstrip()))  # 'hello world   '
print(repr(raw.rstrip()))  # '   hello world'

Você também pode remover caracteres específicos passando-os como argumento:

path = "///usr/local/bin///"
print(path.strip("/"))  # usr/local/bin

Dividindo Strings

O método split(sep) divide uma string com base em um separador e retorna uma lista de substrings. Sem argumento, divide em qualquer espaço em branco e remove strings vazias.

sentence = "Python is easy to learn"
words = sentence.split()
print(words)  # ['Python', 'is', 'easy', 'to', 'learn']

csv_row = "Alice,30,Engineer"
fields = csv_row.split(",")
print(fields)  # ['Alice', '30', 'Engineer']

Passe um segundo argumento maxsplit para limitar o número de divisões:

data = "one:two:three:four"
print(data.split(":", 2))  # ['one', 'two', 'three:four']

Juntando Strings

join() é o inverso de split(). Ele combina uma lista de strings em uma só, colocando um separador entre cada elemento. O separador é a string na qual você chama join().

words = ["Python", "is", "fun"]
sentence = " ".join(words)
print(sentence)  # Python is fun

path_parts = ["usr", "local", "bin"]
path = "/".join(path_parts)
print(path)  # usr/local/bin

Usar join() é muito mais eficiente do que concatenar strings em um loop, pois cada + cria um novo objeto string. join() aloca a string final apenas uma vez.

Pesquisando Dentro de Strings

Vários métodos ajudam a encontrar texto dentro de uma string.

find() e index()

find(sub) retorna o índice da primeira ocorrência de sub, ou -1 se não encontrado. index(sub) faz o mesmo, mas lança ValueError em vez de retornar -1.

text = "the quick brown fox"
print(text.find("quick"))   # 4
print(text.find("slow"))    # -1

print(text.index("brown"))  # 10

startswith() e endswith()

Esses métodos retornam True ou False e são uma alternativa mais limpa ao fatiamento quando você precisa verificar o início ou o fim de uma string.

url = "https://www.w3docs.com"
print(url.startswith("https"))   # True
print(url.endswith(".com"))      # True
print(url.startswith("http://")) # False

Você pode passar uma tupla de prefixos/sufixos para verificar múltiplas opções de uma vez:

filename = "photo.jpg"
print(filename.endswith((".jpg", ".jpeg", ".png")))  # True

count()

count(sub) retorna quantas vezes sub aparece na string (sem sobreposição).

text = "banana"
print(text.count("a"))   # 3
print(text.count("an"))  # 2

Verificando Propriedades de Strings

Python possui uma família de métodos is* que retornam True ou False sobre o conteúdo de uma string.

print("hello".isalpha())    # True  – all alphabetic
print("hello123".isalnum()) # True  – all alphanumeric
print("12345".isdigit())    # True  – all digits
print("  ".isspace())       # True  – all whitespace
print("Hello World".istitle()) # True – title-case

Esses métodos são especialmente úteis para validação de entradas.

Exemplo Prático: Limpando Entradas do Usuário

A modificação de strings no mundo real frequentemente combina várias técnicas:

raw_input = "  Ada Lovelace  "

# Clean and normalise
name = raw_input.strip()          # remove surrounding spaces
name = name.title()               # ensure proper capitalisation

parts = name.split()              # split into first / last
first, last = parts[0], parts[1]

print(f"First: {first}, Last: {last}")  # First: Ada, Last: Lovelace

Referência Rápida

Para a lista completa de métodos de string integrados, veja String Methods. Para aprender sobre sequências de escape como \n e \t, veja Escape Characters. Para pesquisa e manipulação de texto poderosa usando padrões, veja Python Regex.

Prática