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

[Sugestão] Calculadora com tratamento de erros

import os

# --- MÓDULOS DE UTILIDADE ---

def limpar_tela():
    """Limpa a tela do terminal dependendo do sistema operacional."""
    os.system('cls' if os.name == 'nt' else 'clear')

def formatar_numero(numero):
    """
    Remove a casa decimal (.0) se o número for inteiro.
    Se for decimal, formata a exibição usando vírgula no lugar do ponto.
    """
    if numero.is_integer():
        return str(int(numero)) # Retorna como texto sem casas decimais
    
    # Converte para texto e troca o ponto americano pela vírgula brasileira
    return str(numero).replace('.', ',')


# --- MÓDULOS DE ENTRADA E LÓGICA ---

def solicitar_numeros():
    """Pede os números e valida, aceitando tanto vírgula quanto ponto."""
    try:
        # Pega o texto digitado e substitui a vírgula por ponto antes de converter
        entrada1 = input("\nDigite o primeiro número: ").replace(',', '.')
        num1 = float(entrada1)
        
        entrada2 = input("Digite o segundo número: ").replace(',', '.')
        num2 = float(entrada2)
        
        return num1, num2, True
    except ValueError:
        print("Erro: Você digitou letras ou caracteres inválidos. Digite apenas números!")
        return None, None, False

def realizar_calculo(num1, num2, operacao):
    """Verifica as regras matemáticas e retorna o resultado."""
    operacoes = {
        '+': lambda x, y: x + y,
        '-': lambda x, y: x - y,
        '*': lambda x, y: x * y,
        '/': lambda x, y: x / y,
    }

    if operacao not in operacoes:
        print("Erro: Operação inválida. Escolha entre +, -, *, /.")
        return None, False

    if operacao == '/' and num2 == 0:
        print("Erro: Divisão por zero não é permitida.")
        return None, False

    resultado = operacoes[operacao](num1, num2)
    return resultado, True


# --- MÓDULO PRINCIPAL (FLUXO DO PROGRAMA) ---

def iniciar_calculadora():
    """Gerencia o menu principal e a contagem de erros."""
    print("=== Calculadora em Python ===")
    erros_validacao = 0 
    
    while True:
        if erros_validacao >= 3:
            print("\nLimite de tentativas excedido. Calculadora encerrada por segurança!")
            break

        num1, num2, sucesso_numeros = solicitar_numeros()
        if not sucesso_numeros:
            erros_validacao += 1
            continue 
        
        operacao = input("Digite a operação desejada (+, -, *, /): ").strip()
        resultado, sucesso_calculo = realizar_calculo(num1, num2, operacao)
        
        if not sucesso_calculo:
            erros_validacao += 1
            continue
            
        erros_validacao = 0
            
        # As variáveis formatadas agora são textos prontas para exibição com vírgula
        n1 = formatar_numero(num1)
        n2 = formatar_numero(num2)
        res = formatar_numero(resultado)
        
        print(f"Resultado: {n1} {operacao} {n2} = {res}")

        continuar = input("\nDeseja realizar outra operação? (sim/s ou nao/n): ").strip().lower()
        if continuar not in ['s', 'sim']:
            print("Calculadora encerrada. Até a próxima!")
            break 
            
        limpar_tela()

# --- EXECUÇÃO ---
iniciar_calculadora()
1 resposta

Fala, Marinaldo! Tudo bom?

Agradeço por compartilhar sua solução no fórum!

Curti demais como explorou o tratamento de erros para garantir entradas válidas com Python, compreendeu perfeitamente a importância da função modular para organizar responsabilidades e utilizou bem o formatar_numero para deixar a saída mais amigável ao usuário.

Algo bem legal para complementar é permitir que o usuário escolha continuar ou não logo após um erro, evitando que o programa encerre de forma abrupta. Assim:

if not sucesso_numeros:
    erros_validacao += 1
    continuar = input("Deseja tentar novamente? (s/n): ").strip().lower()
    if continuar not in ['s', 'sim']:
        print("Calculadora encerrada. Até a próxima!")
        break
    continue

Isso faz com que o fluxo fique mais flexível e o usuário tenha maior controle sobre a execução.

Se quiser aprofundar ainda mais, algumas boas práticas são:

  • Documentação clara: manter docstrings explicativas em cada função.
  • Separação de responsabilidades: dividir entrada, cálculo e saída em módulos distintos.
  • Validação robusta: tratar casos de divisão por zero e entradas inválidas de forma consistente.

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

Alguns materiais podem estar em inglês, mas é possível compreendê-los usando o recurso de tradução de páginas do próprio navegador.

Ah, uma pergunta: você prefere manter a calculadora no terminal ou pensa em evoluir para uma interface gráfica futuramente?

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!