Strings em profundidade: fatiamento, métodos e formatação

1. Introdução às Strings em Python

1.1. Strings como sequências imutáveis de caracteres

Em Python, strings são sequências imutáveis de caracteres Unicode. Isso significa que, uma vez criada, uma string não pode ser alterada in-place — qualquer operação que pareça modificar uma string, na verdade, cria um novo objeto na memória. Essa imutabilidade traz segurança e previsibilidade ao código, além de permitir que strings sejam usadas como chaves em dicionários.

1.2. Criação de strings: aspas simples, duplas e triplas

Python oferece três formas de criar strings literais:

# Aspas simples
nome = 'Python'

# Aspas duplas
linguagem = "Python"

# Aspas triplas (multilinha)
texto_longo = """Esta é uma string
que se estende por
várias linhas."""

A escolha entre aspas simples e duplas é pessoal, mas ambas são equivalentes. Aspas triplas são ideais para documentação (docstrings) e textos longos.

1.3. Caracteres especiais e escape sequences

Strings podem conter caracteres especiais usando a barra invertida (\):

print("Linha 1\nLinha 2")       # \n = nova linha
print("Coluna 1\tColuna 2")     # \t = tabulação
print("Caminho: C:\\Users\\")   # \\ = barra invertida literal
print('Ele disse: "Olá"')       # aspas dentro de string

2. Indexação e Fatiamento (Slicing)

2.1. Indexação positiva e negativa

Cada caractere em uma string possui um índice. A indexação começa em 0 para o primeiro caractere e em -1 para o último:

texto = "Python"
print(texto[0])    # 'P'
print(texto[5])    # 'n'
print(texto[-1])   # 'n' (último caractere)
print(texto[-6])   # 'P' (primeiro caractere)

2.2. Sintaxe completa do fatiamento

O fatiamento segue a sintaxe [início:fim:passo], onde:
- início: índice inicial (inclusivo, padrão = 0)
- fim: índice final (exclusivo, padrão = comprimento da string)
- passo: incremento entre caracteres (padrão = 1)

texto = "Programação em Python"
print(texto[0:11])      # 'Programação'
print(texto[:11])       # 'Programação' (início implícito)
print(texto[12:])       # 'em Python' (fim implícito)
print(texto[::2])       # 'Pormçã ePto' (passo 2)
print(texto[::-1])      # 'nohtyP me oãçamargorP' (invertida)

2.3. Exemplos práticos

# Invertendo uma string
palindromo = "radar"
print(palindromo == palindromo[::-1])  # True

# Extraindo partes específicas
email = "usuario@exemplo.com"
usuario = email[:email.index("@")]
dominio = email[email.index("@")+1:]
print(f"Usuário: {usuario}, Domínio: {dominio}")

# Pulando caracteres
texto = "abcdefghij"
print(texto[1:9:3])  # 'beh'

3. Imutabilidade e Operações Básicas

3.1. Por que strings não podem ser alteradas in-place

texto = "Python"
# texto[0] = "J"  # Isso geraria TypeError: 'str' object does not support item assignment

# A forma correta é criar uma nova string
novo_texto = "J" + texto[1:]
print(novo_texto)  # 'Jython'

3.2. Concatenação (+) e repetição (*)

saudacao = "Olá" + " " + "Mundo"
print(saudacao)           # 'Olá Mundo'

eco = "Eco! " * 3
print(eco)                # 'Eco! Eco! Eco! '

3.3. Verificação de pertinência com in e not in

frase = "Python é incrível"
print("Python" in frase)      # True
print("Java" not in frase)    # True

4. Métodos de Consulta e Análise

4.1. Busca e contagem

texto = "A arte de programar em Python é uma arte"

print(texto.find("arte"))      # 2 (primeira ocorrência)
print(texto.rfind("arte"))     # 35 (última ocorrência)
print(texto.index("arte"))     # 2 (similar ao find, mas levanta exceção se não encontrar)
print(texto.count("arte"))     # 2 (quantas vezes aparece)

4.2. Verificação de conteúdo

codigo = "Python3"
print(codigo.startswith("Py"))  # True
print(codigo.endswith("3"))     # True
print("123".isdigit())          # True
print("abc".isalpha())          # True
print("abc123".isalnum())       # True

4.3. Comprimento e capitalização

texto = "python é legal"
print(len(texto))               # 15
print(texto.upper())            # 'PYTHON É LEGAL'
print(texto.lower())            # 'python é legal'
print(texto.capitalize())       # 'Python é legal'
print(texto.title())            # 'Python É Legal'

5. Métodos de Transformação e Limpeza

5.1. Substituição e divisão

texto = "Python,Java,Ruby,JavaScript"

# Substituição
print(texto.replace(",", " | "))  # 'Python | Java | Ruby | JavaScript'

# Divisão
linguagens = texto.split(",")
print(linguagens)  # ['Python', 'Java', 'Ruby', 'JavaScript']

# Divisão por linhas
multilinha = "Linha1\nLinha2\nLinha3"
print(multilinha.splitlines())  # ['Linha1', 'Linha2', 'Linha3']

5.2. Junção e centralização

# Junção
palavras = ["Python", "é", "poderoso"]
frase = " ".join(palavras)
print(frase)  # 'Python é poderoso'

# Centralização
titulo = "Python"
print(titulo.center(20, "="))  # '=======Python========'
print(titulo.ljust(20, "-"))   # 'Python--------------'
print(titulo.rjust(20, "-"))   # '--------------Python'

5.3. Remoção de espaços e caracteres

texto_sujo = "   Olá Mundo!   "
print(texto_sujo.strip())      # 'Olá Mundo!'
print(texto_sujo.lstrip())     # 'Olá Mundo!   '
print(texto_sujo.rstrip())     # '   Olá Mundo!'

# Removendo caracteres específicos
url = "www.exemplo.com/"
print(url.strip("w./"))        # 'exemplo.com'

6. Formatação de Strings (Além das f-strings)

6.1. Método format(): placeholders e argumentos

# Argumentos posicionais
print("{} é {} anos".format("João", 25))  # 'João é 25 anos'

# Argumentos nomeados
print("{nome} tem {idade} anos".format(nome="Maria", idade=30))

# Índices
print("{1} {0} {1}".format("casa", "azul"))  # 'azul casa azul'

6.2. Especificadores de formato

# Alinhamento
print("{:<10}".format("esquerda"))  # 'esquerda  '
print("{:>10}".format("direita"))   # '  direita'
print("{:^10}".format("centro"))    # '  centro  '

# Preenchimento
print("{:-^20}".format("Python"))   # '-------Python--------'

6.3. Formatação de números

# Casas decimais
pi = 3.14159265
print("{:.2f}".format(pi))          # '3.14'

# Separadores de milhar
print("{:,}".format(1234567))       # '1,234,567'

# Notação científica
print("{:.2e}".format(12345.6789))  # '1.23e+04'

# Porcentagem
taxa = 0.25
print("{:.1%}".format(taxa))        # '25.0%'

7. Codificação e Boas Práticas

7.1. Strings Unicode e encoding/decoding

texto = "Python é ツ"
print(texto.encode("utf-8"))  # b'Python \xc3\xa9 \xe2\x98\xba'
print(texto.encode("utf-8").decode("utf-8"))  # 'Python é ツ'

# Cuidado com encoding incorreto
try:
    texto.encode("utf-8").decode("latin-1")  # Pode gerar caracteres estranhos
except UnicodeDecodeError as e:
    print(f"Erro: {e}")

7.2. Performance: evitando concatenação excessiva

# Ineficiente (cria várias strings intermediárias)
resultado = ""
for i in range(1000):
    resultado += str(i)

# Eficiente (usa lista e join)
partes = []
for i in range(1000):
    partes.append(str(i))
resultado = "".join(partes)

7.3. Comparação de strings e ordenação lexicográfica

# Comparação lexicográfica (baseada em Unicode)
print("abc" < "abd")   # True
print("Python" > "Java")  # True
print("Maçã" == "maçã")  # False (case-sensitive)

# Ordenação
palavras = ["zebra", "árvore", "banana", "Água"]
print(sorted(palavras))  # ['banana', 'Água', 'zebra', 'árvore'] (cuidado com acentos)
print(sorted(palavras, key=str.lower))  # Ordenação case-insensitive

Referências