Proyectos de Python Tkinter [Explicación paso a paso]

Aprender sobre GUI en Python puede ser bastante desafiante. ¡No te preocupes porque te cubrimos las espaldas! En este artículo, compartimos un tutorial de Tkinter para que pueda trabajar en proyectos de GUI de Python de manera eficiente. Después de completar este tutorial, estará familiarizado con los componentes básicos para crear proyectos de Python Tkinter. Si desea obtener más experiencia en python, consulte nuestros programas de ciencia de datos.

También hemos compartido el código para cada paso. Sin embargo, le recomendamos que lo copie y pegue solo cuando comprenda cómo funciona. De lo contrario, no sería de mucha utilidad.

¿Qué es Tkinter?

Tkinter es un paquete para que Python use el kit de herramientas Tk GUI. Puede usar Tkinter para crear programas GUI a través de Python. Si bien Tkinter es capaz de producir muchos programas, es posible que deba usar módulos para implementaciones avanzadas. Debe estar familiarizado con los conceptos básicos de Tkinter antes de trabajar en proyectos de Python Tkinter:

Un programa Hello World en Tkinter

Aquí hay un ejemplo de un programa hola mundo en Tkinter:

importar tkinter como tk

Aplicación de clase (tk.Frame):

def __init__(auto, maestro=Ninguno):

super().__init__(maestro)

self.maestro = maestro

auto.paquete()

self.create_widgets()

def create_widgets(auto):

self.hi_there = tk.Button(self)

self.hi_there[“texto”] = “Hola mundo\n(haz clic en mí)”

self.hola_allí[“comando”] = self.decir_hola

self.hi_there.pack(side=”top”)

self.salir = tk.Button(self, text=”QUIT”, fg=”red”,

command=self.master.destroy)

self.quit.pack(lado=”abajo”)

def decir_hola(uno mismo):

imprimir ("¡Hola a todos!")

raíz = tk.Tk()

app = Aplicación (maestro = raíz)

aplicación.mainloop()

Gestores de Geometría en Tkinter

Otro concepto principal que debe conocer al trabajar en proyectos de Python Tkinter son los administradores de geometría. Sin usar un administrador de geometría, sus widgets no aparecerían en la pantalla. Existen principalmente tres formas de agregar un administrador de geometría:

Cuadrícula

Agrega una cuadrícula al padre y le permite mostrar los widgets en consecuencia. La cuadrícula tiene filas y columnas para medir la longitud y la altura de sus widgets.

Paquete

Este método le dice al widget que se empaquete dentro del padre. Solo agrega el widget a una lista de widgets secundarios para el padre. En términos simples, los agrega a un bloque antes de colocarlos en un widget principal.

Lugar

Este método coloca los widgets en una ubicación específica según el widget principal.

En nuestro tutorial a continuación, hemos utilizado el administrador de paquetes para manejar la posición de nuestros widgets. Es por eso que sería mejor si está familiarizado con estos conceptos. Le ayudaría a comprender mejor el funcionamiento de nuestro proyecto.

Pago: 42 ideas y temas emocionantes de proyectos de Python para principiantes

Construyendo una GUI en Python (Tutorial de Tkinter)

Paso #1: Importando el Módulo

Para comenzar a trabajar en la aplicación, primero debemos importar el módulo necesario. Puede hacerlo importando el módulo en su espacio de nombres. Le permitiría usar las constantes y clases por sus nombres en lugar de calificarlas. Esto significa que puede usar "Etiqueta" usando su nombre en lugar de calificarlo como "TkinterLabel". Haría las cosas relativamente fáciles y puede ahorrar mucho tiempo, ya que calificar cada clase y constante puede ser muy engorroso. Use el siguiente código para importar el módulo:

>>> desde la importación de Tkinter *

Si Python no está vinculado a Tk (o Tcl) en su sistema o si no tiene Tk (o Tcl) instalado en su sistema, verá un mensaje de error en esta sección. Para solucionar este problema, necesitaría el acceso del administrador de su sistema. Asegúrate de resolver este problema haciendo lo mismo.

Por otro lado, si no ve ningún mensaje de error en estas secciones, puede pasar al siguiente paso para crear una ventana:

>>> ganar = Tk()

Hemos asignado a nuestra ventana la variable "ganar". Después de implementar el código anterior, verá una pequeña ventana en la pantalla. Su barra de título debe mostrar "tk" escrito en él.

Esto significa que completó este paso con éxito y ahora puede comenzar a construir GUI en Python.

Paso #2: Agregar botones

Ahora que tenemos nuestro Tkinter ejecutándose, podemos agregar botones a nuestro programa. Los botones son la sección más simple de cualquier programa GUI, por lo que comenzaremos con ellos:

>>> b1 = Botón(ganar, texto=”Uno”)

>>> b2 = Botón(ganar, texto=”Dos”)

La ventana que creamos en la última sección es la principal de los botones que creamos ahora. A medida que trabaje en más proyectos de Python Tkinter, encontrará que los marcos también pueden actuar como padres para otras clases. Ahora, cuando implemente este código, notará una ocurrencia extraña: ¡los botones no aparecen en la ventana!

Eso es porque necesitamos agregar una cuadrícula y un paquete a nuestro programa. Se denominan administradores de geometría y los hemos discutido anteriormente en este artículo. Agregaremos el administrador de paquetes en nuestra próxima sección:

Paso #3: Implementando el Pack Manager

Usaremos el método pack para agregar nuestros botones al widget principal. Con el administrador de paquetes, puede indicar en qué lado del widget principal desea que se empaque el widget secundario. Puede usar ARRIBA, DERECHA, ABAJO, IZQUIERDA como sus funciones. El programa selecciona TOP como predeterminado si no especifica un lado. Agreguemos primero el administrador del paquete:

>>> b1.paquete()

>>> b2.paquete()

Cuando agregue el primer botón (primera línea del código), notará que su ventana se reduce al tamaño del botón. De manera similar, cuando agrega el segundo botón (segunda línea del código), la ventana se expande de acuerdo con el tamaño de ese botón. La ventana ha colocado los botones en orden vertical porque no especificamos en qué lado deben colocarse. Vamos a empaquetarlos a la izquierda usando el siguiente código:

>>> b2.paquete(lado=IZQUIERDO)

>>> b1.paquete(lado=IZQUIERDO)

Tenga en cuenta que usamos el administrador de paquetes principalmente cuando tenemos que colocar nuestros widgets en estos dos órdenes (horizontal y vertical) solamente. Para otros tipos de ubicaciones de widgets, usamos el método de cuadrícula o el método de lugar. Puede agregar algo de espacio entre los botones y la ventana usando las funciones 'padx' o 'pady'. La función 'padx' agrega relleno al eje X (izquierda y derecha) del widget, y la función 'pady' agrega relleno al eje Y (parte superior e inferior) del dispositivo.

>>> b1.pack(lado=IZQUIERDO, padx=10)

>>> b2.pack(lado=IZQUIERDO, padx=10)

Recomendamos experimentar con el relleno de los widgets. Le ayudaría a comprender las diferentes formas en que puede modificar la ubicación de los widgets. El relleno es un concepto difícil de dominar, por lo que sería mejor probarlo antes de pasar a la siguiente sección.

Paso #4: El administrador de cuadrícula

Otro administrador de geometría popular en Tkinter es el administrador de cuadrícula. Como hemos discutido anteriormente en nuestro artículo, el administrador de cuadrícula le permite dividir el padre en filas y columnas. Puede colocar los widgets secundarios en las celdas de la cuadrícula principal. Puede modificar el ancho y la longitud de cada columna y fila según sus requisitos. No todas las columnas tienen que tener el mismo ancho. Del mismo modo, no es necesario que todas las filas tengan la misma altura. Por lo tanto, el administrador de cuadrícula le brinda más libertad creativa en términos de editar la apariencia y ubicación de sus widgets.

Crearemos una nueva ventana con los mismos botones que creamos antes para probar el administrador de cuadrícula. Sin embargo, agregaremos los botones en una cuadrícula de 2×2:

>>> ganar = Tk()

>>> b1 = Botón(ganar, texto=”Uno”)

>>> b2 = Botón(ganar,texto=”Dos”)

>>> b1.grid(fila=0, columna=0)

>>> b2.grid(fila=1, columna=1)

Notarás que nuestro programa ha dejado algunas celdas vacías. Eso es porque no agregamos nada a la fila 0, columna 1 (o fila 1 y columna 0). Probaremos un nuevo widget para ver algo interesante:

>>> l = Etiqueta(ganar, texto=”Esto es una etiqueta”)

>>> l.grid(fila=1, columna=0)

Una vez que agregue el código anterior, notará que el segundo botón se desplaza hacia la derecha para acomodar el texto. Sería mejor probar el administrador de cuadrículas con múltiples widgets para ver cómo funciona.

Debe leer: salario de desarrollador de Django en India

Paso #5: Mejorar el diseño

En esta sección probaremos un nuevo widget llamado marco. Un marco es solo para contener otros widgets. Puede empaquetar varios widgets en un marco o usar una cuadrícula para colocarlos en el mismo. También puede empaquetar diferentes marcos en un solo marco. Esta característica le permite crear diseños avanzados para su programa GUI. Por ejemplo, agregaremos tres botones a un marco en una fila. Agregue los botones horizontalmente y luego empaque la etiqueta verticalmente con el marco:

>>> ganar = Tk()

>>> f = Cuadro(ganar)

>>> b1 = Botón(f, “Uno”)

>>> b2 = Botón(f, “Dos”)

>>> b3 = Botón(f, “Tres”)

>>> b1.paquete(lado=IZQUIERDO)

>>> b2.paquete(lado=IZQUIERDO)

>>> b3.paquete(lado=IZQUIERDO)

>>> l = Etiqueta (ganar, "Esta etiqueta está sobre todos los botones")

>>> l.paquete()

>>> f.paquete()

Como hemos discutido anteriormente en el artículo, también puede usar el método place como administrador de geometría. El método de ubicación le permite colocar widgets en una ubicación específica dentro de una ventana o un marco. Sin embargo, no recomendamos usar el método place con frecuencia porque restringe la capacidad de respuesta del programa.

Con la función de cuadrícula, puede usar el parámetro 'sticky' que le permite usar las coordenadas del mapa (S, N, W, SW, NE, etc.) para especificar la ubicación de los widgets. Antes de pasar a la siguiente sección, asegúrese de comprender las funciones que hemos discutido hasta ahora. Pruebe la cuadrícula y las funciones del marco juntas para ver cómo puede usarlas en otros proyectos de GUI de Python.

Paso #6: Hacer que los Botones sean Útiles

Si hiciera clic en los botones que hemos creado hasta ahora, debe haber notado que no responden (no hacen nada). Se presionan cuando hace clic y se resaltan cuando pasa el mouse sobre ellos, pero no realizan ninguna función. Para que nuestros botones realicen funciones específicas, tendremos que usar la función 'configurar'.

Podemos pasar cualquier argumento de palabra clave al método de 'configuración' de un widget para pasarlo mientras lo creamos. Aquí hay un ejemplo:

>>> b1.configure(text=”Uno”)

El parámetro 'comando' vincula los botones a las funciones de devolución de llamada cuando los crea o les agrega 'configurar'. Para entender cómo funciona, crearemos una función que imprima un mensaje:

>>> def pero1():

… print(“Se pulsó el botón uno”)

…

>>> b1.configure(comando=pero1)

Entonces, cuando haga clic en el botón respectivo, imprimirá un mensaje.

Paso #7: Adición de widgets de entrada

Los widgets de entrada permiten a los usuarios ingresar texto en el programa. Sin embargo, tendríamos que hacer que el widget de entrada sea funcional como hicimos con los botones. Un widget de entrada tiene que recuperar (y establecer) texto. Para que el widget de entrada realice esta función, debe usar el objeto Tkinter 'StringVar'. El objeto 'StringVar' contiene el texto en forma de cadena y lo hace legible a través de get.

Crearemos una nueva ventana para probar nuestros widgets de entrada:

>>> ganar = Tk()

>>> v = VarCadena()

>>> e = Entrada(ganar,variabletexto=v)

>>> e.paquete()

Ahora agreguemos "esto es una prueba" como la entrada y recuperemos lo mismo a través de StringVar:

>>> v.obtener()

"esto es una prueba"

Ahora puede configurar el texto en StringVar y hacer que aparezca en el widget:

>>> v.set(“esto se establece desde el programa”)

Widget adicional: el widget Listbox

Además del widget de entrada, podemos agregar un widget de cuadro de lista. Un widget de cuadro de lista permite al usuario elegir un elemento de un menú. Crearemos una nueva ventana para probar el widget de cuadro de lista:

>>> ganar = Tk()

>>> lb = Listbox(ganar, altura=3)

>>> lb.paquete()

>>> lb.insertar(FIN, “primera entrada”)

>>> lb.insertar(FIN, “segunda entrada”)

>>> lb.insertar(FIN, “tercera entrada”)

>>> lb.insertar(FIN, “cuarta entrada”)

Puede insertar elementos al principio, en el medio y al final de la lista. También puede eliminarlos. Si hay demasiados elementos en la lista, puede agregar una barra de desplazamiento:

>>> sb = Barra de desplazamiento (ganar, orientar = VERTICAL)

>>> sb.pack(lado=IZQUIERDO, relleno=Y)

Para que nuestra barra de desplazamiento funcione, tendremos que usar funciones de devolución de llamada:

>>> sb.configure(comando=lb.yview)

>>> lb.configure(yscrollcommand=sb.set)

El método curselection le devuelve un elemento cuando lo selecciona en el cuadro de lista. Devolverá una tupla vacía si no elige ningún elemento.

Paso #8: Pasos finales

Usaremos todo lo que aprendimos en nuestro tutorial de Tkinter para crear un editor de listas de teléfonos:

Código total

#!/usr/bin/env python3

de tkinter importar *

de importación de teléfonos *

def cual_seleccionado():

imprimir(“En {0}”.format(select.curselection()))

volver int(seleccionar.curselección()[0])

def agregar_entrada():

phonelist.append([fnamevar.get(), lnamevar.get(), phonevar.get()])

establecer_seleccionar()

def actualizar_entrada():

phonelist[que_seleccionó()] = [fnamevar.get(),

nombrevar.get(),

phonevar.get()]

def eliminar_entrada():

del phonelist[que_seleccionó()]

establecer_seleccionar()

def cargar_entrada():

fname, lname, teléfono = lista de teléfonos [que_seleccionó ()]

fnombrevar.set(fnombre)

nombrevar.set(nombre)

phonevar.set(teléfono)

def crear_ventana():

fnamevar global, lnamevar, phonevar, seleccionar

ganar = Tk()

frame1 = Frame(ganar)

cuadro1.paquete()

Label(frame1, text=”First Name”).grid(row=0, column=0, sticky=W)

fnamevar = StringVar()

fname = Entrada (fotograma1, variable de texto = fnamevar)

fname.grid(fila=0, columna=1, adhesivo=W)

Etiqueta (marco 1, texto = "Apellido"). cuadrícula (fila = 1, columna = 0, adhesivo = W)

lnamevar = StringVar()

lname = Entrada (marco1, variable de texto = lnamevar)

lname.grid(fila=1, columna=1, fijo=W)

Etiqueta (marco 1, texto = "Teléfono"). cuadrícula (fila = 2, columna = 0, adhesivo = W)

phonevar = StringVar()

teléfono = Entrada (marco1, variable de texto = phonevar)

phone.grid(fila=2, columna=1, fijo=W)

frame2 = Frame(win) # Fila de botones

cuadro2.paquete()

b1 = Botón (cuadro2, texto = "Agregar", comando = agregar_entrada)

b2 = Botón(cuadro2, texto=”Actualizar”, comando=actualizar_entrada)

b3 = Botón(cuadro2, texto=”Eliminar”, comando=eliminar_entrada)

b4 = Botón (cuadro 2, texto = "Cargar", comando = cargar_entrada)

b5 = Botón (cuadro 2, texto = "Actualizar", comando = establecer_seleccionar)

b1.pack(lado=IZQUIERDO)

b2.pack(lado=IZQUIERDO)

b3.pack(lado=IZQUIERDO)

b4.pack(lado=IZQUIERDO)

b5.pack(lado=IZQUIERDO)

frame3 = Frame(win) # selección de nombres

cuadro3.paquete()

desplazamiento = barra de desplazamiento (fotograma 3, orientación = VERTICAL)

select = Listbox(frame3, yscrollcommand=scroll.set, height=6)

scroll.config(command=select.yview)

scroll.pack(lado=DERECHO, relleno=Y)

select.pack (lado = IZQUIERDO, relleno = AMBOS, expandir = 1)

volver a ganar

def set_select():

phonelist.sort(clave=registro lambda: registro[1])

seleccionar.eliminar(0, FIN)

para fname, lname, teléfono en la lista de teléfonos:

select.insert(END, “{0}, {1}”.format(lname, fname))

ganar = hacer_ventana()

establecer_seleccionar()

ganar.mainloop()

Aquí está la lista de teléfonos:

lista de teléfonos = [['Chris', 'Meyers', '241-343-4349'],

['Roberto', 'Smith', '202-689-1234'],

['Janet', 'Jones', '609-483-5432'],

['Ralph', 'Barnhart', '215-683-2341'],

['Eric', 'Nelson', '571-485-2689'],

['Ford', 'Prefecto', '703-987-6543'],

['María', 'Zigler', '812-567-8901'],

['Bob', 'Smith', '856-689-1234']]

El programa que compartimos aquí es un ejemplo. Puede crear su programa con las funciones que discutimos en este tutorial de Tkinter. El programa anterior carece de varias funcionalidades, como que no tiene la opción de guardar los cambios. Puede agregar la función de guardar usted mismo creando un botón que pueda realizar esta tarea.

Debe leer: Cadena de Markov en Python Tutorial

Obtenga más información sobre Python y los proyectos de interfaz gráfica de usuario de Python

Trabajar en proyectos de Python Tkinter puede ser muy divertido si sabes lo que estás haciendo. También son una excelente manera de comprender sus puntos fuertes (y débiles). Puedes aprender más sobre Python; Recomendamos dirigirse a nuestro blog. Aquí hay algunos recursos para leer más:

• 10 proyectos de GUI de Python
• Cómo hacer un chatbot en Python
• 42 ideas de proyectos Python

¿Cuáles son sus pensamientos sobre este proyecto? ¿Has trabajado en otros proyectos de Python Tkinter? Haznos saber.

Si tiene curiosidad por aprender sobre ciencia de datos, consulte el Programa ejecutivo PG en ciencia de datos de IIIT-B y upGrad, creado para profesionales que trabajan y ofrece más de 10 estudios de casos y proyectos, talleres prácticos, tutoría con expertos de la industria, 1 -on-1 con mentores de la industria, más de 400 horas de aprendizaje y asistencia laboral con las mejores empresas.