Programando uma calculadora em python

 

Para elevar o nível da sua calculadora, vamos sair do básico e estruturá-la de forma modular. Adicionar a hipotenusa é um ótimo exercício, pois introduz o uso de bibliotecas externas, como a math.

Para calcular a hipotenusa ($c$) de um triângulo retângulo com catetos $a$ e $b$, usamos o Teorema de Pitágoras:

$$c = \sqrt{a^2 + b^2}$$

Aqui está uma versão completa e organizada:

O Código da Calculadora Pro

Python

import math

def soma(a, b): return a + b
def subtrai(a, b): return a - b
def divide(a, b): 
    return a / b if b != 0 else "Erro: Divisão por zero"
def hipotenusa(a, b): 
    return math.hypot(a, b) # Função nativa que faz o cálculo de Pitágoras

def menu():
    print("\n--- CALCULADORA PYTHON ---")
    print("1. Soma (+)")
    print("2. Subtração (-)")
    print("3. Divisão (/)")
    print("4. Hipotenusa (Teorema de Pitágoras)")
    print("0. Sair")

while True:
    menu()
    opcao = input("\nEscolha uma opção: ")

    if opcao == '0':
        print("Saindo...")
        break
    
    if opcao in ['1', '2', '3', '4']:
        try:
            n1 = float(input("Digite o primeiro valor (ou cateto 1): "))
            n2 = float(input("Digite o segundo valor (ou cateto 2): "))

            if opcao == '1':
                print(f"Resultado: {soma(n1, n2)}")
            elif opcao == '2':
                print(f"Resultado: {subtrai(n1, n2)}")
            elif opcao == '3':
                print(f"Resultado: {divide(n1, n2)}")
            elif opcao == '4':
                print(f"A hipotenusa é: {hipotenusa(n1, n2):.2f}")
        except ValueError:
            print("Erro: Digite apenas números válidos.")
    else:
        print("Opção inválida!")

---

Por que usar math.hypot?

Embora você pudesse escrever (a**2 + b**2)**0.5, o Python oferece o math.hypot(a, b) por dois motivos:

1. Precisão: Ele é numericamente mais estável para números muito grandes ou muito pequenos.

2. Legibilidade: Quem lê seu código entende imediatamente que você está lidando com geometria.

Getty Images
Explorar

Próximos Passos

Agora que sua calculadora já resolve problemas de geometria, que tal torná-la ainda mais "completa"?

• Histórico: Podemos criar uma lista para salvar os últimos resultados e mostrá-los ao usuário.

• Interface Gráfica: Podemos usar a biblioteca Tkinter para criar janelas e botões reais.

A seguir um exemplo: 

Excelente! Vamos transformar esse código em um aplicativo de verdade com janelas e botões.

Para isso, usaremos o Tkinter, que já vem instalado com o Python. Ele permite criar interfaces gráficas (GUI) de forma simples.

Calculadora Visual com Tkinter

Este código cria uma interface onde você digita os números e clica no botão da operação desejada.

Python

import tkinter as tk
from tkinter import messagebox
import math

# Funções de Cálculo
def calcular(operacao):
    try:
        n1 = float(entry_n1.get())
        n2 = float(entry_n2.get())
        
        if operacao == "soma":
            res = n1 + n2
        elif operacao == "sub":
            res = n1 - n2
        elif operacao == "div":
            res = n1 / n2 if n2 != 0 else "Erro (Div/0)"
        elif operacao == "hipo":
            res = math.hypot(n1, n2)
        
        label_resultado.config(text=f"Resultado: {res:.2f}" if isinstance(res, float) else res)
    except ValueError:
        messagebox.showerror("Erro", "Por favor, insira números válidos.")

# Configuração da Janela Principal
janela = tk.Tk()
janela.title("Calculadora Pro")
janela.geometry("300x350")

# Entradas de Texto
tk.Label(janela, text="Número 1 / Cateto A:").pack(pady=5)
entry_n1 = tk.Entry(janela)
entry_n1.pack()

tk.Label(janela, text="Número 2 / Cateto B:").pack(pady=5)
entry_n2 = tk.Entry(janela)
entry_n2.pack()

# Botões de Operação
tk.Button(janela, text="Somar (+)", width=20, command=lambda: calcular("soma")).pack(pady=5)
tk.Button(janela, text="Subtrair (-)", width=20, command=lambda: calcular("sub")).pack(pady=5)
tk.Button(janela, text="Dividir (/)", width=20, command=lambda: calcular("div")).pack(pady=5)
tk.Button(janela, text="Hipotenusa (📐)", width=20, bg="lightblue", command=lambda: calcular("hipo")).pack(pady=5)

# Resultado
label_resultado = tk.Label(janela, text="Resultado: ", font=("Arial", 12, "bold"))
label_resultado.pack(pady=20)

janela.mainloop()

---

O que mudou aqui?

1. tk.Entry: São as caixas de texto onde o usuário digita.

2. lambda: Usamos command=lambda: ... nos botões para que a função só execute quando o botão for clicado, passando o nome da operação como argumento.

3. messagebox: Se o usuário digitar uma letra em vez de número, aparece uma janelinha de erro profissional.

4. mainloop(): É o que mantém a janela aberta e "escutando" os cliques.