#19 - Como criar sua Primeira Calculadora com Tkinter, descomplicando o mundo das GUIs em Python

🌌 Projeto CodeVerse Python - #17/2025

👋 Fala, Galera Dev!

Se você já explorou o universo Python comigo, dominou a lógica de programação, destrinchou operadores, mergulhou em listas, tomou decisões com if, deu voltas com for e while, criou funções mágicas, instalou pacotes como um mestre Jedi e até colocou as mãos na biblioteca Tkinter… então parabéns: você está pronto para o próximo nível! 🚀

Sim, vamos sair do modo terminal e ativar o modo GUI (Graphical User Interface), com Tkinter como nossa armadura Mark II — mais bonita, completa e pronta para brilhar como uma interface de verdade.

Neste artigo, vamos fazer sua transição do terminal para o mundo visual com estilo — construindo sua primeira calculadora gráfica com Python e Tkinter, nossa armadura Mark II. 💻✨

Aqui, você vai:

• 🔍 Revisar rapidamente os conceitos essenciais que usaremos no projeto;
• 🧱 Entender passo a passo como montar a estrutura da interface gráfica com Tkinter;
• 💡 Aprender a lógica por trás do funcionamento da calculadora (do clique do botão ao resultado na tela);
• 🎯 Ver o código completo, comentado e explicado para que você possa adaptar e evoluir sua própria versão.

Tudo isso apresentado de forma simples, direta, e com aquele toque especial para que você realmente aprenda fazendo. Ao final, você não só terá uma calculadora funcional, mas também terá dado seu primeiro grande passo no desenvolvimento de interfaces gráficas em Python!

No artigo (#18), você conhecemos o Tkinter, nossa “Joia do Infinito” para criar interfaces gráficas. Agora chegou o momento de unir todos esses poderes para construir nossa primeira Calculadora Visual com Python. 🧠⚡

Bora transformar código em experiência visual? 🎨🐍

🧰 O que vamos usar?

• Python (óbvio, né?)
• Tkinter (para criar a interface)
• Funções (organizar o código como um plano do Tony Stark)
• Operadores (os golpes especiais da nossa calculadora)
• Eventos e Widgets (botões, visor, layout... o time dos Vingadores do Tkinter)

_____________________________________________________________________________________________________________________________________________

🛠️ Aprofundando em como usar a biblioteca TKinter:

📌 tk.Entry – O que é?

O tk.Entry é um widget da biblioteca Tkinter usado para entrada de texto de uma única linha. Nesse caso, é utilizado como visor de entrada e saída da calculadora.

visor = tk.Entry(
  janela,                         # Parâmetro master (widget pai)
  font=("Arial", 20),            # Define a fonte e o tamanho do texto
  borderwidth=5,                 # Largura da borda
  relief="ridge",                # Tipo de borda (estilo 3D)
  justify="right"                # Alinhamento do texto (direita)
)
visor.grid(
  row=0, column=0,               # Posição na grade
  columnspan=4,                  # Ocupar 4 colunas (de 0 a 3)
  padx=10, pady=20,              # Espaço externo (margem horizontal e vertical)
  ipady=10                       # Espaço interno vertical (altura da linha)
)

🔍 Explicação das Propriedades

Outras Propriedades Possíveis

Você pode personalizar ainda mais:

• bg="cor" → muda a cor de fundo
• fg="cor" → muda a cor do texto
• state="readonly" → impede edição (útil se for apenas visor de saída)
• show="*" → oculta os caracteres digitados (como senha)
• width=largura → define o número de caracteres visíveis

🧠 O que é tk.END?

tk.END é uma constante do módulo Tkinter que representa o fim do conteúdo de um widget de entrada (Entry, Text, etc.).

Em outras palavras, ele é usado para indicar "até o final do texto".

💡 Aplicações comuns:

🔸 Apagar o conteúdo do visor:

visor.delete(0, tk.END)

• Significa: Delete o texto do índice 0 até o fim.
• 0: posição inicial (primeiro caractere).
• tk.END: posição final (último caractere).

Essa linha limpa todo o conteúdo do Entry.

🔸 Inserir conteúdo no final:

visor.insert(tk.END, "123")

• Significa: Insere o texto "123" no final do que já está no visor.
• Útil quando você quer adicionar sem apagar o que já está escrito.

📌 Onde isso aparece no seu código?

visor.delete(0, tk.END)  # limpa o visor
visor.insert(0, str(resultado))  # insere o novo valor começando do início

Você também poderia usar tk.END no segundo argumento do insert se quisesse adicionar ao final em vez de sobrescrever:

visor.insert(tk.END, str(resultado))

🤷 O que é a função eval()?

A função eval() é usada dentro da função calcular() para avaliar a expressão matemática digitada pelo usuário no visor da calculadora.

A função eval() do Python interpreta uma string como código Python válido e executa essa expressão. No contexto da calculadora:

• visor.get() retorna o conteúdo digitado no visor, por exemplo: "2+3*5".
• eval("2+3*5") calcula essa expressão e retorna 17.

Riscos do eval()

Apesar de prática, eval() pode ser perigosa, pois executa qualquer código Python, inclusive comandos maliciosos se o usuário tiver liberdade para digitar qualquer coisa. Por exemplo:

eval("__import__('os').system('rm -rf /')")

Esse tipo de código poderia apagar arquivos, por isso eval() só deve ser usado em contextos totalmente controlados — como esse projeto simples local.

Como é uma calculadora local e controlada, o uso de eval() é aceitável, mas em projetos maiores ou online, o ideal seria usar um parser matemático, mas vamos usar a função eval() para deixar nosso projeto mais simples por enquanto.

_____________________________________________________________________________________________________________________________________________

🛠️ Montando a Calculadora:

A biblioteca Tkinter é como se fosse a primeira armadura do Homem de Ferro: simples, mas funcional. Com ela, conseguimos criar janelas, botões, visores, tudo para deixar nosso programa mais “usável” para o público. E aqui está a calculadora completa:

🛠️ O que essa calculadora vai ter?

• Um visor para mostrar os números e resultados
• Botões de 0 a 9
• Os 4 operadores principais: +, -, *, /
• Botão C para limpar o visor
• Botão = para calcular o resultado

import tkinter as tk

# Criação da janela principal
janela = tk.Tk()
janela.title("Calculadora CodeVerse 2025")
janela.geometry("300x400")
janela.resizable(False, False)

# Visor de entrada e saída
visor = tk.Entry(janela, font=("Arial", 20), borderwidth=5, relief="ridge", justify="right")
visor.grid(row=0, column=0, columnspan=4, padx=10, pady=20, ipady=10)

# Função para inserir número ou operador no visor
def clicar(valor):
  visor.insert(tk.END, str(valor))

# Função para limpar o visor
def limpar():
  visor.delete(0, tk.END)

# Função para calcular o resultado
def calcular():
  try:
      resultado = eval(visor.get())
      visor.delete(0, tk.END)
      visor.insert(0, str(resultado))
  except:
      visor.delete(0, tk.END)
      visor.insert(0, "Erro")

# Lista com os botões e suas posições
botoes = [
  ("7", 1, 0), ("8", 1, 1), ("9", 1, 2), ("/", 1, 3),
  ("4", 2, 0), ("5", 2, 1), ("6", 2, 2), ("*", 2, 3),
  ("1", 3, 0), ("2", 3, 1), ("3", 3, 2), ("-", 3, 3),
  ("0", 4, 0), (".", 4, 1), ("C", 4, 2), ("+", 4, 3),
  ("=", 5, 0, 4)
]

# Criação dos botões na janela
for botao in botoes:
  texto = botao[0]
  linha = botao[1]
  coluna = botao[2]
  largura = botao[3] if len(botao) == 4 else 1

  if texto == "=":
      btn = tk.Button(janela, text=texto, width=33, height=2, bg="green", fg="white", command=calcular)
  elif texto == "C":
      btn = tk.Button(janela, text=texto, width=5, height=2, bg="red", fg="white", command=limpar)
  else:
      btn = tk.Button(janela, text=texto, width=5, height=2, command=lambda t=texto: clicar(t))

  btn.grid(row=linha, column=coluna, columnspan=largura, padx=5, pady=5)

janela.mainloop()

🧩 Explicando o funcionamento

🔹 visor = tk.Entry(...)

Esse é o campo onde os números e resultados aparecem. Ele funciona como a “tela” da calculadora.

🔹 def clicar(valor):

Toda vez que clicamos num botão, essa função adiciona o número ou operador no visor. Por exemplo: clicou 7, ele mostra “7” na tela.

🔹 def limpar():

Essa função limpa tudo que estiver no visor — como apertar o botão “C” da calculadora normal.

🔹 def calcular():

Aqui está o cérebro da operação! Quando clicamos =, essa função lê o que está no visor, resolve a conta com eval() e mostra o resultado. Se houver erro (por exemplo, digitar 5++5), mostra “Erro”.

📐 Como os botões são posicionados?

Usamos o método grid() do Tkinter para montar os botões como se fosse uma tabela invisível.

Cada botão tem:

• row: a linha onde ele vai aparecer
• column: a coluna
• columnspan: quantas colunas ele ocupa (usamos só no botão = que ocupa a linha inteira)

_____________________________________________________________________________________________________________________________________________

🤔 Se não entendeu... Vamos ao passo a passo:

Se você está começando sua jornada com Python e não entendeu tudo explicado acima, calma, vamso começar do zero e explicar item a item. Vamos linha por linha para que você entenda exatamente o que está acontecendo no código da Calculadora CodeVerse 2025!

🖼️ Criação da Janela Principal

# Importa a biblioteca tkinter e a apelida como tk, para facilitar a escrita do código. Ela é usada para criar a interface gráfica (a janela, os botões, etc).
import tkinter as tk
# Cria a janela principal da aplicação. É a "base" da interface.
janela = tk.Tk()
# Define o título que vai aparecer na barra da janela.
janela.title("Calculadora CodeVerse 2025")
# Define o tamanho da janela: 300 pixels de largura e 400 de altura.
janela.geometry("300x400")
# Impede que o usuário redimensione a janela (ela terá tamanho fixo).
janela.resizable(False, False)

🔢 Campo do Visor (entrada e saída de dados)

# Cria um campo de entrada de texto (o visor da calculadora), com fonte grande, bordas em relevo, e texto alinhado à direita.
visor = tk.Entry(janela, font=("Arial", 20), borderwidth=5, relief="ridge", justify="right")
# Coloca o visor na linha 0 e coluna 0 da grade da janela, ocupando 4 colunas (para cobrir a largura inteira da calculadora). Também adiciona margens internas e externas.
visor.grid(row=0, column=0, columnspan=4, padx=10, pady=20, ipady=10)

🧠 Funções da Calculadora

# 1. Inserir valores no visor: Sempre que um número ou operador for clicado, essa função insere o valor no final do visor.
def clicar(valor):
  visor.insert(tk.END, str(valor))
# 2. Limpar o visor: Apaga tudo que está escrito no visor, começando do índice 0 até o final (tk.END).
def limpar():
  visor.delete(0, tk.END)
# 3. Calcular o resultado:
def calcular():
  try:
      resultado = eval(visor.get())
      visor.delete(0, tk.END)
      visor.insert(0, str(resultado))
  except:
      visor.delete(0, tk.END)
      visor.insert(0, "Erro")

• visor.get() pega o conteúdo digitado.
• eval() avalia a expressão como se fosse um cálculo Python.
• Se tudo der certo, apaga o visor e insere o resultado.
• Se der erro (ex: expressão inválida), exibe "Erro".

🔘 Criação dos Botões

Essa lista define cada botão da calculadora:

• Cada tupla representa: (texto no botão, linha, coluna, [largura opcional])
• O botão "=" tem columnspan=4 (ocupa toda a linha inferior).

botoes = [
  ("7", 1, 0), ("8", 1, 1), ("9", 1, 2), ("/", 1, 3),
  ("4", 2, 0), ("5", 2, 1), ("6", 2, 2), ("*", 2, 3),
  ("1", 3, 0), ("2", 3, 1), ("3", 3, 2), ("-", 3, 3),
  ("0", 4, 0), (".", 4, 1), ("C", 4, 2), ("+", 4, 3),
  ("=", 5, 0, 4)
]

🧱 Posicionamento e Comportamento dos Botões

Esse for percorre todos os botões da lista. Ele separa o texto, linha, coluna e (se existir) a largura personalizada.

for botao in botoes:
  texto = botao[0]
  linha = botao[1]
  coluna = botao[2]
  largura = botao[3] if len(botao) == 4 else 1

🟢 🔴 ⚪ Criação dos Botões com Comportamentos Diferentes

# Botão =: larga o suficiente para ocupar toda a linha. Chama a função calcular.
if texto == "=":
  btn = tk.Button(janela, text=texto, width=33, height=2, bg="green", fg="white", command=calcular)

# Botão C: limpa o visor.
elif texto == "C":
  btn = tk.Button(janela, text=texto, width=5, height=2, bg="red", fg="white", command=limpar)

# Demais botões (números e operadores) chamam clicar(valor) ao serem clicados.
else:
  btn = tk.Button(janela, text=texto, width=5, height=2, command=lambda t=texto: clicar(t))

📌 Posicionamento na Grade da Interface

Cada botão é posicionado na linha e coluna definidas, com a largura especificada (columnspan) e espaçamento entre os botões (padx e pady).

btn.grid(row=linha, column=coluna, columnspan=largura, padx=5, pady=5)

🔁 Execução da Interface

janela.mainloop()

_____________________________________________________________________________________________________________________________________________

🔚 Concluindo...

Construir essa calculadora visual com Tkinter não foi apenas um exercício técnico — foi como montar sua própria armadura Mark II, onde cada parte do código representa um componente essencial para o funcionamento da interface gráfica.

Com esse projeto, aprendemos diversos temas fundamentais como estruturas de decisão, funções, operadores, manipulação de eventos e, claro, o uso prático da biblioteca Tkinter. Tudo isso dentro de uma aplicação útil e visual, que vai muito além do terminal.

Agora você tem nas mãos um exemplo completo de como transformar código em algo interativo e funcional. Essa calculadora é apenas o inicio de um mundo de interfaces visuais com python, desde criação de palicativos com botões, janelas etc. com aquela cara de aplicativo do windows.

Obs.: Deixei um pequeno erro proposital no código que limita o tamanho da calculadora, deixando-a menor do que o necessário, mas ele é bem fácil de resolver. rs

✅🚀👨💻 Projeto concluído com sucesso!

👉 Se curtiu o projeto, dá uma olhada no repositório completo lá no GitHub: CodeVersePython_2025 📢 ou se quiser trocar uma ideia, acompanhar outros projetos ou bater um papo sobre tecnologia, me chama lá no LinkedIn: linkedin.com/in/carlos-cgs