Neste guia, vamos criar programas em Python que resolvem problemas comuns relacionados a operações com strings.
Você vai descobrir como verificar se strings em Python são palíndromos, anagramas ou se estão no formato de “Título”.
Revisão Rápida sobre Strings em Python
Em Python, strings são tipos de dados poderosos e nativos, usados para armazenar sequências de caracteres.
Indexação em Strings Python: Similar a outras estruturas de dados iteráveis, strings são indexadas a partir de zero. Portanto, os índices válidos para uma string de tamanho N vão de 0, 1, 2, até N-1.
Python também permite indexação negativa para acessar elementos do final da string. O índice -1 corresponde ao último caractere, -2 ao penúltimo, e assim por diante.
Imutabilidade de Strings em Python: As strings em Python são imutáveis, o que significa que não podem ser modificadas diretamente. No entanto, é possível usar diversos métodos de string para criar novas strings com as transformações desejadas.
Agora que já recapitulamos os fundamentos de strings em Python, vamos resolver alguns problemas simples e interessantes.
Vamos começar.
Verificação de Palíndromos em Strings Python
Problema: Dada uma string em Python, determine se ela é ou não um palíndromo.
Retorne `True` se for um palíndromo e `False` caso contrário.
Nosso primeiro desafio é identificar se uma string fornecida é um palíndromo ou não.
Um palíndromo é uma string que se lê da mesma forma da esquerda para a direita e da direita para a esquerda. Alguns exemplos são: “arara”, “radar”, “osso”, “reler”, entre outros.
Aqui estão os passos para resolver este problema:
- Crie uma cópia invertida da string e armazene-a em outra variável, se necessário.
- Compare os valores da string original com a string invertida.
- Se forem idênticos, a string é um palíndromo. Retorne `True` e encerre o processo.
- Se as cópias original e invertida forem diferentes, a string não é um palíndromo. Retorne `False`.
A operação chave é obter uma cópia invertida da string. Em Python, existem várias formas de realizar isso.
Vamos explorar duas abordagens:
- Usando fatiamento de string (slicing).
- Usando a função `reversed()` combinada com o método `join()`.
Como Inverter uma String Python Usando Slicing
A sintaxe `
- Se `inicio` for omitido, o fatiamento começa no início da string.
- Se o índice de `fim` for omitido, o fatiamento se estende até o final da string.
- Valores negativos para `passo` permitem retornar fatias a partir do final da string.
Portanto, `
O bloco de código abaixo mostra a definição da função `is_palindrome()`.
Ela recebe uma string como argumento e retorna `True` ou `False`, dependendo de ser um palíndromo ou não.
Aqui, utilizamos o fatiamento de string para obter a cópia invertida.
def is_palindrome(texto):
texto_invertido = texto[::-1]
if texto == texto_invertido:
return True
else:
return False
▶️ Agora que a função foi definida, podemos chamá-la com qualquer string válida como argumento.
is_palindrome("arara")
True
No código acima, “arara” é um palíndromo. Assim, a função `is_palindrome()` retorna `True` conforme esperado.
Agora, tente chamar a função com uma string que não seja um palíndromo, como “casa”.
is_palindrome("casa")
False
Como podemos observar, a função retorna `False`, o que está correto. ✅
Como Inverter uma String Python Usando `reversed()` e `join()`
Em Python, é possível usar o método `join()` em conjunto com a função `reversed()` para inverter uma string.
- A função `reversed()` retorna um iterador reverso sobre os caracteres da string.
- O método `join()` pode então ser usado para unir esses caracteres na ordem inversa.
Utilizando o método acima, podemos reescrever a função `is_palindrome()` como no bloco de código abaixo.
def is_palindrome(texto):
texto_invertido = "".join(reversed(texto))
if texto == texto_invertido:
return True
else:
return False
Você também pode usar a função `is_palindrome()` dentro de uma list comprehension para coletar todos os palíndromos de uma lista maior de strings.
lista_textos = ["reler", "azul", "osso", "12321", "dragão"] palindromos = [texto for texto in lista_textos if is_palindrome(texto)] print(palindromos) # Output ['reler', 'osso', '12321']
Veja como o código acima funciona:
- Itera sobre `lista_textos` e chama `is_palindrome()` em cada string.
- Se `is_palindrome()` retornar `True`, a string é adicionada à lista `palindromos`.
Como pode ser observado na saída, `palindromos` é a lista com todas as strings palíndrômicas encontradas em `lista_textos`.
Verificação de Anagramas em Strings Python
Outra questão comum em entrevistas é verificar se um par de strings, `str1` e `str2`, são anagramas.
Duas strings são consideradas anagramas se a contagem de caracteres em ambas for exatamente a mesma. Isso significa que uma string pode ser obtida permutando ou reorganizando os caracteres da outra.
Exemplos de anagramas são: “roma” – “amor”, “olá” – “loa”, “ator” – “rota”, etc.
Como Verificar Anagramas Usando o Objeto Counter em Python
Uma maneira simples e intuitiva é calcular a quantidade de ocorrências de cada caractere nas duas strings e, em seguida, verificar se essas contagens são iguais.
Isso pode ser facilitado com o uso do objeto `Counter` do módulo `itertools`. O `Counter` retorna um dicionário Python, onde as chaves são os caracteres e os valores são as contagens correspondentes.
Considere as strings “amor” e “roma”, conforme mostrado abaixo.
str1 = "amor" str2 = "roma"
Aqui, `c1` e `c2` são objetos `Counter` que armazenam as contagens de caracteres de `str1` e `str2`, respectivamente.
from collections import Counter
c1 = Counter(str1)
c2 = Counter(str2)
print(c1)
print(c2)
c1 == c2
# Output
Counter({'a': 1, 'm': 1, 'o': 1, 'r': 1})
Counter({'r': 1, 'o': 1, 'm': 1, 'a': 1})
True
`c1 == c2` retorna `True` pois `str1` e `str2` são anagramas.
Com base nessa lógica, podemos definir a função `são_anagramas()` com dois parâmetros, `texto1` e `texto2`. Dentro da função, verificamos se `Counter(texto1) == Counter(texto2)`.
def são_anagramas(texto1, texto2):
if Counter(texto1) == Counter(texto2):
return True
else:
return False
▶️ Para verificar, chame `são_anagramas()` com `str1` e `str2` como argumentos. Como `str1` e `str2` são anagramas (“amor” e “roma”), a função retorna `True`, o que está correto.
são_anagramas(str1, str2) True
Como Verificar Anagramas Usando Cópias Ordenadas de Strings
Há outra forma de fazer isso.
Se duas strings são anagramas, suas cópias ordenadas são idênticas.
Assim, podemos reescrever a função `são_anagramas()` para verificar se a versão ordenada de `str1` é a mesma que a cópia ordenada de `str2`. Se forem iguais, as strings são anagramas; caso contrário, não são.
Com o método de comparação de cópias ordenadas, podemos reescrever a função `são_anagramas()` da seguinte forma:
def são_anagramas(texto1, texto2):
if sorted(texto1) == sorted(texto2):
return True
else:
return False
Agora, vamos executar algumas chamadas da função.
- As strings “elbow” e “below” são anagramas, e a função `são_anagramas()` retorna `True`.
- As strings “state” e “tasted” não são anagramas, e a função retorna `False`.
são_anagramas("below","elbow")
True
são_anagramas("state","tasted")
False
Verificação de String em Formato “Título” em Python
Aqui está nossa última questão para este guia.
Problema: Dada uma string – o nome completo de uma pessoa (nome e sobrenome).
Você precisa verificar se a primeira letra do nome e do sobrenome estão em maiúsculo.
Esse formato em que a primeira letra de cada palavra é maiúscula é conhecido como formato “Título”.
Portanto, é preciso verificar se o nome está no formato “Título”:
1. Se sim, exiba uma mensagem informando que a formatação já está correta.
2. Caso contrário, retorne uma cópia da string formatada no formato “Título”.
- Python possui um método embutido de string chamado `istitle()` que verifica se uma string está no formato “Título”.
`
- O método de string `title()` do Python retorna uma cópia da string no formato “Título”.
Agora, podemos usar esses dois métodos para resolver o problema.
Defina a função `verifica_titulo()` que recebe `nome` como argumento.
- Chame o método `istitle()` na string de entrada para verificar se está formatada no estilo “Título”.
- Se o resultado for `True`, imprima que a string já está no formato “Título”.
- Caso contrário, chame o método `title()` e retorne uma cópia da string no formato “Título”.
O bloco de código abaixo apresenta a definição da função `verifica_titulo()`.
def verifica_titulo(nome):
if nome.istitle():
print(f"'{nome}' já está formatado no formato título.")
else:
return nome.title()
Agora, vamos chamar o método `verifica_titulo()` com um argumento.
verifica_titulo("ana silva")
# Output
Ana Silva
Na saída acima, vemos que a string “Ana Silva” agora está no formato “Título”.
▶️ Vamos analisar outro exemplo.
verifica_titulo("maria clara")
# Output
Maria Clara
Desta vez, vamos chamar a função com uma string que já está no formato “Título”.
verifica_titulo("José Souza")
# Output
'José Souza' já está formatado no formato título.
Somos informados de que a string já está formatada no estilo “Título”, e a função funciona conforme o esperado.
Conclusão 👩🏫
Agora, vamos recapitular os problemas que abordamos até agora.
- Para verificar se uma string é um palíndromo, compare a string com sua versão invertida. Use fatiamento de string ou métodos internos para inverter a string.
- Para determinar se duas strings são anagramas, verifique se suas cópias ordenadas são iguais. Use a função `sorted()` para ordenar uma string.
- Para verificar se um nome está no formato “Título”, utilize o método `.istitle()` para verificação e o método `.title()` para obter uma cópia da string formatada corretamente.
Espero que você tenha aproveitado este guia sobre strings em Python. Como próximos passos, sugiro que explore list comprehensions em Python ou o operador “não igual”.
Bons estudos e codificação! 🎉