Imagina que tienes el poder de diseñar espacios digitales donde las ideas cobran vida, donde cada ventana es un nuevo mundo de posibilidades. En este taller, no solo aprenderás a programar interfaces gráficas con Python, sino que descubrirás cómo organizar el flujo de información entre diferentes espacios visuales, cultivando un pensamiento estructurado, creativo y estratégico.
Te guiaré en un viaje donde la lógica de programación se encuentra con la intuición del diseño, donde cada línea de código es una decisión consciente que construye experiencias significativas para quien interactúe con tu creación.
Objetivo de aprendizaje: Dominar la creación y gestión de múltiples ventanas en aplicaciones de escritorio usando Python y tkinter, integrando competencias técnicas como el manejo de widgets y el control de eventos, con habilidades cognitivas de diseño de flujos de información y resolución de problemas, así como actitudes de curiosidad, perseverancia y atención al detalle, para desarrollar aplicaciones funcionales que respondan a necesidades reales de interacción persona-computadora, fortaleciendo así la capacidad de traducir ideas abstractas en soluciones concretas y elegantes.
Piensa en la última aplicación que usaste en tu teléfono o computadora. ¿Notaste cómo se mueve entre diferentes pantallas? Al ingresar a tu banco en línea, primero ves la ventana de login, luego la de tu dashboard, después la de transferencias... Cada ventana tiene un propósito específico, y juntas forman una experiencia coherente.
Reflexión: Así como en la vida real nos movemos entre diferentes espacios (casa, colegio, parque), en el mundo digital las ventanas son esos espacios donde ocurren interacciones específicas. Programar múltiples ventanas es como diseñar el plano de una casa digital, donde cada habitación tiene una función y todas se conectan de manera intuitiva.
En Ecuador, donde la tecnología se integra cada vez más en nuestra cotidianidad, entender estos principios te permitirá no solo consumir tecnología, sino crearla con sentido, considerando las necesidades de personas reales en contextos reales.
Toda aplicación tkinter comienza con una ventana principal, el contenedor de todos los demás elementos. Es nuestra base, nuestro punto de partida.
import tkinter as tk
from tkinter import messagebox
# Crear la ventana principal
root = tk.Tk()
root.title("Mi primera aplicación")
root.geometry("400x300")
# Widgets básicos (botones, etiquetas, etc.)
label_titulo = tk.Label(root, text="Bienvenido a mi app", font=("Arial", 16))
label_titulo.pack(pady=20)
def saludar():
messagebox.showinfo("Saludo", "¡Hola, futuro programador!")
boton_saludo = tk.Button(root, text="Saludar", command=saludar)
boton_saludo.pack(pady=10)
# Ejecutar el bucle principal
root.mainloop()Las ventanas secundarias se crean a partir de la principal y permiten organizar funcionalidades específicas. Son como nuevas habitaciones en nuestra casa digital.
def abrir_ventana_secundaria():
# Crear una nueva ventana (secundaria)
ventana_nueva = tk.Toplevel(root)
ventana_nueva.title("Ventana de configuración")
ventana_nueva.geometry("300x200")
# Agregar contenido a la ventana nueva
label_config = tk.Label(ventana_nueva, text="Ajusta tus preferencias")
label_config.pack(pady=20)
# Botón para cerrar solo esta ventana
boton_cerrar = tk.Button(ventana_nueva, text="Cerrar ventana",
command=ventana_nueva.destroy)
boton_cerrar.pack(pady=10)
# Botón en la ventana principal para abrir la secundaria
boton_abrir = tk.Button(root, text="Abrir ventana secundaria",
command=abrir_ventana_secundaria)
boton_abrir.pack(pady=20)Experimenta: Modifica el código anterior cambiando los tamaños de las ventanas, los textos y colores. ¿Qué pasa si creas una tercera ventana? ¿Y si intentas abrir la misma ventana secundaria varias veces? Observa, prueba, reflexiona sobre lo que ocurre.
El verdadero poder de las múltiples ventanas aparece cuando pueden compartir información entre sí. Veamos cómo lograrlo:
class AplicacionMultiVentana:
def __init__(self):
self.ventana_principal = tk.Tk()
self.ventana_principal.title("App con comunicación entre ventanas")
# Variable para compartir entre ventanas
self.datos_compartidos = "Información inicial"
# Interfaz de la ventana principal
self.label_estado = tk.Label(self.ventana_principal,
text=f"Estado: {self.datos_compartidos}")
self.label_estado.pack(pady=20)
boton_cambiar = tk.Button(self.ventana_principal, text="Abrir editor",
command=self.abrir_editor)
boton_cambiar.pack(pady=10)
def abrir_editor(self):
# Crear ventana de edición
ventana_editor = tk.Toplevel(self.ventana_principal)
ventana_editor.title("Editor de datos")
# Campo para editar los datos compartidos
label_instruccion = tk.Label(ventana_editor, text="Edita la información:")
label_instruccion.pack(pady=10)
self.entry_datos = tk.Entry(ventana_editor, width=40)
self.entry_datos.insert(0, self.datos_compartidos)
self.entry_datos.pack(pady=10)
boton_guardar = tk.Button(ventana_editor, text="Guardar cambios",
command=lambda: self.guardar_cambios(ventana_editor))
boton_guardar.pack(pady=10)
def guardar_cambios(self, ventana_editor):
# Actualizar los datos compartidos
self.datos_compartidos = self.entry_datos.get()
# Actualizar la etiqueta en la ventana principal
self.label_estado.config(text=f"Estado: {self.datos_compartidos}")
# Cerrar la ventana de edición
ventana_editor.destroy()
messagebox.showinfo("Éxito", "Datos actualizados correctamente")
# Para ejecutar la aplicación
if __name__ == "__main__":
app = AplicacionMultiVentana()
app.ventana_principal.mainloop()Ahora es tu turno: copia este código en tu entorno Python, ejecútalo y explora. Modifica, añade nuevas funcionalidades, juega con las posibilidades. La programación se aprende programando, cometiendo errores y descubriendo soluciones.
Crea una aplicación de escritorio con Python y tkinter que permita gestionar tareas pendientes utilizando tres ventanas diferentes que se comuniquen entre sí.
Pista: Considera crear una clase Tarea con atributos como título, descripción, prioridad y estado. Luego, mantén una lista de objetos Tarea que sea accesible desde todas las ventanas. Puedes usar el patrón de la clase AplicacionMultiVentana que vimos antes como punto de partida.
Reflexión metacognitiva: Al finalizar el reto, pregúntate: ¿qué estrategias usé para resolver los problemas que encontré? ¿Cómo organicé mi código para que fuera mantenible? ¿Qué haría diferente si tuviera que empezar de nuevo? Esta reflexión es tan importante como el código mismo.
Responde estas 5 preguntas para consolidar lo aprendido. ¡Cada respuesta correcta suma puntos!