Como Verificar se uma String é um Palíndromo em Python - Guia Passo a Passo

Introdução

Neste laboratório, você aprenderá como verificar se uma string é um palíndromo em Python. Um palíndromo é uma sequência de caracteres que se lê da mesma forma para trás e para a frente, como "arara" ou "ovo".

O laboratório guia você através da criação de um script Python que define uma função is_palindrome para identificar palíndromos. Isso envolve o processamento do texto de entrada, convertendo-o para minúsculas e removendo espaços, e então comparando o texto processado com sua versão invertida. Você também aprenderá como testar a função com palavras de exemplo.

Definir Palíndromos

Nesta etapa, exploraremos o conceito de palíndromos e como identificá-los usando Python. Um palíndromo é uma palavra, frase, número ou outra sequência de caracteres que se lê da mesma forma para trás ou para a frente. Exemplos incluem "arara", "reviver" e "ovo".

Para começar, vamos criar um script Python para definir o que é um palíndromo.

Abra o editor VS Code no ambiente LabEx.
Crie um novo arquivo chamado palindrome.py no diretório ~/project.

Você pode criar um novo arquivo clicando com o botão direito no painel Explorer (geralmente no lado esquerdo) e selecionando "New File". Certifique-se de salvar o arquivo como palindrome.py no diretório ~/project.
Adicione o seguinte código Python ao arquivo palindrome.py:
```
def is_palindrome(text):
    processed_text = ''.join(text.lower().split())
    return processed_text == processed_text[::-1]

## Example usage
word = "madam"
if is_palindrome(word):
    print(f"'{word}' is a palindrome")
else:
    print(f"'{word}' is not a palindrome")
```
Vamos detalhar este código:
- def is_palindrome(text):: Esta linha define uma função chamada is_palindrome que recebe uma string text como entrada.
- processed_text = ''.join(text.lower().split()): Esta linha prepara o texto de entrada para a verificação de palíndromo. Primeiro, converte o texto para minúsculas usando .lower() e, em seguida, remove quaisquer espaços usando .split() para dividir a string em uma lista de palavras, e ''.join() para juntar as palavras de volta em uma única string sem espaços.
- return processed_text == processed_text[::-1]: Esta linha compara o texto processado com sua versão invertida. processed_text[::-1] cria uma cópia invertida da string. Se o texto processado for o mesmo que sua versão invertida, a função retorna True (é um palíndromo); caso contrário, retorna False.
- As linhas após a definição da função são exemplos de uso. Ele chama a função is_palindrome com a palavra "madam" e imprime se é um palíndromo ou não.
Agora, vamos executar o script. Abra um terminal no WebIDE. Você geralmente pode encontrar uma aba de terminal na parte inferior da interface do VS Code, ou pode abrir um novo através do menu: Terminal -> New Terminal.
No terminal, navegue até o diretório ~/project (se você ainda não estiver lá):
```
cd ~/project
```
Execute o script Python:
```
python palindrome.py
```
Você deve ver a seguinte saída:
```
'madam' is a palindrome
```
Isso confirma que nosso script identifica corretamente "madam" como um palíndromo.

Inverter e Comparar

Nesta etapa, vamos nos aprofundar em como a função is_palindrome funciona, invertendo explicitamente a string de entrada e, em seguida, comparando-a com a original. Isso lhe dará uma compreensão mais clara do processo de identificação de palíndromos.

Abra o arquivo palindrome.py no editor VS Code. Este é o mesmo arquivo que você criou na etapa anterior.

Modifique a função is_palindrome em palindrome.py para inverter a string explicitamente:

def is_palindrome(text):
    processed_text = ''.join(text.lower().split())
    reversed_text = processed_text[::-1]  ## Explicitamente inverte a string
    return processed_text == reversed_text

## Example usage
word = "madam"
if is_palindrome(word):
    print(f"'{word}' is a palindrome")
else:
    print(f"'{word}' is not a palindrome")

word2 = "hello"
if is_palindrome(word2):
    print(f"'{word2}' is a palindrome")
else:
    print(f"'{word2}' is not a palindrome")

Aqui está o que mudou:

reversed_text = processed_text[::-1]: Esta linha cria uma cópia invertida da string processed_text e a atribui à variável reversed_text.
return processed_text == reversed_text: Esta linha agora compara o texto processado original com o texto explicitamente invertido.
Adicionado um segundo exemplo com a palavra "hello" para demonstrar um não-palíndromo.

Salve as alterações em palindrome.py.
Execute o script novamente no terminal:
```
python palindrome.py
```
Você deve agora ver a seguinte saída:
```
'madam' is a palindrome
'hello' is not a palindrome
```
Esta saída confirma que o script identifica corretamente tanto palíndromos quanto não-palíndromos. Ao inverter explicitamente a string, tornamos a lógica da função is_palindrome mais transparente.

Ignorar Maiúsculas/Minúsculas e Espaços

Nesta etapa, aprimoraremos nossa função is_palindrome para lidar com frases que são palíndromos, mas contêm espaços e letras maiúsculas e minúsculas. Por exemplo, "A man, a plan, a canal: Panama" é um palíndromo se ignorarmos os espaços, pontuação e caixa alta/baixa.

Abra o arquivo palindrome.py no editor VS Code.
Modifique a função is_palindrome em palindrome.py para ignorar maiúsculas/minúsculas e espaços:
```
import re

def is_palindrome(text):
    processed_text = re.sub(r'[^a-zA-Z]', '', text).lower()
    reversed_text = processed_text[::-1]
    return processed_text == reversed_text

## Example usage
word1 = "A man, a plan, a canal: Panama"
if is_palindrome(word1):
    print(f"'{word1}' is a palindrome")
else:
    print(f"'{word1}' is not a palindrome")

word2 = "Racecar"
if is_palindrome(word2):
    print(f"'{word2}' is a palindrome")
else:
    print(f"'{word2}' is not a palindrome")

word3 = "hello"
if is_palindrome(word3):
    print(f"'{word3}' is a palindrome")
else:
    print(f"'{word3}' is not a palindrome")
```
Vamos detalhar as mudanças:
- import re: Esta linha importa o módulo re, que fornece operações de expressão regular.
- processed_text = re.sub(r'[^a-zA-Z]', '', text).lower(): Esta linha agora usa uma expressão regular para remover quaisquer caracteres que não sejam letras (a-z, A-Z) do texto de entrada. re.sub(r'[^a-zA-Z]', '', text) substitui todos os caracteres que não são letras por uma string vazia, efetivamente removendo-os. Em seguida, .lower() converte a string resultante para minúsculas.
- Adicionamos exemplos de uso com "A man, a plan, a canal: Panama", "Racecar" e "hello" para testar a função atualizada.
Salve as alterações em palindrome.py.
Execute o script novamente no terminal:
```
python palindrome.py
```
Você deve agora ver a seguinte saída:
```
'A man, a plan, a canal: Panama' is a palindrome
'Racecar' is a palindrome
'hello' is not a palindrome
```
Esta saída confirma que o script agora identifica corretamente palíndromos, mesmo com espaços, pontuação e letras maiúsculas e minúsculas. A expressão regular efetivamente limpa o texto de entrada, permitindo a detecção precisa de palíndromos.

Resumo

Neste laboratório, começamos explorando o conceito de palíndromos, que são strings que se leem da mesma forma de trás para frente. Em seguida, criamos um script Python chamado palindrome.py contendo uma função is_palindrome(text) para identificar palíndromos.

A função is_palindrome primeiro pré-processa o texto de entrada, convertendo-o para minúsculas e removendo espaços. Em seguida, compara o texto processado com sua versão invertida para determinar se é um palíndromo, retornando True se for e False caso contrário. O script também inclui exemplos de uso demonstrando como chamar a função e imprimir o resultado.