Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

1
resposta

Contador de caractere

Boa noite,

Segue o código feito para atividade

# Receba uma palavra e exiba a quantidade de caracteres
import re


def contar_caracteres(texto):
    return len(texto)


def contar_espacos(texto):
    return sum(1 for c in texto if c.isspace())


def contar_palavras(texto):
    return len(texto.split())


def formatar(qtd, singular, plural):
    return f'{qtd} {singular if qtd == 1 else plural}'


def perguntar_sim_nao(pergunta):
    while True:
        resposta = input(pergunta).strip().lower()
        if resposta in ('s', 'sim'):
            return True
        if resposta in ('n', 'nao', 'não'):
            return False
        print('Resposta inválida! Digite "s" para sim ou "n" para não.')


def pedir_texto(mensagem='Digite uma palavra ou frase: '):
    while True:
        texto = input(mensagem)
        limpo = texto.strip()

        if not limpo:
            print('O texto não pode ficar vazio.')
        elif not any(c.isspace() for c in limpo):
            # Palavra única: não aceita espaços nas pontas
            if texto != limpo:
                print('Uma palavra não pode ter espaços. Remova-os e tente de novo.')
            else:
                return limpo, False
        else:
            # Frase: os espaços entre as palavras são aceitos
            return limpo, True


def encontrar_espacos_duplos(texto):
    return list(re.finditer(r'\s{2,}', texto))


def corrigir_espacos_duplos(texto):
    return re.sub(r'\s{2,}', ' ', texto)


def mostrar_espacos_duplos(texto, ocorrencias):
    print('\nAtenção: encontrei espaços seguidos na sua frase:')
    print(f'  {texto}')
    marcador = [' '] * len(texto)
    for o in ocorrencias:
        for i in range(o.start(), o.end()):
            marcador[i] = '^'
    print(f'  {"".join(marcador)}')

    for o in ocorrencias:
        qtd = o.end() - o.start()
        print(f'  -> {qtd} espaços seguidos, nas posições {o.start() + 1} a {o.end()}')
    print()


def obter_texto():
    mensagem = 'Digite uma palavra ou frase: '
    corrigido = False

    while True:
        texto, eh_frase = pedir_texto(mensagem)
        ocorrencias = encontrar_espacos_duplos(texto) if eh_frase else []

        if not ocorrencias:
            return texto, eh_frase, corrigido

        mostrar_espacos_duplos(texto, ocorrencias)
        if perguntar_sim_nao('Os espaços seguidos estão corretos? (s/n): '):
            return texto, eh_frase, corrigido

        corrigido = True
        if perguntar_sim_nao('Deseja que eu corrija automaticamente? (s/n): '):
            texto = corrigir_espacos_duplos(texto)
            print(f'\nTexto corrigido: {texto}')
            return texto, True, corrigido

        mensagem = 'Reescreva o texto com o ajuste: '


def main():
    while True:
        texto, eh_frase, corrigido = obter_texto()
        total = contar_caracteres(texto)

        if eh_frase:
            espacos = contar_espacos(texto)
            palavras = contar_palavras(texto)
            titulo = 'Contagem do texto corrigido' if corrigido else 'Contagem'
            print(f'\n{titulo} de "{texto}":')
            print(f'  - {formatar(total, "caractere", "caracteres")} (contando os espaços)')
            print(f'  - {formatar(total - espacos, "caractere", "caracteres")} (sem contar os espaços)')
            print(f'  - {formatar(espacos, "espaço", "espaços")}')
            print(f'  - {formatar(palavras, "palavra", "palavras")}')
        else:
            print(f'\nA palavra "{texto}" tem {formatar(total, "caractere", "caracteres")}!')

        if not perguntar_sim_nao('\nDeseja testar outro texto? (s/n): '):
            print('Programa encerrado. Até mais!')
            break


main()
1 resposta

Fala, Laura! Tudo bom?

Agradeço por trazer sua solução para o fórum!

Curti demais como trabalhou a biblioteca re para detectar e corrigir espaços duplicados em Python, entendeu perfeitamente a importância da validação de entrada para evitar textos vazios ou inválidos e usou bem a função formatar para deixar as mensagens mais amigáveis e dinâmicas.

Algo bem legal para complementar é simplificar o cálculo de palavras e espaços usando expressões regulares, deixando o código mais enxuto. Dessa maneira:

import re

def contar_palavras(texto):
    return len(re.findall(r'\b\w+\b', texto))

def contar_espacos(texto):
    return len(re.findall(r'\s', texto))

Isso faz com que a contagem seja mais precisa e aproveite melhor os recursos da biblioteca re.

E algumas boas práticas que você pode adotar são:

  • Legibilidade: manter funções curtas e com nomes claros.
  • Exploração: adicionar testes automatizados para validar diferentes tipos de entrada.
  • Consistência: separar responsabilidades (entrada, validação e contagem) em funções distintas.

Continue postando as suas soluções! Além de ganhar pontos de XP na plataforma, você pode ajudar outros estudantes no fórum.

Ah, uma pergunta: você prefere evoluir esse programa para incluir relatórios mais completos (como porcentagem de espaços e palavras) ou manter apenas a contagem para focar na clareza?

Fico à disposição! E se precisar, conte sempre com o apoio do fórum.

Abraço e bons estudos!

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