O que é Tkinter e como criar interfaces gráficas em Python

O que é Tkinter?

Tkinter é a biblioteca padrão do Python para criar interfaces gráficas de usuário (GUI). Ela fornece uma interface para o toolkit Tcl/Tk, que consiste na linguagem de script Tcl (criada em 1988) e no toolkit gráfico Tk (desenvolvido a partir de 1991), ambos projetados originalmente para a construção de interfaces gráficas multiplataforma.

Além disso, o Tkinter é simples de usar, não exige instalação extra e permite criar interfaces gráficas completas com poucas linhas de código.

Por isso, ela é uma das melhores escolhas para quem quer desenvolver aplicações desktop com janelas, botões, menus e formulários interativos.

Veja as principais vantagens de usar Tkinter para criar interfaces gráficas:

• Já vem instalado na maioria das distribuições Python;
• Permite criar aplicações gráficas com poucas linhas de código;
• Funciona em Windows, Linux e macOS sem modificações;
• Grande variedade de widgets prontos (botões, caixas de texto, menus);
• Integração nativa com Python e compatibilidade com outras bibliotecas.

Tkinter no desenvolvimento de aplicações desktop

Atualmente, Tkinter é a biblioteca GUI padrão e está presente em milhares de projetos ao redor do mundo. Seu impacto no ecossistema das linguagem de programação é significativo, especialmente em ferramentas internas, sistemas corporativos e aplicações educacionais.

Muitos dos desenvolvedores Python que criam interfaces gráficas começam com Tkinter pela facilidade de uso e curva de aprendizado suave.

Empresas e projetos como IDLE, ferramentas de automação corporativa e sistemas de gerenciamento interno usam Tkinter em suas interfaces.

Leia também

O que é IDLE no Python e como usar esse ambiente para começar a programar

Como instalar e configurar o Tkinter?

Instalar e configurar o Tkinter é simples. O processo varia conforme o sistema operacional, mas em poucos minutos você já estará pronto para criar suas primeiras interfaces gráficas.

Veja como fazer a instalação em cada sistema:

Instalação no Ubuntu e distribuições Linux

No Ubuntu e outras distros baseadas em Debian, o Tkinter geralmente não vem instalado por padrão com o Python. Por isso, você precisa instalar manualmente através do gerenciador de pacotes.

Para instalar, abra o terminal e execute os seguintes comandos:

sudo apt update
sudo apt install python3-tk

sudo apt update
sudo apt install python3-tk

Após a instalação, você precisa importar o Tkinter no seu código Python com import tkinter as tk e você já pode começar a desenvolver suas aplicações gráficas.

Instalação no Windows

No Windows, o Tkinter já vem incluso na instalação padrão do Python baixado pelo site oficial.

Estrutura básica de um programa Tkinter

Criar um programa com Tkinter segue uma estrutura simples e organizada. Afinal, a biblioteca foi pensada para facilitar o desenvolvimento de interfaces gráficas de forma direta e intuitiva.

Por isso, seguir os passos básicos garante que você tenha uma aplicação funcional em poucos minutos.

Veja os elementos essenciais de qualquer programa Tkinter:

1. Importar o módulo Tkinter

O primeiro passo é importar a biblioteca no seu código Python. Essa etapa permite acessar todas as classes e funções necessárias para criar sua interface gráfica:

import tkinter as tk

Usar o alias tk é uma prática comum que torna o código mais limpo e fácil de ler.

2. Criar a janela principal

A janela principal é o container no qual todos os elementos da sua aplicação serão exibidos. Você cria essa janela instanciando a classe Tk:

janela = tk.Tk()
janela.title("Minha Primeira Janela")

janela = tk.Tk()
janela.title("Minha Primeira Janela")

Aqui você cria a janela principal e define seu título. Vale lembrar que a janela não será exibida imediatamente, pois ela só aparece na tela quando o método mainloop() for executado no final do programa.

3. Adicionar widgets à janela

Widgets são os componentes gráficos da sua interface, como botões, rótulos, caixas de texto e menus. Cada widget precisa ser criado e então posicionado na janela usando um gerenciador de layout.

Exemplo de como adicionar um rótulo simples:

rotulo = tk.Label(janela, text="Olá, Tkinter!")
rotulo.pack()

rotulo = tk.Label(janela, text="Olá, Tkinter!")
rotulo.pack()

O método pack() é um gerenciador de layout que organiza o widget automaticamente na janela. Além dele, você também pode usar grid() para organização em grades ou place() para posicionamento absoluto com coordenadas específicas.

4. Iniciar o loop principal

O loop principal mantém a aplicação rodando e responsiva às ações do usuário. Sem ele, a janela seria criada e fechada imediatamente:

janela.mainloop()

Esse método fica aguardando eventos como cliques, digitação e movimentos do mouse, atualizando a interface conforme necessário até que o usuário feche a janela.

Exemplo completo de programa básico

Juntando todos os elementos, você tem uma aplicação funcional completa:

import tkinter as tk

janela = tk.Tk()
janela.title("Minha Primeira Janela")

rotulo = tk.Label(janela, text="Olá, Tkinter!")
rotulo.pack()

janela.mainloop()

import tkinter as tk

janela = tk.Tk()
janela.title("Minha Primeira Janela")

rotulo = tk.Label(janela, text="Olá, Tkinter!")
rotulo.pack()

janela.mainloop()

Essa estrutura é a base de qualquer aplicação Tkinter. A partir dela, você pode criar interfaces muito mais complexas combinando diferentes widgets, gerenciadores de layout e eventos de interação.

Gerenciamento de layout em Tkinter

Gerenciar o layout dos widgets no Tkinter é fundamental para criar interfaces organizadas e funcionais. Afinal, a forma como os elementos são posicionados na tela define a experiência do usuário com sua aplicação.

Por isso, o Tkinter oferece três métodos principais de gerenciamento de layout, cada um com suas características e casos de uso específicos.

Veja os gerenciadores de layout disponíveis e quando usar cada um:

Método pack()

O pack() é o gerenciador mais simples e direto do Tkinter. Ele empilha os widgets na ordem em que são adicionados ao código, organizando-os automaticamente de forma vertical ou horizontal.

Esse método é perfeito para layouts básicos em que você não precisa de controle preciso sobre o posicionamento. Na prática, o pack() funciona muito bem para menus simples, barras de ferramentas e interfaces com poucos elementos.

Exemplo de uso:

botao1 = tk.Button(janela, text="Botão 1")
botao1.pack()

botao2 = tk.Button(janela, text="Botão 2")
botao2.pack()

botao1 = tk.Button(janela, text="Botão 1")
botao1.pack()

botao2 = tk.Button(janela, text="Botão 2")
botao2.pack()

Aqui, os botões aparecem um abaixo do outro automaticamente. Você também pode controlar a direção do empilhamento usando parâmetros como side=tk.LEFT ou side=tk.TOP.

Método grid()

O grid() organiza os widgets em uma grade com linhas e colunas, permitindo posicionamento mais preciso e estruturado. Esse gerenciador é ideal para formulários, calculadoras e qualquer interface que precise de alinhamento tabular.

Com o grid(), você define exatamente em qual linha e coluna cada widget deve aparecer, criando layouts organizados e profissionais com facilidade.

Exemplo de uso:

rotulo.grid(row=0, column=0)
botao.grid(row=1, column=0)

rotulo.grid(row=0, column=0)
botao.grid(row=1, column=0)

O rótulo fica na primeira linha e primeira coluna, enquanto o botão aparece na segunda linha, mesma coluna. Você também pode fazer widgets ocuparem múltiplas linhas ou colunas usando parâmetros como rowspan e columnspan.

Método place()

O place() permite posicionar widgets em coordenadas absolutas na janela, dando controle total sobre a posição de cada elemento. Esse método usa coordenadas x e y em pixels para definir onde o widget deve aparecer.

Na prática, o place() é usado quando você precisa de posicionamento exato e personalizado, como em interfaces com design específico ou elementos sobrepostos.

Exemplo de uso:

rotulo.place(x=50, y=50)

Aqui, o rótulo fica posicionado a 50 pixels da borda esquerda e 50 pixels do topo da janela. Porém, esse método pode ser mais trabalhoso para criar interfaces responsivas que se adaptam a diferentes tamanhos de tela.

Escolhendo o gerenciador ideal

Cada método tem suas vantagens e situações ideais de uso. O pack() é rápido e simples para layouts básicos e lineares. O grid() é perfeito para interfaces com estrutura tabular e formulários organizados. O place() oferece controle absoluto quando você precisa de posicionamento pixel-perfect.

Vale lembrar que é importante não misturar pack() e grid() na mesma janela principal para evitar conflitos. O Tkinter não consegue gerenciar dois métodos diferentes no mesmo container, o que pode causar erros ou comportamentos inesperados.

Criando widgets comuns em Tkinter

Widgets são os blocos de construção de qualquer interface gráfica no Tkinter. Afinal, são eles que permitem a interação do usuário com sua aplicação, desde exibir informações até capturar dados e executar ações.

Por isso, dominar os widgets principais é essencial para criar aplicações funcionais e intuitivas.

Veja os componentes mais usados e como implementá-los:

Rótulos (Labels)

Os rótulos servem para exibir textos estáticos na interface. Eles são perfeitos para títulos, mensagens informativas e instruções ao usuário. Você pode personalizar fonte, cor, tamanho e alinhamento conforme necessário.

Exemplo de uso:

rotulo = tk.Label(janela, text="Bem-vindo ao Tkinter!", font=("Arial", 16))
rotulo.pack()

rotulo = tk.Label(janela, text="Bem-vindo ao Tkinter!", font=("Arial", 16))
rotulo.pack()

Aqui, o rótulo exibe uma mensagem de boas-vindas com fonte Arial tamanho 16. Na prática, os labels são usados em praticamente todas as interfaces para guiar o usuário.

Botões (Buttons)

Os botões são componentes interativos que executam uma ação específica quando clicados. Cada botão pode ser associado a uma função que define o que acontece ao acioná-lo.

Esse widget é essencial para qualquer aplicação, já que permite ao usuário realizar comandos e interagir com o sistema.

Exemplo de uso:

def acao_botao():
    print("Botão clicado!")

botao = tk.Button(janela, text="Clique aqui", command=acao_botao)
botao.pack()

def acao_botao():
    print("Botão clicado!")

botao = tk.Button(janela, text="Clique aqui", command=acao_botao)
botao.pack()

Nesse exemplo, o botão executa a função acao_botao() quando clicado, imprimindo uma mensagem no console. Você pode personalizar cor, tamanho, fonte e comportamento dos botões conforme sua necessidade.

Caixas de entrada (Entry)

As caixas de entrada permitem que o usuário digite texto na aplicação. Elas são fundamentais para formulários, campos de login, barras de pesquisa e qualquer situação na qual você precise capturar dados do usuário.

Exemplo de uso:

entrada = tk.Entry(janela)

entrada.pack()

Com apenas duas linhas, você cria um campo de texto funcional. Na prática, você pode capturar o conteúdo digitado usando o método get() e validar ou processar essa informação conforme necessário.

Menus

Os menus servem para criar barras de menu na parte superior da janela, organizando comandos e opções de forma hierárquica. Eles são ideais para aplicações mais complexas que precisam de múltiplas funcionalidades organizadas.

Exemplo de uso:

menu = tk.Menu(janela)
janela.config(menu=menu)

submenu = tk.Menu(menu)
menu.add_cascade(label="Arquivo", menu=submenu)
submenu.add_command(label="Sair", command=janela.quit)

menu = tk.Menu(janela)
janela.config(menu=menu)

submenu = tk.Menu(menu)
menu.add_cascade(label="Arquivo", menu=submenu)
submenu.add_command(label="Sair", command=janela.quit)

Aqui, você cria um menu principal com um submenu “Arquivo” que contém a opção “Sair”. Essa estrutura permite organizar dezenas de comandos de forma profissional e intuitiva.

Exemplo completo com múltiplos widgets

Juntando todos esses elementos, você pode criar uma interface funcional completa:

import tkinter as tk

def acao_botao():
    print("Botão clicado!")

janela = tk.Tk()
janela.title("Interface Simples")

rotulo = tk.Label(janela, text="Bem-vindo ao Tkinter!", font=("Arial", 16))
rotulo.pack()

botao = tk.Button(janela, text="Clique aqui", command=acao_botao)
botao.pack()

entrada = tk.Entry(janela)
entrada.pack()

menu = tk.Menu(janela)
janela.config(menu=menu)

submenu = tk.Menu(menu)
menu.add_cascade(label="Arquivo", menu=submenu)
submenu.add_command(label="Sair", command=janela.quit)

janela.mainloop()

import tkinter as tk

def acao_botao():
    print("Botão clicado!")

janela = tk.Tk()
janela.title("Interface Simples")

rotulo = tk.Label(janela, text="Bem-vindo ao Tkinter!", font=("Arial", 16))
rotulo.pack()

botao = tk.Button(janela, text="Clique aqui", command=acao_botao)
botao.pack()

entrada = tk.Entry(janela)
entrada.pack()

menu = tk.Menu(janela)
janela.config(menu=menu)

submenu = tk.Menu(menu)
menu.add_cascade(label="Arquivo", menu=submenu)
submenu.add_command(label="Sair", command=janela.quit)

janela.mainloop()

Esse código cria uma janela com um texto exibido pelo rótulo, um botão que imprime mensagem no console ao ser clicado, uma caixa para entrada de texto e um menu simples com opção para sair da aplicação.

Tratamento de eventos em Tkinter

Os eventos são ações que ocorrem na interface, como cliques de mouse ou pressionamentos de tecla. O Tkinter permite que você reaja a esses eventos através de funções de callback.

Veja as principais formas de implementar callbacks no Tkinter:

Usando o parâmetro command

A forma mais simples e direta de criar callbacks é através do parâmetro command nos widgets. Esse método funciona perfeitamente para botões e outros componentes que precisam executar uma ação específica quando acionados.

Exemplo:

def mudar_texto():
    rotulo.config(text="Texto alterado!")


botao = tk.Button(janela, text="Mudar Texto", command=mudar_texto)
botao.pack()

def mudar_texto():
    rotulo.config(text="Texto alterado!")


botao = tk.Button(janela, text="Mudar Texto", command=mudar_texto)
botao.pack()

Aqui, o botão executa a função mudar_texto() quando clicado, alterando o conteúdo do rótulo instantaneamente. Na prática, você pode associar qualquer função ao comando, desde cálculos simples até operações complexas com banco de dados.

Usando o método bind() para eventos diversos

O método bind() oferece controle muito mais amplo sobre eventos na interface. Com ele, você pode capturar ações como movimento do mouse, pressionamento de teclas, cliques específicos e muito mais.

Esse método é ideal quando você precisa responder a eventos que vão além de simples cliques em botões.

Exemplo de uso com eventos de mouse:

rotulo.bind("<Enter>", lambda e: rotulo.config(text="Mouse sobre o rótulo!"))
rotulo.bind("<Leave>", lambda e: rotulo.config(text="Olá, Tkinter!"))

rotulo.bind("<Enter>", lambda e: rotulo.config(text="Mouse sobre o rótulo!"))
rotulo.bind("<Leave>", lambda e: rotulo.config(text="Olá, Tkinter!"))

Nesse exemplo, <Enter> detecta quando o mouse entra na área do widget e <Leave> quando sai dela. O texto do rótulo muda automaticamente conforme o mouse se move, criando uma interface mais dinâmica e interativa.

Eventos disponíveis no Tkinter

Você pode detectar diversos tipos de eventos além dos mostrados acima. Entre os mais usados estão:

• Cliques específicos do mouse (<Button-1> para botão esquerdo, <Button-3> para botão direito);
• Pressionamento de teclas (<Key> para qualquer tecla ou <Return> para Enter);
• Movimentação do mouse (<Motion>);
• Redimensionamento de janela (<Configure>).

Na prática, o bind() transforma qualquer widget em um componente totalmente interativo. Você pode criar interfaces em que praticamente qualquer ação do usuário gera uma resposta da aplicação, tornando a experiência muito mais fluida e profissional.

Tkinter vs PyQt vs Kivy 

Tkinter não é a única opção para criar interfaces gráficas em Python. Afinal, existem diversas bibliotecas disponíveis, cada uma com suas características, vantagens e casos de uso específicos.

Por isso, entender as diferenças entre as principais alternativas ajuda você a escolher a ferramenta certa para cada projeto.

Tkinter

Tkinter é a biblioteca padrão para criar interfaces gráficas simples e rápidas. Ela é ideal para iniciantes e aplicações básicas que não exigem recursos avançados. A curva de aprendizado é baixa e, por vir inclusa no Python, você não precisa instalar nada adicional.

Porém, sua aparência pode ser considerada tradicional ou até ultrapassada em alguns casos. Os widgets são básicos e funcionais, mas sem suporte nativo para recursos avançados como multimídia complexa, gráficos vetoriais ou integração direta com bancos de dados.

Na prática, Tkinter resolve muito bem projetos pequenos e médios, ferramentas internas, protótipos e aplicações em que a funcionalidade importa mais que a estética moderna.

PyQt

PyQt é um framework muito mais robusto e completo, baseado na biblioteca Qt usada em aplicações profissionais ao redor do mundo. Ele oferece uma vasta gama de widgets sofisticados, aparência moderna e suporte a funcionalidades complexas como redes, multimídia, gráficos vetoriais e integração nativa com bancos de dados.

O PyQt utiliza um modelo de sinais e slots para comunicação entre objetos, proporcionando flexibilidade impressionante para construir interfaces ricas e profissionais. Porém, tem uma curva de aprendizado maior e exige instalação separada, além de considerações sobre licenciamento em alguns casos.

Essa biblioteca é ideal para projetos de médio a grande porte que precisam de interfaces avançadas, alto nível de personalização e recursos que vão muito além do básico.

Kivy

Kivy é focado no desenvolvimento de aplicativos móveis e interfaces multi-touch para plataformas como Android e iOS. Enquanto Tkinter é voltado principalmente para desktops, Kivy foi projetado desde o início para interfaces modernas e responsivas em dispositivos móveis.

A biblioteca suporta gráficos acelerados por hardware e tem um design visual moderno que se adapta bem a telas sensíveis ao toque. Porém, não é a escolha ideal para aplicações desktop tradicionais, em que Tkinter e PyQt são mais adequados.

Kivy oferece uma complexidade média, com paradigmas diferentes do desenvolvimento desktop tradicional, e também requer instalação separada.

Kivy e Python: vale a pena para seu projeto? Guia completo

Comparação direta entre as bibliotecas

Quer aprender Python do zero e começar a criar suas próprias aplicações?

Tkinter é uma ferramenta poderosa e acessível para quem quer começar a criar interfaces gráficas em Python. Afinal, ele combina simplicidade, praticidade e funcionalidade em uma biblioteca que já está pronta para usar.

Por isso, mesmo com o surgimento de alternativas mais modernas e robustas, Tkinter continua sendo a escolha ideal para milhares de desenvolvedores ao redor do mundo.

O curso gratuito Python para Iniciantes: do zero ao primeiro projeto é ideal para quem deseja dominar Python e começar a criar interfaces gráficas simples, como janelas e aplicativos interativos com Tkinter.

Você vai aprender desde os fundamentos da linguagem até conceitos práticos que permitem desenvolver projetos reais. E o melhor: é completamente gratuito e focado em fazer você colocar a mão na massa desde o primeiro dia.

Curso Gratuito

Seu primeiro projeto Python – curso grátis com certificado!

Vá do zero ao primeiro projeto em apenas 2 horas com o curso Python para Iniciantes.

Comece agora

FAQ: perguntas frequentes sobre Tkinter

Para que serve o Tkinter?

O Tkinter é uma biblioteca padrão do Python projetada para criar interfaces gráficas de usuário (GUIs) em aplicações desktop, permitindo o desenvolvimento de programas interativos com elementos como janelas, botões, menus, formulários e widgets personalizados de forma simples e eficiente; ele é especialmente útil para protótipos rápidos, ferramentas educativas ou aplicativos básicos que necessitam de uma interface visual sem depender de dependências externas complexas, facilitando a criação de itens como calculadoras gráficas ou editores de texto, e opera de maneira multiplataforma em sistemas como Windows, macOS e Linux.

O que é o framework Tkinter?

Tkinter é uma biblioteca padrão do Python, não exatamente um framework completo como outros, mas um módulo para o desenvolvimento de GUIs que fornece uma interface para o toolkit Tcl/Tk, uma ferramenta criada nos anos 90 conhecida por sua simplicidade e portabilidade; ele vem incluído na instalação padrão do Python a partir da versão 2.0, eliminando a necessidade de instalações extras, e permite a construção de aplicações com poucas linhas de código, focando em widgets como labels, buttons e canvases, tornando-o acessível para iniciantes enquanto suporta funcionalidades básicas para interfaces interativas.

Qual a melhor interface gráfica para Python?

A escolha da melhor interface gráfica para Python varia conforme as necessidades do projeto, mas Tkinter destaca-se para iniciantes e aplicações simples devido à sua leveza, ausência de instalação adicional e integração oficial com o Python; alternativas como PyQt ou PySide oferecem mais poder e modernidade para projetos profissionais com designs complexos.

Como posso executar o Tkinter no Python?

Para executar o Tkinter no Python, importe o módulo com ‘import tkinter as tk’, crie uma janela principal usando ‘root = tk.Tk()’, defina propriedades como título com ‘root.title(“Exemplo”)’ e tamanho com ‘root.geometry(“400×300”)’, e inicie o loop principal com ‘root.mainloop()’; salve o código em um arquivo .py e rode-o via terminal com ‘python arquivo.py’.

Como posso colocar uma imagem no Tkinter?

Para inserir uma imagem no Tkinter, utilize o widget Label combinado com PhotoImage para formatos como GIF, ou integre Pillow para JPG/PNG instalando-o via ‘pip install pillow’ e importando ‘from PIL import Image, ImageTk’; carregue a imagem com ‘image = Image.open(“caminho/imagem.png”)’.

Como posso abrir o Tkinter?

Abrir o Tkinter significa iniciar uma aplicação que utiliza a biblioteca, importando ‘tkinter as tk’, criando ‘root = tk.Tk()’ e executando ‘root.mainloop()’ para exibir uma janela vazia, o que pode ser testado diretamente no interpretador Python ou em um script .py rodado via terminal.