[Sugestão] resolução: Identificando palavras mais longas em um texto

from identifica import identifica_palavras frase = input('Digite uma frase: ') tamanhos, palavras = identifica_palavras(frase) print('Dicionário (Palavra : Tamanho):') print(tamanhos) print('\nPalavras longas encontradas: ') for palavra in palavras: print(palavra)

def identifica_palavras(texto): tamanho_palavras = {} palavras_encontradas = [] # Ao mesmo tempo que inicio a função tenho que capturar o retorno, por esse motivo coloca texto = tratar_texto(texto) texto = trata_texto(texto) # Aqui transforma em uma lista de palavras palavras = texto.split() for palavra in palavras: if len(palavra) > 10: tamanho_palavras[palavra] = tamanho_palavras.get(palavra,len(palavra)) palavras_encontradas.append(palavra) return tamanho_palavras,palavras_encontradas def trata_texto(texto): texto = texto.lower() caracteres = ',.:;()*!_-[]{}' for char in caracteres: texto = texto.replace(char,'') return texto

Oi, William! Como vai?

Achei excelente a sua iniciativa de modularizar o código (separar em arquivos) e, principalmente, criar uma função para tratar a pontuação. Isso resolve um problema que o exercício original ignorava: palavras "grudadas" em vírgulas ou pontos contam como letras extras se não forem limpas.

Para deixar o código mais Pythonic (ou seja, seguindo o estilo e filosofia do Python), tenho duas sugestões principais: o uso de List Comprehensions (Compreensão de Listas) e o uso do módulo string para a pontuação.

List Comprehensions:

Em Python, quando queremos criar uma nova lista baseada em uma existente (filtrando ou modificando), evitamos criar uma lista vazia e usar um for com append. Fazemos tudo em uma linha.

No lugar de:

palavras_encontradas = []
for palavra in palavras:
    if len(palavra) > 10:
        palavras_encontradas.append(palavra)

Usamos:

palavras_encontradas = [p for p in palavras if len(p) > 10]

Otimizando a limpeza de texto:

Em vez de iterar caractere por caractere com replace (o que cria uma nova string a cada passada do loop), podemos usar o método translate junto com o módulo string. É mais performático e limpo.

Veja como ficaria o seu identifica.py aplicando essas técnicas:

import string

def identifica_palavras(texto):
    # Passo 1: Limpeza
    # Removemos pontuação de forma direta
    texto = texto.lower()
    tabela_traducao = str.maketrans('', '', string.punctuation)
    texto_limpo = texto.translate(tabela_traducao)
    
    palavras = texto_limpo.split()

    # Passo 2: Filtragem com List Comprehension
    # Cria a lista apenas com as palavras maiores que 10
    palavras_encontradas = [p for p in palavras if len(p) > 10]

    # Passo 3: Dicionário com Dict Comprehension
    # Cria o dicionário {palavra: tamanho} usando a lista já filtrada
    tamanho_palavras = {p: len(p) for p in palavras_encontradas}

    return tamanho_palavras, palavras_encontradas

O que mudou?

string.punctuation: Pega automaticamente todos os símbolos !"#$%&'()*+,-./:;<=>?@[\]^_{|}~, evitando que você precise digitar um por um na variável caracteres.
Dict Comprehension: A linha tamanho_palavras[palavra] = tamanho_palavras.get(...) tinha uma redundância. Como você já sabe que a palavra está ali, basta atribuir len(p) direto. Fizemos isso em uma linha também.

Essa abordagem deixa o código mais limpo e fácil de ler, aproveitando o que a linguagem oferece de melhor.

Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!

[Sugestão] resolução: Identificando palavras mais longas em um texto

Trilhas por carreira

Carreiras de IA

Carreiras de Dados

Carreiras de Cyber

Carreiras de DevOps & Cloud

Carreiras de UX & UI

Carreiras de Mobile & Front-End

Carreiras de Back-End

Carreiras de Negócios

Cursos universitários FIAP

Tópicos relacionados

Conteúdos Alura com o tema