O Tkinter é a biblioteca padrão do Python para criação de interfaces gráficas (GUI). Presente desde as primeiras versões da linguagem, o Tkinter permite transformar scripts de console em aplicações visuais completas com janelas, botões, campos de texto, menus e muito mais. Se você deseja criar programas que pessoas reais possam usar sem precisar abrir um terminal, o Tkinter é o caminho mais direto e acessível.
Neste guia completo, você aprenderá desde a criação da primeira janela até técnicas avançadas de layout, manipulação de eventos e desenvolvimento de aplicações desktop completas. Se você ainda está aprendendo os fundamentos da linguagem, confira nosso guia completo para iniciantes em Python antes de prosseguir.
O Que é o Tkinter?
Tkinter é um binding Python para o toolkit gráfico Tcl/Tk, desenvolvido por John Ousterhout no final dos anos 80. O nome "Tkinter" vem da contração de "Tk interface". Por ser parte da biblioteca padrão do Python, o Tkinter está disponível em qualquer instalação oficial da linguagem, sem necessidade de instalar pacotes adicionais — o que o torna a escolha mais prática para começar no desenvolvimento de interfaces gráficas.
O Tkinter oferece uma ampla variedade de widgets (componentes visuais) como botões, rótulos, caixas de texto, listas, barras de progresso, canvas para desenho personalizado e muito mais. A biblioteca também inclui suporte a diálogos nativos (abrir arquivos, escolher cores, mensagens), menus, atalhos de teclado e eventos do mouse.
De acordo com a documentação oficial do Python, o Tkinter é a forma mais simples e rápida de criar aplicações GUI na linguagem, sendo amplamente utilizado em ferramentas internas, protótipos e até em aplicações de produção de pequeno e médio porte.
Instalação e Configuração
A melhor notícia sobre o Tkinter é que ele já vem instalado com o Python. Para verificar se o Tkinter está disponível no seu ambiente, execute o seguinte comando no terminal:
python -m tkinterSe tudo estiver correto, uma pequena janela com informações sobre o Tkinter será exibida. Caso receba um erro informando que o módulo não foi encontrado, pode ser necessário instalá-lo separadamente. No Ubuntu e Debian, por exemplo, use:
sudo apt-get install python3-tkNo Windows e macOS, o Tkinter já vem incluso no instalador oficial do Python disponível em python.org. Após confirmar que o módulo está funcionando, você está pronto para criar sua primeira interface gráfica.
Sua Primeira Janela com Tkinter
Vamos criar o clássico "Olá, Mundo!" em versão gráfica. O código abaixo cria uma janela com um título e um rótulo centralizado:
import tkinter as tk
janela = tk.Tk()
janela.title("Minha Primeira Janela")
janela.geometry("400x300")
rotulo = tk.Label(janela, text="Olá, Mundo!")
rotulo.pack()
janela.mainloop()
Vamos entender cada parte do código:
- import tkinter as tk: Importa o módulo com o alias
tk, prática recomendada para evitar conflitos de nomes. - tk.Tk(): Cria a janela principal (raiz) da aplicação. Toda aplicação Tkinter precisa de uma instância de
Tk. - janela.title(): Define o título exibido na barra de título da janela.
- janela.geometry(): Define o tamanho inicial da janela no formato "largura x altura".
- tk.Label(): Cria um widget de rótulo (texto estático). O primeiro argumento é o pai (a janela que conterá o widget).
- .pack(): Gerencia o posicionamento do widget na janela usando o gerenciador de layout
pack. - janela.mainloop(): Inicia o loop principal de eventos da aplicação. Sem essa linha, a janela apareceria e fecharia instantaneamente.
Ao executar o código, você verá uma janela de 400x300 pixels com o texto "Olá, Mundo!" centralizado. Parabéns, você acaba de criar sua primeira GUI com Python!
Widgets Essenciais do Tkinter
O Tkinter oferece dezenas de widgets prontos para uso. Conhecer os principais é fundamental para construir qualquer aplicação gráfica. Abaixo estão os widgets mais utilizados no dia a dia:
Label (Rótulo)
O Label exibe texto ou imagens estáticas. É um dos widgets mais simples e versáteis:
rotulo = tk.Label(janela, text="Texto qualquer", font=("Arial", 14))
rotulo.pack()O parâmetro font aceita uma tupla com o nome da fonte e o tamanho. Você também pode usar fg (foreground) para cor do texto e bg (background) para cor de fundo.
Button (Botão)
O Button executa uma função quando clicado. O parâmetro command recebe a função callback:
def ao_clicar():
print("Botão clicado!")
botao = tk.Button(janela, text="Clique Aqui", command=ao_clicar)
botao.pack()
O Tkinter também permite configurar a aparência do botão com width, height, bg, fg e relief (estilo da borda).
Entry (Campo de Texto)
O Entry permite que o usuário insira uma linha de texto. Para recuperar o valor digitado, use o método .get():
entrada = tk.Entry(janela, width=40)
entrada.pack()
def mostrar_texto():
print(entrada.get())
tk.Button(janela, text="Mostrar", command=mostrar_texto).pack()
O widget Entry aceita parâmetros como show="*" para campos de senha e state="disabled" para desabilitar a edição.
Text (Texto Multilinha)
Diferente do Entry, o Text permite múltiplas linhas e formatação rica:
texto = tk.Text(janela, height=10, width=50)
texto.pack()
texto.insert("1.0", "Digite seu texto aqui...")O método .insert() recebe um índice no formato "linha.coluna". "1.0" significa linha 1, coluna 0 (início). Para recuperar todo o conteúdo, use texto.get("1.0", tk.END).
Frame (Contêiner)
O Frame é um widget invisível usado para agrupar outros widgets. Ele é essencial para organizar layouts complexos:
frame = tk.Frame(janela, relief="solid", borderwidth=2)
frame.pack(padx=10, pady=10)
botao1 = tk.Button(frame, text="Botão 1")
botao1.pack(side="left")
botao2 = tk.Button(frame, text="Botão 2")
botao2.pack(side="left")
O parâmetro side no pack() define a direção de empilhamento: "left", "right", "top" (padrão) ou "bottom".
Gerenciadores de Layout
O posicionamento dos widgets é controlado por gerenciadores de layout (geometry managers). O Tkinter oferece três gerenciadores principais:
pack
O gerenciador pack organiza os widgets em blocos, empilhando-os sequencialmente. É o mais simples e recomendado para layouts lineares:
tk.Label(janela, text="Topo").pack(side="top", fill="x")
tk.Label(janela, text="Esquerda").pack(side="left")
tk.Label(janela, text="Direita").pack(side="right")
tk.Label(janela, text="Base").pack(side="bottom", fill="x")Parâmetros úteis do pack: fill (expandir no eixo x/y), expand (ocupar espaço extra), padx/pady (espaçamento externo), ipadx/ipady (espaçamento interno).
grid
O gerenciador grid organiza os widgets em linhas e colunas, similar a uma planilha. É ideal para formulários e painéis organizados em grade:
tk.Label(janela, text="Nome:").grid(row=0, column=0, sticky="e")
tk.Entry(janela).grid(row=0, column=1, padx=5, pady=5)
tk.Label(janela, text="Email:").grid(row=1, column=0, sticky="e")
tk.Entry(janela).grid(row=1, column=1, padx=5, pady=5)
tk.Button(janela, text="Enviar").grid(row=2, column=0, columnspan=2)
O parâmetro sticky alinha o widget dentro da célula usando pontos cardeais (n, s, e, w). columnspan e rowspan permitem que um widget ocupe múltiplas células.
place
O gerenciador place posiciona os widgets em coordenadas absolutas ou relativas. Use com moderação, pois não se adapta bem a redimensionamentos:
tk.Label(janela, text="Absoluto").place(x=50, y=100)
tk.Label(janela, text="Relativo").place(relx=0.5, rely=0.5, anchor="center")Segundo o tutorial oficial do TkDocs, o grid é o gerenciador mais versátil para a maioria das aplicações, enquanto o pack é excelente para layouts simples e sequenciais.
Eventos e Callbacks
O Tkinter é orientado a eventos. Toda interação do usuário — cliques, teclas pressionadas, movimentos do mouse — gera um evento que pode ser tratado por uma função callback.
Eventos de Mouse
def clique(evento):
print(f"Clique em ({evento.x}, {evento.y})")
janela.bind("", clique) # Botão esquerdo
janela.bind("", clique) # Botão direito
janela.bind("", clique) # Duplo clique
janela.bind("", clique) # Movimento do mouse
Eventos de Teclado
def tecla_pressionada(evento):
print(f"Tecla: {evento.keysym} (código: {evento.keycode})")
janela.bind("", tecla_pressionada)
janela.bind("", lambda e: print("Enter pressionado"))
janela.bind("", lambda e: janela.destroy())
O parâmetro evento (ou event) é um objeto que contém informações sobre o evento ocorrido: posição do mouse (x, y), tecla pressionada (keysym, keycode), widget de origem (widget), entre outros.
Para associar eventos a widgets específicos, use o método .bind() diretamente no widget. Para eventos globais, use o método bind_all() ou bind_class(). A documentação oficial sobre eventos do Tkinter lista todos os sequências de eventos disponíveis.
Janelas e Diálogos
Aplicações reais frequentemente precisam de múltiplas janelas e diálogos nativos. O Tkinter oferece suporte completo a esses recursos.
Criando Novas Janelas (Toplevel)
def abrir_janela():
nova = tk.Toplevel(janela)
nova.title("Janela Secundária")
nova.geometry("300x200")
tk.Label(nova, text="Esta é uma nova janela").pack()
tk.Button(janela, text="Abrir Janela", command=abrir_janela).pack()
O widget Toplevel cria uma nova janela independente. Diferente da janela principal Tk, você pode criar quantos Toplevel desejar.
Diálogos Nativos
O módulo tkinter.messagebox fornece diálogos prontos para mensagens, alertas e confirmações:
from tkinter import messagebox
def confirmar_saida():
if messagebox.askyesno("Confirmação", "Deseja realmente sair?"):
janela.destroy()
messagebox.showinfo("Info", "Operação concluída!")
messagebox.showwarning("Aviso", "Arquivo não encontrado.")
messagebox.showerror("Erro", "Falha na conexão.")
O módulo tkinter.filedialog oferece diálogos para seleção de arquivos e diretórios:
from tkinter import filedialog
arquivo = filedialog.askopenfilename(title="Selecione um arquivo")
pasta = filedialog.askdirectory(title="Selecione uma pasta")
caminho = filedialog.asksaveasfilename(title="Salvar como")
Esses diálogos são nativos do sistema operacional, garantindo integração visual com o ambiente do usuário. Consulte a documentação do messagebox e a documentação do filedialog para mais opções.
Aplicação Completa: Gerenciador de Tarefas
Vamos consolidar o conhecimento construindo uma aplicação funcional: um gerenciador de tarefas (to-do list) com interface gráfica.
import tkinter as tk
from tkinter import messagebox
def adicionar_tarefa():
tarefa = entrada.get().strip()
if tarefa:
lista_tarefas.insert(tk.END, tarefa)
entrada.delete(0, tk.END)
else:
messagebox.showwarning("Aviso", "Digite uma tarefa!")
def remover_tarefa():
try:
indice = lista_tarefas.curselection()[0]
lista_tarefas.delete(indice)
except IndexError:
messagebox.showwarning("Aviso", "Selecione uma tarefa!")
def limpar_todas():
if messagebox.askyesno("Confirmar", "Limpar todas as tarefas?"):
lista_tarefas.delete(0, tk.END)
janela = tk.Tk()
janela.title("Gerenciador de Tarefas")
janela.geometry("400x450")
frame_entrada = tk.Frame(janela)
frame_entrada.pack(pady=10)
entrada = tk.Entry(frame_entrada, width=35)
entrada.pack(side="left", padx=5)
entrada.bind("", lambda e: adicionar_tarefa())
btn_adicionar = tk.Button(frame_entrada, text="Adicionar", command=adicionar_tarefa)
btn_adicionar.pack(side="left")
lista_tarefas = tk.Listbox(janela, height=15, width=50)
lista_tarefas.pack(pady=10)
frame_botoes = tk.Frame(janela)
frame_botoes.pack(pady=5)
tk.Button(frame_botoes, text="Remover", command=remover_tarefa).pack(side="left", padx=5)
tk.Button(frame_botoes, text="Limpar Todas", command=limpar_todas).pack(side="left", padx=5)
tk.Button(frame_botoes, text="Sair", command=janela.destroy).pack(side="left", padx=5)
janela.mainloop()
Esta aplicação demonstra na prática o uso de Entry, Listbox, Frame, Button, messagebox, gerenciamento de layout com pack, bind de eventos de teclado e organização modular de código. Você pode expandi-la adicionando persistência em arquivo, categorias ou data de vencimento.
O Widget Canvas
O Canvas é um widget poderoso para desenho vetorial, gráficos personalizados e animações. Com ele, você pode desenhar linhas, retângulos, círculos, polígonos e até exibir imagens:
canvas = tk.Canvas(janela, width=300, height=300, bg="white")
canvas.pack()
canvas.create_line(50, 50, 250, 250, fill="blue", width=3)
canvas.create_rectangle(80, 80, 180, 180, outline="red", width=2, fill="yellow")
canvas.create_oval(200, 50, 280, 130, fill="green")
canvas.create_text(150, 270, text="Canvas do Tkinter", font=("Arial", 12))
Cada elemento desenhado no Canvas retorna um ID que pode ser usado posteriormente para modificar ou remover o elemento com métodos como itemconfig(), move() e delete(). Isso torna o Canvas ideal para criar jogos simples, visualizações de dados personalizadas e ferramentas de desenho.
O tutorial de Tkinter do Real Python explora em profundidade as capacidades do Canvas e como combiná-lo com outros widgets para criar aplicações interativas.
Estilizando sua Interface com ttk
O módulo tkinter.ttk (Themed Tkinter) oferece widgets com aparência moderna e nativa do sistema operacional. Enquanto os widgets clássicos do Tkinter têm uma aparência que lembra os anos 90, os widgets ttk se integram visualmente ao ambiente do usuário:
from tkinter import ttk
botao_ttk = ttk.Button(janela, text="Botão Moderno")
botao_ttk.pack()
progresso = ttk.Progressbar(janela, length=200, mode="determinate")
progresso.pack()
slider = ttk.Scale(janela, from_=0, to=100, orient="horizontal")
slider.pack()
tree = ttk.Treeview(janela, columns=("nome", "idade"), show="headings")
tree.heading("nome", text="Nome")
tree.heading("idade", text="Idade")
tree.pack()
Os widgets ttk suportam temas que podem ser alterados globalmente. Você pode listar os temas disponíveis com ttk.Style().theme_names() e alternar entre eles com ttk.Style().theme_use("nome_do_tema"). Os temas comuns incluem "clam", "alt", "default" e "vista" (Windows).
A documentação oficial do ttk detalha todos os widgets temáticos disponíveis e suas opções de configuração.
Boas Práticas com Tkinter
Para criar aplicações Tkinter profissionais e de fácil manutenção, siga estas recomendações:
- Separação em classes: Organize sua aplicação usando classes, geralmente herdando de
tk.Tkoutk.Frame. Isso facilita a organização do código e o gerenciamento de estado. Aprenda mais sobre esse padrão em nosso guia de Programação Orientada a Objetos em Python. - Use
gridpara formulários: Ogridé muito mais adequado quepackpara organizar rótulos e campos de entrada lado a lado. - Prefira
ttkaos widgets clássicos: Os widgets temáticos oferecem aparência mais profissional e consistente entre plataformas. - Evite
placepara layouts responsivos: Posicionamento absoluto não se adapta a redimensionamentos de janela. - Não use
time.sleep(): Osleepcongela a interface. Usejanela.after()para agendar execuções futuras sem bloquear a GUI. - Valide entradas do usuário: Sempre verifique os dados inseridos nos campos
EntryeTextantes de processá-los. - Documente os callbacks: Funções associadas a eventos devem ter nomes descritivos e, idealmente, docstrings explicando seu propósito.
Em relação a bloqueios de interface, o método after() é uma alternativa fundamental ao sleep. Veja um exemplo de timer não-bloqueante:
def atualizar_relogio():
from datetime import datetime
rotulo_relogio.config(text=datetime.now().strftime("%H:%M:%S"))
janela.after(1000, atualizar_relogio)
rotulo_relogio = tk.Label(janela, font=("Arial", 24))
rotulo_relogio.pack()
atualizar_relogio()
Conclusão
O Tkinter é uma ferramenta poderosa e acessível para criar interfaces gráficas em Python. Neste guia, você aprendeu desde a criação da primeira janela até técnicas avançadas como gerenciadores de layout, eventos, diálogos nativos, estilização com ttk e boas práticas de desenvolvimento.
O Tkinter brilha especialmente em cenários como ferramentas internas de empresa, protótipos rápidos, editores simples, sistemas de cadastro, dashboards leves e aplicações educacionais. Para projetos que exigem interfaces web, recomendamos explorar Flask ou FastAPI. E se precisar de interfaces mobile, frameworks como Kivy são mais adequados.
A melhor forma de dominar o Tkinter é praticar. Comece criando projetos pequenos: um conversor de temperaturas, um bloco de notas simples, um cronômetro ou um visualizador de imagens. Cada projeto vai consolidar seu aprendizado e te preparar para aplicações mais complexas. A Python Wiki sobre Tkinter e o site TkDocs são excelentes recursos para continuar seus estudos.