Tkinter es la interfaz estándar de Python para crear aplicaciones gráficas de escritorio. Permite construir ventanas, botones, campos, menús, listas y diálogos sin instalar un framework web. Es una buena opción para herramientas internas, formularios, utilidades educativas y proyectos de aprendizaje. Una interfaz útil, sin embargo, necesita más que colocar widgets: debe validar datos, organizar el diseño y evitar bloquear la ventana.
Antes de comenzar conviene conocer las funciones en Python, la programación orientada a objetos, el manejo de excepciones, el uso de threads para evitar bloqueos y el proyecto de calculadora en Python.
La documentación oficial de tkinter explica la integración con Tcl/Tk. El tutorial TkDocs ofrece patrones modernos para diseño, eventos y widgets.
Comprobar que Tkinter funciona
python -m tkinter
Si aparece una pequeña ventana de demostración, el módulo está disponible. En algunas distribuciones de Linux puede ser necesario instalar el paquete de Tk desde el gestor del sistema.
Crear la primera ventana
import tkinter as tk
ventana = tk.Tk()
ventana.title("Mi primera aplicación")
ventana.geometry("500x300")
ventana.minsize(400, 240)
ventana.mainloop()
mainloop() inicia el bucle de eventos. Mientras está activo, Tkinter escucha clics, teclado, redimensionamiento y actualizaciones. No coloques código después esperando que se ejecute continuamente; usa callbacks y programación con after.
Añadir texto y botones
titulo = tk.Label(
ventana,
text="Bienvenido",
font=("Arial", 20, "bold"),
)
titulo.pack(pady=20)
def saludar():
titulo.config(text="¡Hola desde Tkinter!")
boton = tk.Button(
ventana,
text="Saludar",
command=saludar,
)
boton.pack()
En command debes pasar la función sin paréntesis. Si escribes command=saludar(), se ejecutará al crear el botón y se guardará su resultado.
Usar ttk
ttk ofrece widgets con aspecto más moderno:
from tkinter import ttk
boton = ttk.Button(
ventana,
text="Guardar",
command=saludar,
)
boton.pack(pady=10)
Para proyectos nuevos, utiliza ttk cuando exista un widget equivalente.
Organizar el diseño con grid
marco = ttk.Frame(ventana, padding=20)
marco.pack(fill="both", expand=True)
etiqueta = ttk.Label(marco, text="Nombre:")
etiqueta.grid(row=0, column=0, sticky="w", padx=5, pady=5)
entrada = ttk.Entry(marco, width=30)
entrada.grid(row=0, column=1, sticky="ew", padx=5, pady=5)
marco.columnconfigure(1, weight=1)
No mezcles pack y grid dentro del mismo contenedor. Puedes usar pack en la ventana y grid dentro de un frame.
Leer y validar un formulario
from tkinter import messagebox
def guardar_usuario():
nombre = entrada.get().strip()
if len(nombre) < 2:
messagebox.showerror(
"Datos inválidos",
"El nombre debe tener al menos dos caracteres",
)
entrada.focus_set()
return
messagebox.showinfo("Guardado", f"Usuario: {nombre}")
entrada.delete(0, tk.END)
La validación importante también debe existir en la capa de lógica, no solo en la interfaz. Así puede reutilizarse desde tests o una API.
Variables de Tkinter
nombre_var = tk.StringVar()
activo_var = tk.BooleanVar(value=True)
entrada = ttk.Entry(marco, textvariable=nombre_var)
check = ttk.Checkbutton(
marco,
text="Usuario activo",
variable=activo_var,
)
Estas variables conectan widgets y valores. Usa get() y set() para acceder a ellas.
Crear una aplicación orientada a objetos
class Aplicacion(ttk.Frame):
def __init__(self, master):
super().__init__(master, padding=20)
self.pack(fill="both", expand=True)
self.nombre = tk.StringVar()
self.crear_widgets()
def crear_widgets(self):
ttk.Label(self, text="Nombre").grid(
row=0, column=0, sticky="w"
)
ttk.Entry(self, textvariable=self.nombre).grid(
row=0, column=1, sticky="ew"
)
ttk.Button(
self,
text="Mostrar",
command=self.mostrar,
).grid(row=1, column=0, columnspan=2, pady=12)
self.columnconfigure(1, weight=1)
def mostrar(self):
messagebox.showinfo("Nombre", self.nombre.get())
ventana = tk.Tk()
ventana.title("Formulario")
Aplicacion(ventana)
ventana.mainloop()
Esta estructura agrupa estado y widgets, pero la lógica de negocio compleja debe permanecer en módulos separados.
Listas y selección
lista = tk.Listbox(marco, height=6)
for tarea in ["Estudiar", "Probar", "Documentar"]:
lista.insert(tk.END, tarea)
lista.grid(row=2, column=0, columnspan=2, sticky="ew")
def tarea_seleccionada():
seleccion = lista.curselection()
if not seleccion:
return None
return lista.get(seleccion[0])
Para tablas con columnas utiliza ttk.Treeview.
Menús
menu = tk.Menu(ventana)
archivo = tk.Menu(menu, tearoff=False)
archivo.add_command(label="Guardar", command=guardar_usuario)
archivo.add_separator()
archivo.add_command(label="Salir", command=ventana.destroy)
menu.add_cascade(label="Archivo", menu=archivo)
ventana.config(menu=menu)
Seleccionar archivos
from tkinter import filedialog
def abrir_archivo():
ruta = filedialog.askopenfilename(
title="Seleccionar archivo",
filetypes=[("Texto", "*.txt"), ("Todos", "*.*")],
)
if ruta:
print(ruta)
Trata la cancelación como un resultado normal. No intentes abrir una ruta vacía.
Programar tareas con after
reloj = ttk.Label(marco)
reloj.grid(row=3, column=0, columnspan=2)
def actualizar_reloj():
from datetime import datetime
reloj.config(text=datetime.now().strftime("%H:%M:%S"))
ventana.after(1000, actualizar_reloj)
actualizar_reloj()
after programa una función sin bloquear el bucle de eventos. Es ideal para relojes, animaciones sencillas y comprobaciones cortas.
Evitar que la ventana se congele
Una solicitud HTTP o un procesamiento largo no debe ejecutarse directamente dentro de un callback:
from threading import Thread
def iniciar_tarea():
boton.config(state="disabled")
Thread(target=tarea_larga, daemon=True).start()
def tarea_larga():
resultado = "Proceso terminado"
ventana.after(0, finalizar_tarea, resultado)
def finalizar_tarea(resultado):
titulo.config(text=resultado)
boton.config(state="normal")
Los widgets deben actualizarse desde el hilo principal. El trabajador entrega el resultado mediante after.
Separar la lógica
def calcular_total(precio, cantidad):
if precio < 0 or cantidad < 0:
raise ValueError("Valores negativos")
return precio * cantidad
La interfaz convierte entradas, llama a la función y muestra errores. Esta función puede probarse sin crear una ventana.
Estilos
estilo = ttk.Style()
estilo.configure("Titulo.TLabel", font=("Arial", 20, "bold"))
etiqueta = ttk.Label(
marco,
text="Panel principal",
style="Titulo.TLabel",
)
No dependas de colores que reduzcan el contraste. Respeta tamaños legibles, navegación por teclado y mensajes claros.
Cerrar de forma segura
def cerrar():
if messagebox.askyesno("Salir", "¿Deseas cerrar la aplicación?"):
ventana.destroy()
ventana.protocol("WM_DELETE_WINDOW", cerrar)
Antes de cerrar puedes guardar preferencias o detener threads mediante un Event.
Empaquetar la aplicación
Una vez probada, puedes distribuirla con PyInstaller. Prueba el ejecutable en un equipo limpio y conserva los archivos de configuración fuera del paquete cuando deban editarse. No uses --onefile automáticamente sin evaluar el tiempo de inicio y los recursos.
Errores frecuentes
Los problemas habituales son llamar la función dentro de command, mezclar administradores en el mismo contenedor, ejecutar tareas largas en el hilo principal, crear varias instancias de Tk y colocar toda la lógica en callbacks. Para ventanas secundarias utiliza Toplevel.
Conclusión
Tkinter permite crear aplicaciones de escritorio con herramientas incluidas en Python. Comienza con una ventana, usa frames y grid, valida formularios y separa la lógica. Programa tareas cortas con after y mueve operaciones largas a un trabajador sin actualizar widgets desde ese hilo. Con una estructura clara puedes transformar scripts de terminal en herramientas gráficas mantenibles.
