Construa a função freqPalavras que receba uma string e retorne um dicionário onde cada palavra dessa string é uma chave e que tenha como valor o número de vezes que a palavra ocorre.
Por exemplo:
  • freqpalavras (“dinheiro é dinheiro e vice versa”)
  • retorna o dicionário: {“dinheiro”:2, “é”: 1 , “e”: 1 , “vice”: 1 , “versa”:1}

Passo 1

O que o enunciado pede e quais dados temos:
  • Função a construir: freqPalavras.
  • Entrada: uma única string (texto).
  • Saída esperada: um dicionário em que cada palavra encontrada na string é uma chave e o valor é o número de ocorrências dessa palavra.
  • Exemplo dado:
    • Entrada: "dinheiro é dinheiro e vice versa"
    • Saída esperada: {"dinheiro": 2, "é": 1, "e": 1, "vice": 1, "versa": 1}

Passo 2

Decisões e problemas que precisamos resolver antes de codificar (coisas que aparecem muito em prova):
  • Diferenciar maiúsculas/minúsculas? Vamos normalizar para minúsculas com lower() para que Dinheiro e dinheiro sejam a mesma palavra.
  • Pontuação e espaços extras: precisamos separar palavras mesmo se tiver vírgula, ponto, múltiplos espaços etc. Por exemplo "olá, mundo!" deve dar {"olá":1, "mundo":1}.
  • Caracteres acentuados (como é) devem ser tratados como parte da palavra. Em Python 3 isso é possível com expressões regulares Unicode.
  • Números: se aparecerem, podemos contar também ("123 teste 123""123":2, "teste":1). Isso é aceitável para a maioria dos exercícios; se não quiser números, é só mudar o padrão.

Passo 3

Escolha do método (explicando por que):
  • Método escolhido para extrair palavras: usar expressão regular para pegar “sequências de caracteres de palavra” (ou seja, letras acentuadas, números e underscores). Em Python usamos re.findall(r'\w+', texto, flags=re.UNICODE). Isso retorna uma lista com as palavras.
    • Explicação do padrão \w+: \w significa “caractere de palavra” (letras, dígitos e underscore). O + significa “um ou mais” desses caracteres, então capturamos blocos contínuos de caracteres de palavra.
    • flags=re.UNICODE garante comportamento Unicode (em Python 3 já é padrão, mas deixa explícito).
  • Contagem: usar um dicionário Python e, para cada palavra, incrementar seu contador. Técnica simples e direta para prova: freq[p] = freq.get(p, 0) + 1.
  • Por que não usar str.split() direto? split() separa apenas por espaços e não remove pontuação (por exemplo "olá, mundo" resultaria em ["olá,", "mundo"] com a vírgula presa). Por isso preferimos regex para extrair “apenas” as palavras.

Passo 4

Algoritmo passo a passo (pseudocódigo que dá pra escrever rápido na prova):
  1. Receber a string texto.
  2. Converter para minúsculas: texto_lower = texto.lower().
  3. Extrair palavras com regex: palavras = re.findall(r'\w+', texto_lower, flags=re.UNICODE).
  4. Criar dicionário vazio freq = {}.
  5. Para cada p em palavras:
    • Se p já estiver em freq, incrementar (freq[p] += 1).
    • Caso contrário, inicializar (freq[p] = 1).
  6. Retornar freq.

Passo 5

Vou te explicar detalhadamente como funciona a contagem com o exemplo do enunciado, para você fazer igual na prova sem bug:
  • Entrada: "dinheiro é dinheiro e vice versa"
  • Normalização para minúsculas (aqui já está em minúsculas): "dinheiro é dinheiro e vice versa".
  • Extração de palavras com re.findall(r'\w+', ...) — resultado da lista palavras:
    • ["dinheiro", "é", "dinheiro", "e", "vice", "versa"]
  • Agora percorremos essa lista e atualizamos o dicionário freq passo a passo:
    • começo: freq = {}
    • ver "dinheiro": não existe → freq = {"dinheiro": 1}
    • ver "é": não existe → freq = {"dinheiro": 1, "é": 1}
    • ver "dinheiro" de novo: existe com 1 → incrementa → freq = {"dinheiro": 2, "é": 1}
    • ver "e": não existe → freq = {"dinheiro": 2, "é": 1, "e": 1}
    • ver "vice": não existe → freq = {"dinheiro": 2, "é": 1, "e": 1, "vice": 1}
    • ver "versa": não existe → freq = {"dinheiro": 2, "é": 1, "e": 1, "vice": 1, "versa": 1}
  • Resultado final: exatamente o dicionário que o enunciado pediu.

Passo 6

Dicas rápidas de implementação e variações para a prova:
  • Se não quiser contar números, troque o padrão por algo que aceite apenas letras (ex.: re.findall(r'[^\W\d_]+', ...) captura sequências de letras, exclui dígitos e underscore).
  • Se quiser preservar apóstrofos internos em palavras (ex.: “it’s”), o padrão precisa ser ajustado (mais trabalho, só faça se pedirem).
  • Complexidade: extração com regex é O(n) e a contagem também é O(n) onde n é o tamanho do texto — isso é rápido o suficiente para provas/entradas típicas.
  • Teste sempre com casos borda: string vazia ""{}, somente pontuação "!!!"{}, múltiplos espaços "a a"{"a":2}.

Passo 7

Animação final: respira fundo — com esse passo a passo você sabe exatamente o que fazer na prova: normalizar, extrair palavras com regex, e contar com um dicionário. Bora codar rápido e testar com o exemplo para ganhar tempo!

Resposta

import re

def freqPalavras(texto):
    """
    Recebe uma string 'texto' e retorna um dicionário com a frequência de cada palavra.
    Normaliza para minúsculas e considera palavras formadas por caracteres de palavra Unicode.
    """
    palavras = re.findall(r'\w+', texto.lower(), flags=re.UNICODE)
    freq = {}
    for p in palavras:
        freq[p] = freq.get(p, 0) + 1
    return freq

Exercícios relacionados