Manual Tkinter

MANUAL DE TKINTER
PYTHON
I.S.C. Liliana Guadalupe Hernández Rodríguez

Contenido
Widgets clásicos (tk) ............................................................................................................................... 4
Button ................................................................................................................................................. 4
Canvas................................................................................................................................................. 9
Checkbutton ..................................................................................................................................... 11
Entry ................................................................................................................................................. 13
Frame ................................................................................................................................................ 16
Label ................................................................................................................................................. 17
Listbox .............................................................................................................................................. 19
Menubutton...................................................................................................................................... 22
Menu ................................................................................................................................................ 24
Message ............................................................................................................................................ 27
Radiobutton ...................................................................................................................................... 29
Scrollbar ............................................................................................................................................ 32
Text ................................................................................................................................................... 34
Toplevel ............................................................................................................................................ 38
Spinbox ............................................................................................................................................. 40
Labelframe ........................................................................................................................................ 42
tkMessageBox................................................................................................................................... 43
Open File Dialog ................................................................................................................................ 45
Selección de Múltiples Archivos ........................................................................................................ 47
Abrir archivos directamente ............................................................................................................. 49
Widgets temáticos (ttk) ........................................................................................................................ 52
Combobox......................................................................................................................................... 54
Notebook .......................................................................................................................................... 57
Progressbar ....................................................................................................................................... 60
Separator .......................................................................................................................................... 64
Sizegrip ............................................................................................................................................. 65
Treeview ........................................................................................................................................... 67
Configuración de widgets ..................................................................................................................... 87
Command binding................................................................................................................................. 88
Event binding ........................................................................................................................................ 90
Gestión de geometría ........................................................................................................................... 94
Pack .................................................................................................................................................. 95
Grid ................................................................................................................................................. 102
Sticky........................................................................................................................................... 103
Padding ....................................................................................................................................... 106
Ejemplo de gestor de geometría de grid Tkinter ......................................................................... 106
Place ............................................................................................................................................... 109
Manejo de Imágenes .......................................................................................................................... 111
Formatos de archivo de Tkinter PhotoImage .................................................................................. 112
Cambio de tipo de imagen .............................................................................................................. 114
Cambio de tamaño de las imágenes (Resizing Images) ................................................................... 114
Transformación de color ................................................................................................................. 115
Conversión entre modos ............................................................................................................. 115
Mejoras de imagen ......................................................................................................................... 115
Recorte de imagen .......................................................................................................................... 116
Referencias ......................................................................................................................................... 118
Widgets clásicos (tk)
Los controles clásicos son los controles originales de Tk, a los cuales desde Python accedemos vía el
módulo tkinter (que generalmente se abrevia tk)
 Button
 Canvas
 Checkbutton
 Entry
 Frame
 Label
 LabelFrame
 Listbox
 Menu
 Menubutton
 Message
 OptionMenu
 PanedWindow
 Radiobutton
 Scale
 Scrollbar
 Spinbox
 Text
Button
El widget Button se utiliza para añadir botones en una aplicación Python. Estos botones pueden mostrar
texto o imágenes que transmiten el propósito de los botones. Se puede adjuntar una función o un
método a un botón que se llama automáticamente cuando se hace clic en el botón.
Sintaxis:
w = Button ( master, option = value, ... )
Parametros:
 master - Representa la ventana padre.
 options - Aquí está la lista de las opciones más utilizadas para este widget. Estas opciones
pueden utilizarse como pares clave-valor separados por comas.
Opción Descripción
Activebackground Color de fondo cuando el botón está bajo el
cursor.
Activeforeground Color de primer plano cuando el botón está bajo
el cursor.
bd Ancho del borde en píxeles. Por defecto es 2.
bg Color de fondo normal.
command Función o método que se llama cuando se hace
clic en el botón.
fg Color normal de primer plano (texto).
font Fuente de texto que se utilizará para la etiqueta
del botón.
height Altura del botón en líneas de texto (para botones
textuales) o en píxeles (para imágenes).
highlightcolor El color del resaltado del foco cuando el widget
tiene foco.
image Imagen que se mostrará en el botón (en lugar de
texto).
justify Cómo mostrar varias líneas de texto: LEFT para
ajustar cada línea a la izquierda; CENTER para
centrarlas; o RIGHT para ajustarlas a la derecha.
padx Relleno adicional a la izquierda y a la derecha del
texto.
pady Relleno adicional por encima y por debajo del
texto.
relief El relieve especifica el tipo de borde. Algunos de
los valores son SUNKEN, RAISED, GROOVE y
RIDGE.
state Establezca esta opción como DISABLED para que
el botón se vuelva gris y no responda. Tiene el
valor ACTIVE cuando el ratón está sobre él. Por
defecto es NORMAL.
underline Por defecto es -1, lo que significa que no se
subrayará ningún carácter del texto del botón. Si
no es negativo, se subrayará el carácter del texto
correspondiente
width Ancho del botón en letras (si muestra texto) o en
píxeles (si muestra una imagen).
wraplength Si este valor se establece como un número
positivo, las líneas de texto se envolverán para
ajustarse a esta longitud.
Métodos
Los siguientes son los métodos más utilizados para este widget
Método Descripción
flash() Hace que el botón parpadee varias veces entre
los colores activo y normal. Deja el botón en el
estado en que estaba originalmente. Se ignora si
el botón está desactivado.
invoke() Llama a la llamada de retorno del botón, y
devuelve lo que esa función devuelve. No tiene
efecto si el botón está desactivado o no hay
devolución de llamada.
Ejemplo
# !/usr/bin/python3
from tkinter import *
from tkinter import messagebox
top = Tk()
top.geometry("100x100")
def helloCallBack():
msg = messagebox.showinfo( "Hello Python", "Hello World")
B = Button(top, text = "Hello", command = helloCallBack)

B.place(x = 50,y = 50)
top.mainloop()
La función asociada a un botón no debe requerir ningún argumento. Sin embargo, en algunas ocasiones
es útil pasar información a dicha función: por ejemplo, si se encuentra en otro módulo, para que este
tenga a acceso a objetos del módulo principal.
Pasar los argumentos a command en el botón Tkinter con parciales

Una solución posible para esto es usar functools.partial().
import tkinter as tk
from functools import partial
from tkinter import messagebox, ttk
def suma(numero1 , numero2):

messagebox.showinfo(message=str(numero1+numero2), title="Suma")
root = tk.Tk()
root.config(width=300, height=200)
root.title("Botón en Tk")
numero1=2
numero2=5
boton = ttk.Button(text="¡Hola, mundo!", command=partial(suma, numero1,numero2))
boton.place(x=100, y=50)
root.mainloop()
Pasar los argumentos a command en Tkinter Button con la función lambda
Sintaxis de lambda: lambda: argument_list: expression
def suma(numero1 , numero2):

messagebox.showinfo(message=str(numero1+numero2), title="Suma")
root = tk.Tk()
numero1=2
numero2=5
boton = ttk.Button(text="¡Hola, mundo!", command=lambda: suma(numero1,numero2))
root.mainloop()
Llamada a función sin parámetros por medio de command:

from tkinter import DISABLED, messagebox, ttk
def suma():
numero1_ = numero1.get()
numero2_ = numero2.get()
messagebox.showinfo(message=int(numero1_)+int(numero2_), title="Suma")
if __name__ == "__main__":
root = tk.Tk()
numero1= tk.Entry(root)
numero1.place(x=30,y=20)
numero2= tk.Entry(root)
numero2.place(x=30,y=40)
boton = ttk.Button(text="Suma", command=suma)
root.mainloop()
Output:
Mismo ejercicio anterior en forma de clase:
from tkinter import DISABLED, messagebox, ttk
class ClaseSuma:
def suma(self):
numero1_ = self.numero1.get()
numero2_ = self.numero2.get()
messagebox.showinfo(message=int(numero1_)+int(numero2_), title="Suma")
def __init__(self):
self.root = tk.Tk()
self.root.config(width=300, height=200)
self.root.title("Botón en Tk")
self.numero1= tk.Entry(self.root)
self.numero1.place(x=30,y=20)
self.numero2= tk.Entry(self.root)
self.numero2.place(x=30,y=40)
self.boton = ttk.Button(text="Suma", command=self.suma)
self.boton.place(x=30, y=60)
self.root.mainloop()
suma =ClaseSuma()
Output:
Canvas
El widget Canvas se utiliza para dibujar formas, como líneas, óvalos, polígonos y rectángulos, en su
aplicación.
Sintaxis:
w = Canvas ( master, option = value, ... )
Parametros:
pueden utilizarse como pares clave-valor separados por comas.
confine Si es true (por defecto), el lienzo no puede ser
desplazado fuera de la región de desplazamiento.
cursor Cursor utilizado en el lienzo como flecha, círculo,
punto, etc.
height Tamaño del lienzo en la dimensión Y.
highlightcolor Color que se muestra en el resalte de enfoque.
relief El relieve especifica el tipo de borde. Algunos de
los valores son SUNKEN, RAISED, GROOVE y
RIDGE.
scrollregion Una tupla (w, n, e, s) que define sobre qué área
se puede desplazar el lienzo, donde w es el lado
izquierdo, n la parte superior, e el lado derecho y
s la parte inferior.
width Tamaño del lienzo en la dimensión X.
xscrollincrement Si establece esta opción en alguna dimensión
positiva, el lienzo sólo podrá posicionarse en
múltiplos de esa distancia, y el valor se utilizará
para el desplazamiento por unidades de
desplazamiento, como cuando el usuario hace
clic en las flechas de los extremos de una barra
de desplazamiento.
xscrollcommand Si el lienzo es desplazable, este atributo debe ser
el método .set() de la barra de desplazamiento
horizontal
yscrollincrement Funciona como xscrollincrement, pero gobierna
el movimiento vertical.
yscrollcommand Si el lienzo es desplazable, este atributo debe ser
el método .set() de la barra de desplazamiento
vertical.
El widget Canvas puede admitir los siguientes elementos estándar -
arc . Crea un elemento de arco, que puede ser una cuerda, un corte de pastel o un arco simple
coord = 10, 50, 240, 210
arc = canvas.create_arc(coord, start = 0, extent = 150, fill = "blue")
image . Crea un elemento de imagen, que puede ser una instancia de las clases BitmapImage o
PhotoImage.
filename = PhotoImage(file = "sunshine.gif")

image = canvas.create_image(50, 50, anchor = NE, image = filename)
line . Crea una línea.

line = canvas.create_line(x0, y0, x1, y1, ..., xn, yn, options)
oval . Crea un círculo o una elipse en las coordenadas dadas. Toma dos pares de coordenadas; las
esquinas superior izquierda e inferior derecha del rectángulo que delimita el óvalo.
oval = canvas.create_oval(x0, y0, x1, y1, options)
polygon. Crea un elemento de polígono que debe tener al menos tres vértices.
oval = canvas.create_polygon(x0, y0, x1, y1,...xn, yn, options)
Ejemplo.
# !/usr/bin/python3
top = Tk()
C = Canvas(top, bg = "blue", height = 250, width = 300)
coord = 10, 50, 240, 210

arc = C.create_arc(coord, start = 0, extent = 150, fill = "red")
line = C.create_line(10,10,200,200,fill = 'white')
C.pack()
top.mainloop()
Checkbutton
El widget Checkbutton se utiliza para mostrar una serie de opciones a un usuario como botones de
alternancia. El usuario puede entonces seleccionar una o más opciones haciendo clic en el botón
correspondiente a cada opción.
También puede mostrar imágenes en lugar de texto.
Sintaxis:
w = Checkbutton ( master, option, ... )
Parametros:
pueden utilizarse como pares clave-valor separados por comas
Activebackground Color de fondo cuando el botón está bajo el cursor.
Activeforeground Color de primer plano cuando el botón está bajo el cursor.
bitmap Para mostrar una imagen monocromática en un botón.
command Un procedimiento que será llamado cada vez que el usuario cambie el
estado de este botón de verificación.
cursor Si establece esta opción con un nombre de cursor (flecha, punto, etc.), el
cursor del ratón cambiará a ese patrón cuando esté sobre el botón de
verificación.
disabledforeground El color de primer plano utilizado para representar el texto de un botón de
verificación desactivado. El valor por defecto es una versión punteada del
color de primer plano por defecto.
fg El color utilizado para representar el texto.
font Fuente de texto.
height El número de líneas de texto en el botón de verificación. Por defecto es 1.
highlightcolor El color del resaltado del foco cuando el botón de verificación tiene el
foco.
image Para mostrar una imagen gráfica en el botón.
justify Si el texto contiene varias líneas, esta opción controla cómo se justifica el
texto: CENTER, LEFT o RIGHT.
offvalue Normalmente, la variable de control asociada a un botón de control se
pone a 0 cuando se desactiva (off). Puede proporcionar un valor
alternativo para el estado de desactivación estableciendo offvalue a ese
valor.
onvalue Normalmente, la variable de control asociada a un botón de control se
pondrá a 1 cuando esté activado. Puede proporcionar un valor alternativo
para el estado de encendido estableciendo onvalue a ese valor.
padx Cuánto espacio dejar a la izquierda y a la derecha del botón de verificación
y del texto. El valor por defecto es de 1 píxel.
pady Cuánto espacio dejar por encima y por debajo del botón de verificación y
del texto. Por defecto es 1 pixel
relief Con el valor por defecto, relieve = FLAT, el botón de verificación no se
destaca de su fondo. Puede establecer esta opción en cualquiera de los
otros estilos
selectcolor El color del botón de verificación cuando se establece. Por defecto es
selectcolor = "rojo".
selectimage Si establece esta opción en una imagen, esa imagen aparecerá en el botón
de verificación cuando se establezca.
state El valor por defecto es state = NORMAL, pero se puede utilizar state =
DISABLED para que el control se vuelva gris y no responda. Si el cursor está
actualmente sobre el botón de control, el estado es ACTIVO.
text La etiqueta que se muestra junto al botón de verificación. Utilice líneas
nuevas ("\n") para mostrar varias líneas de texto.
underline Con el valor por defecto de -1, no se subraya ninguno de los caracteres de
la etiqueta de texto. Establezca esta opción en el índice de un carácter del
texto (contando desde cero) para subrayar ese carácter.
variable La variable de control que rastrea el estado actual del botón de
verificación. Normalmente esta variable es una IntVar, y 0 significa
despejado y 1 significa establecido, pero vea las opciones offvalue y
onvalue arriba.
width La anchura por defecto de un botón de verificación viene determinada por
el tamaño de la imagen o del texto mostrado. Puede establecer esta
opción con un número de caracteres y el botón de verificación siempre
tendrá espacio para ese número de caracteres.
wraplength Normalmente, las líneas no se envuelven. Puede establecer esta opción en
un número de caracteres y todas las líneas se dividirán en trozos no más
largos que ese número.
Métodos
A continuación, se detallan los métodos más utilizados para este tipo de viñedos
deselect() Borra (desactiva) el checkbutton.
flash() Hace parpadear el checkbutton unas cuantas veces entre su color activo y
el normal, pero lo deja como empezó.
invoke() Puede llamar a este método para obtener las mismas acciones que
ocurrirían si el usuario hiciera clic en el botón de verificación para cambiar
su estado.
select() Selecciona el checkbutton
toggle() Borra el botón de verificación si está activado, lo activa si está desactivado.
Ejemplo.
# !/usr/bin/python3
import tkinter
top = Tk()
CheckVar1 = IntVar()
CheckVar2 = IntVar()
C1 = Checkbutton(top, text = "Music", variable = CheckVar1, \
onvalue = 1, offvalue = 0, height=5, \
width = 20, )
C2 = Checkbutton(top, text = "Video", variable = CheckVar2, \
onvalue = 1, offvalue = 0, height=5, \
width = 20)
C1.pack()
C2.pack()
top.mainloop()
Entry
El widget Entry se utiliza para aceptar cadenas de texto de una sola línea de un usuario.
Si quieres mostrar varias líneas de texto que puedan ser editadas, entonces debes utilizar el widget de
Texto.
Si desea mostrar una o más líneas de texto que no pueden ser modificadas por el usuario, entonces
debe utilizar el widget Etiqueta.
Sintaxis:
w = Entry( master, option, ... )
Parametros:
bg El color de fondo normal que se muestra detrás de la etiqueta y el indicador.
bd El tamaño del borde alrededor del indicador. Por defecto es de 2 píxeles.
estado de este botón de verificación.
cursor Si establece esta opción con un nombre de cursor (flecha, punto, etc.), el
cursor del ratón cambiará a ese patrón cuando esté sobre el campo.
font Fuente de texto.
exportselection Por defecto, si se selecciona texto dentro de un widget de Entrada, se
exporta automáticamente al portapapeles. Para evitar esta exportación,
utilice exportselection = 0.
fg El color utilizado para representar el texto.
highlightcolor El color del resaltado del foco cuando el campo tiene el focus
texto: CENTER, LEFT o RIGHT.
destaca de su fondo. Puede establecer esta opción en cualquiera de los otros
estilos
selectbackground El color de fondo que se utilizará para mostrar el texto seleccionado.
selectborderwidth El ancho del borde que se utilizará alrededor del texto seleccionado. El valor
por defecto es de un píxel
selectforeground El color de primer plano (texto) del texto seleccionado.
show Normalmente, los caracteres que el usuario escribe aparecen en la entrada.
Para hacer una entrada password. que se haga eco de cada carácter como
un asterisco, establezca show = "*".
state El valor por defecto es state = NORMAL, pero se puede utilizar state =
DISABLED para que el control se vuelva gris y no responda. Si el cursor está
actualmente sobre el campo, el estado es ACTIVE.
textvariable Para poder recuperar el texto actual de su widget de entrada, debe
establecer esta opción a una instancia de la clase StringVar.
width La anchura por defecto de un botón de verificación viene determinada por el
tamaño de la imagen o del texto mostrado. Puede establecer esta opción
con un número de caracteres y el botón de verificación siempre tendrá
espacio para ese número de caracteres.
xscrollcommand Si espera que los usuarios introduzcan a menudo más texto que el tamaño
en pantalla del widget, puede vincular su widget de entrada a una barra de
desplazamiento.
Métodos
A continuación, se detallan los métodos más utilizados para este tipo de widget
delete ( first, last = None ) Elimina los caracteres del widget, empezando por el que está en el
primer índice, hasta el último carácter, pero sin incluirlo. Si se omite
el segundo argumento, sólo se elimina el carácter de la primera
posición.
get() Devuelve el texto actual de la entrada como una cadena.
icursor(index) Coloca el cursor de inserción justo antes del carácter en el índice
dado.
index(index) Desplaza el contenido de la entrada para que el carácter del índice
dado sea el más visible a la izquierda. No tiene efecto si el texto se
ajusta completamente a la entrada.
insert ( index, s ) Inserta la cadena s antes del carácter en el índice dado.
select_adjust ( index ) Este método se utiliza para asegurarse de que la selección incluye el
carácter en el índice especificado.
select_clear() Borra la selección. Si no hay actualmente una selección, no tiene
efecto.
select_from ( index ) Establece la posición del índice ANCHOR en el carácter seleccionado
por el índice, y selecciona ese carácter.
select_present() Si hay una selección, devuelve true, sino devuelve false.
select_range ( start, end ) Establece la selección bajo el control del programa. Selecciona el
texto a partir del índice inicial, hasta el carácter del índice final, pero
sin incluirlo. La posición inicial debe ser anterior a la posición final.
select_to ( index ) Selecciona todo el texto desde la posición ANCHOR hasta el carácter
del índice dado, pero sin incluirlo.
xview ( index ) Este método es útil para vincular el widget Entrada a una barra de
desplazamiento horizontal.
xview_scroll ( number, what Se utiliza para desplazar la entrada horizontalmente. El argumento

) what debe ser UNITS, para desplazarse por el ancho de los caracteres,
o PAGES, para desplazarse por trozos del tamaño del widget de la
entrada. El número es positivo para desplazarse de izquierda a
derecha, y negativo para desplazarse de derecha a izquierda.
Ejemplo.
top = tk.Tk()
L1 = tk.Label(top, text = "User Name")
L1.pack( side = tk.LEFT)
E1 = tk.Entry(top, bd = 5)
E1.pack(side = tk.RIGHT)
top.mainloop()
Output:
Frame
El widget Marco es muy importante para el proceso de agrupación y organización de otros widgets de
una manera amigable. Funciona como un contenedor, que es responsable de organizar la posición de
otros widgets.
Utiliza áreas rectangulares en la pantalla para organizar el diseño y proporcionar el relleno de estos
widgets. Un marco también puede ser utilizado como una clase base para implementar widgets
complejos.
Sintaxis:
w = Frame ( master, option, ... )
Parametros:
bg El color de fondo normal que se muestra detrás de la etiqueta y el
indicador.
bd El tamaño del borde alrededor del indicador. Por defecto es de 2
píxeles.
cursor Si establece esta opción con un nombre de cursor (arrow, dot, etc.), el
cursor del ratón cambiará a ese patrón cuando esté sobre el campo.
heigh Dimensión vertical del frame
highlightbackground El color del resaltado cuando el frame no tiene el focus
highlightcolor El color del resaltado cuando el frame tiene el focus
highlightthickness Espesor del resalte de enfoque.
destaca de su fondo. Puede establecer esta opción en cualquiera de
los otros estilos
width La anchura por defecto de un botón de verificación viene determinada
por el tamaño de la imagen o del texto mostrado. Puede establecer
esta opción con un número de caracteres y el botón de verificación
siempre tendrá espacio para ese número de caracteres.
Ejemplo.
# !/usr/bin/python3
root = Tk()
frame = Frame(root)
frame.pack()
bottomframe = Frame(root)
bottomframe.pack( side = BOTTOM )
redbutton = Button(frame, text = "Red", fg = "red")
redbutton.pack( side = LEFT)
greenbutton = Button(frame, text = "Brown", fg="brown")

greenbutton.pack( side = LEFT )
bluebutton = Button(frame, text = "Blue", fg = "blue")

bluebutton.pack( side = LEFT )
blackbutton = Button(bottomframe, text = "Black", fg = "black")

blackbutton.pack( side = BOTTOM)
root.mainloop()
Label
Este widget implementa una caja de visualización en la que puede colocar texto o imágenes. El texto
mostrado por este widget puede actualizarse en cualquier momento que se desee.
También es posible subrayar parte del texto (como para identificar un atajo de teclado) y extender el
texto en varias líneas.
Sintaxis:
w = Label ( master, option, ... )
Parametros:
anchor Esta opción controla dónde se posiciona el texto si el widget tiene más espacio
del que necesita el texto. El valor por defecto es anchor = CENTER, que centra el
texto en el espacio disponible.
bg El color de fondo normal que se muestra detrás de la etiqueta y el indicador.
bitmap Si esta opción es igual a bitmap o image, la etiqueta mostrará ese gráfico.
Bd El tamaño del borde alrededor del indicador. Por defecto es de 2 píxeles
Cursor Si establece esta opción con un nombre de cursor (flecha, punto, etc.), el cursor
del ratón cambiará a ese patrón cuando esté sobre el botón de verificación.
Font Si está mostrando texto en esta etiqueta (con la opción text o textvariable, la
opción font especifica en qué fuente se mostrará ese texto.
Fg Si está mostrando texto o un mapa de bits en esta etiqueta, esta opción
especifica el color del texto. Si está mostrando un mapa de bits, este es el color
que aparecerá en la posición de los bits de 1 en el mapa de bits.
Height La dimensión vertical del nuevo marco.
Image Para mostrar una imagen estática en el widget de la etiqueta, establezca esta
opción en un objeto de imagen
Justify Especifica cómo se alinearán varias líneas de texto entre sí: IZQUIERDA para la
izquierda, CENTRO para el centrado (por defecto), o DERECHA para el
justificado a la derecha.
Padx Espacio extra añadido a la izquierda y a la derecha del texto dentro del widget.
Por defecto es 1.
pady Espacio extra añadido por encima y por debajo del texto dentro del widget. Por
defecto es 1.
relief Especifica la apariencia de un borde decorativo alrededor de la etiqueta. El
valor por defecto es FLAT; para otros valores.
text Para mostrar una o más líneas de texto en un widget de etiqueta, establezca
esta opción en una cadena que contenga el texto. Las nuevas líneas internas
("\n") forzarán un salto de línea.
textvariable Para esclavizar el texto mostrado en un widget de etiqueta a una variable de
control de la clase StringVar, establezca esta opción a esa variable.
underline Puede mostrar un subrayado (_) debajo de la enésima letra del texto, contando
desde 0, estableciendo esta opción como n. El valor por defecto es subrayado =
-1, lo que significa que no hay subrayado.
width Ancho de la etiqueta en caracteres (¡no en píxeles!). Si no se establece esta
opción, el tamaño de la etiqueta se ajustará a su contenido.
wraplength Puede limitar el número de caracteres de cada línea configurando esta opción
con el número deseado. El valor por defecto, 0, significa que las líneas se
romperán sólo en las nuevas líneas.
Ejemplo.
# !/usr/bin/python3
root = Tk()
var = StringVar()
label = Label( root, textvariable = var, relief = RAISED )
var.set("Hey!? How are you doing?")

label.pack()
root.mainloop()
Listbox
El widget Listbox se utiliza para mostrar una lista de elementos de la que el usuario puede seleccionar un
número de elementos
Sintaxis:
w = Listbox (master, option, ... )
Parametros:
indicador.
bd El tamaño del borde alrededor del indicador. Por defecto es de 2 píxeles
cursor El cursor que aparece cuando el ratón está sobre el cuadro de lista.
font Fuente del texto dentro del listbox
fg Color del texto del listbox
height La dimensión vertical del nuevo marco.
highlightcolor Color mostrado cuando el listbox tiene el focus
highlighttickness Grosor del resalte de enfoque.
relief Selecciona los efectos de sombreado de los bordes tridimensionales. El
valor por defecto es SUNKEN.
selectbackground Color de fondo para mostrar texto seleccionado
selectmode Determina cuántos elementos se pueden seleccionar y cómo afecta el
arrastre del ratón a la selección:
 BROWSE - Normalmente, sólo se puede seleccionar una línea de

un cuadro de lista. Si hace clic en un elemento y luego arrastra a
una línea diferente, la selección seguirá al ratón. Esta es la opción
por defecto.
 SIMPLE - Sólo puede seleccionar una línea, y no puede arrastrar el
ratón. Siempre que haga clic en el botón 1, esa línea queda
seleccionada.
 MÚLTIPLE - Puede seleccionar cualquier número de líneas a la
vez. Al hacer clic en cualquier línea se cambia si está seleccionada
o no.
 EXTENDIDO - Puede seleccionar cualquier grupo de líneas
adyacentes a la vez haciendo clic en la primera línea y
arrastrando hasta la última.
width Ancho de la etiqueta en caracteres, el default es 20.

xscrollcommand Si quieres permitir que el usuario se desplace horizontalmente por la caja
de lista, puedes vincular tu widget de caja de lista a una barra de
desplazamiento horizontal
yscrollcommand Si quieres permitir que el usuario se desplace verticalmente por la caja de
lista, puedes vincular tu widget de caja de lista a una barra de
desplazamiento vertical.
Métodos
activate ( index ) Selecciona la línea especificada por el índice dado.
curselection() Devuelve una tupla que contiene los números de línea del elemento o
elementos seleccionados, contando desde 0. Si no se selecciona nada,
devuelve una tupla vacía.
delete ( first, last = None Elimina las líneas cuyos índices están en el rango [primero, último]. Si se
) omite el segundo argumento, se elimina la única línea con índice primero.
get ( first, last = None ) Devuelve una tupla que contiene el texto de las líneas con índices del
primero al último, ambos inclusive. Si se omite el segundo argumento,
devuelve el texto de la línea más cercana a la primera.
index ( i ) Si es posible, posiciona la parte visible del listbox para que la línea que
contiene el índice i esté en la parte superior del widget.
insert ( index, *elements Inserta una o más líneas nuevas en el cuadro de lista antes de la línea
) especificada por el índice. Utilice FIN como primer argumento si desea
añadir nuevas líneas al final del cuadro de lista.
nearest ( y ) Devuelve el índice de la línea visible más cercana a la coordenada y relativa

al widget listbox.
see ( index ) Ajusta la posición de la caja de lista para que la línea referida por el índice
sea visible.
size() Devuelve el número de líneas en el cuadro de lista.

xview() Para hacer que el cuadro de lista sea desplazable horizontalmente,
establezca la opción de comando de la barra de desplazamiento horizontal
asociada a este método.
xview_moveto ( fraction Desplaza el listbox de forma que la fracción más a la izquierda de la

) anchura de su línea más larga quede fuera del lado izquierdo del listbox.
La fracción está en el rango [0,1].
xview_scroll ( number, Desplaza el cuadro de lista horizontalmente. Para el argumento qué, utilice
what ) UNIDADES para desplazarse por caracteres, o PÁGINAS para desplazarse
por páginas, es decir, por el ancho del cuadro de lista. El argumento
número indica el número de páginas a desplazar.
yview() Para hacer que el cuadro de lista sea desplazable verticalmente, establezca
la opción de comando de la barra de desplazamiento vertical asociada a
este método.
yview_moveto ( fraction Desplaza el listbox para que la fracción superior del ancho de su línea más
) larga quede fuera del lado izquierdo del listbox. La fracción está en el rango
[0,1].
yview_scroll ( number, Desplaza la caja de lista verticalmente. Para el argumento qué, utilice
what ) UNIDADES para desplazarse por líneas, o PÁGINAS para desplazarse por
páginas, es decir, por la altura del cuadro de lista. El argumento número
indica el número de páginas a desplazar.
Ejemplo.
# !/usr/bin/python3
import tkinter
top = Tk()
Lb1 = Listbox(top)
Lb1.insert(1, "Python")
Lb1.insert(2, "Perl")
Lb1.insert(3, "C")
Lb1.insert(4, "PHP")
Lb1.insert(5, "JSP")
Lb1.insert(6, "Ruby")
Lb1.pack()
top.mainloop()
Menubutton
Un menubutton es la parte de un menú desplegable que permanece en la pantalla todo el tiempo. Cada
menubutton está asociado a un widget de Menú que puede mostrar las opciones de ese menubutton
cuando el usuario hace clic en él.
Sintaxis:
w = Menubutton (master, option, ... )
Parametros:
activebackground El color de fondo cuando el mouse se encuentra encima del menú.
activeforeground El color de primer plano cuando el ratón está sobre el botón de menú.
anchor Esta opción controla dónde se posiciona el texto si el widget tiene más
espacio del que necesita el texto. El valor por defecto es anchor =
CENTER, que centra el texto.
indicador.
bd El tamaño del borde alrededor del indicador. Por defecto es de 2 píxeles
bitmap Para mostrar un mapa de bits en el botón de menú, establezca esta
opción con un nombre de mapa de bits.
cursor El cursor que aparece cuando el ratón está sobre el menú
direction Establezca la dirección = LEFT para mostrar el menú a la izquierda del
botón; utilice la dirección = RIGHT para mostrar el menú a la derecha del
botón; o utilice la dirección = "above" para colocar el menú encima del
botón
disableforeground El color de primer plano que se muestra en este botón de menú cuando
está desactivado.
fg El color de primer plano cuando el ratón no está sobre el menubutton
height La altura del menubutton en líneas de texto (no en píxeles). Por defecto
se ajusta el tamaño del menubutton a su contenido.
highlightcolor Color mostrado cuando el menubutton tiene el focus
highlighttickness Grosor del resalte de enfoque.
image Muestra una imagen en el menubutton
justify Esta opción controla dónde se ubica el texto cuando el texto no llena el
menubutton: use justify = IZQUIERDA para justificar el texto a la izquierda
(esto es lo predeterminado); use justify = CENTRO para centrarlo, o justify
= DERECHA para justificar a la derecha.
menu Para asociar el menubutton con un conjunto de opciones, establezca esta
opción al objeto Menú que contiene esas opciones. Ese objeto menú
debe haber sido creado pasando el menubutton asociado al constructor
como su primer argumento.
padx Cuánto espacio dejar a la izquierda y a la derecha del texto del
menubutton. Por defecto es 1.
pady Cuánto espacio dejar por encima y por debajo del texto del menubutton.
Por defecto es 1.
valor por defecto es RAISED.
state Normalmente, los menubotones responden al ratón. Establezca state =
DISABLED para que el botón de menú se vuelva gris y no responda.
selectbackground Color de fondo para mostrar texto seleccionado
text Para mostrar texto en el botón de menú, establezca esta opción en la
cadena que contiene el texto deseado. Las nuevas líneas ("\n") dentro de
la cadena provocarán saltos de línea.
textvariable Puede asociar una variable de control de la clase StringVar con este botón
de menú. Al establecer esa variable de control se cambiará el texto
mostrado.
underline Normalmente, no aparece ningún subrayado bajo el texto del botón de
menú. Para subrayar uno de los caracteres, establezca esta opción en el
índice de ese carácter.
width Ancho de la etiqueta en caracteres, el default es 20.
wraplength Normalmente, las líneas no se envuelven. Puede establecer esta opción
en un número de caracteres y todas las líneas se dividirán en trozos no
más largos que ese número.
Ejemplo.
# !/usr/bin/python3
import tkinter
top = Tk()
mb = Menubutton ( top, text = "condiments", relief = RAISED )

mb.grid()
mb.menu = Menu ( mb, tearoff = 0 )
mb["menu"] = mb.menu
mayoVar = IntVar()
ketchVar = IntVar()
mb.menu.add_checkbutton ( label = "mayo",

variable = mayoVar )
mb.menu.add_checkbutton ( label = "ketchup",
variable = ketchVar )
mb.pack()
top.mainloop()
Menu
El objetivo de este widget es permitirnos crear todo tipo de menús que puedan ser utilizados por
nuestras aplicaciones. La funcionalidad principal proporciona formas de crear tres tipos de menú:
emergente, de nivel superior y desplegable.
También es posible utilizar otros widgets extendidos para implementar nuevos tipos de menús, como el
widget OptionMenu, que implementa un tipo especial que genera una lista emergente de elementos
dentro de una selección.
Sintaxis:
w = Menu (master, option, ... )
Parametros:
activebackground El color de fondo cuando el mouse se encuentra encima del menú.
activeborderwidth Especifica el ancho de un borde dibujado alrededor de una opción cuando
está bajo el ratón. El valor predeterminado es 1 píxel.
activeforeground El color de primer plano cuando el ratón está sobre el botón de menú.
bg El color de fondo para las opciones que no están bajo el ratón.

bd El tamaño del borde alrededor del indicador. Por defecto es 1
cursor El cursor que aparece cuando el ratón está sobre las opciones, pero sólo
cuando el menú ha sido arrancado.
disableforeground El color del texto para los elementos cuyo estado es DISABLED.
fg El color de primer plano utilizado para las opciones que no están bajo el
ratón.
font Fuente del texto de las opciones del menu
postcommand Puede establecer esta opción en un procedimiento
valor por defecto es RAISED.
selectcolor Especifica el color que se muestra en los botones de verificación y radio
cuando se seleccionan
tearoff Normalmente, un menú puede ser arrancado, la primera posición
(posición 0) de la lista de opciones está ocupada por el elemento de
arrancar, y las opciones adicionales se añaden a partir de la posición 1. Si
establece tearoff = 0, el menú no tendrá la función de tear-off, y las
opciones se añadirán comenzando en la posición 0.
title Normalmente, el título de una ventana de menú desplegable será el
mismo que el texto del menubutton o de la cascada que lleva a este
menú. Si desea cambiar el título de esa ventana, establezca la opción de
título con esa cadena.
Métodos
add_command (options) Agrega un element al menú.
add_radiobutton( Crea un element de tipo radiobutton en el menú.

options )
add_checkbutton( Crea un elemento de tipo check button en el menú.

options )
add_cascade(options) Crea un nuevo menú jerárquico asociando un menú dado a un menú padre
add_separator() Agrega una línea separadora al menú.
add( type, options ) Agrega un tipo especifico de elemento al menú
delete( startindex [, Elimina los elementos del menú que van desde startindex hasta endindex..
endindex ])
entryconfig( index, Permite modificar un elemento del menú, identificado por el índice, y
options ) cambiar sus opciones.
index(item) Devuelve el número de índice del elemento de menú dado.
insert_separator ( index ) Inserta un nuevo separador en la posición especificada por el índice.
invoke ( index ) Llama a la llamada de retorno del comando asociado con la opción en la
posición índice. Si se trata de un botón de verificación, su estado se alterna
entre el establecido y el despejado; si se trata de un botón de radio, esa
elección se establece.
type ( index ) Retorna el tipo de la opción especificada por index: either "cascade",
"checkbutton", "command", "radiobutton", "separator", or "tearoff".
Ejemplo.
# !/usr/bin/python3
def donothing():
filewin = Toplevel(root)
button = Button(filewin, text="Do nothing button")
button.pack()
root = Tk()
menubar = Menu(root)
filemenu = Menu(menubar, tearoff = 0)
filemenu.add_command(label="New", command = donothing)
filemenu.add_command(label = "Open", command = donothing)
filemenu.add_command(label = "Save", command = donothing)
filemenu.add_command(label = "Save as...", command = donothing)
filemenu.add_command(label = "Close", command = donothing)
filemenu.add_separator()
filemenu.add_command(label = "Exit", command = root.quit)

menubar.add_cascade(label = "File", menu = filemenu)
editmenu = Menu(menubar, tearoff=0)
editmenu.add_command(label = "Undo", command = donothing)
editmenu.add_separator()
editmenu.add_command(label = "Cut", command = donothing)

editmenu.add_command(label = "Copy", command = donothing)
editmenu.add_command(label = "Paste", command = donothing)
editmenu.add_command(label = "Delete", command = donothing)
editmenu.add_command(label = "Select All", command = donothing)
menubar.add_cascade(label = "Edit", menu = editmenu)

helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label = "Help Index", command = donothing)
helpmenu.add_command(label = "About...", command = donothing)
menubar.add_cascade(label = "Help", menu = helpmenu)
root.config(menu = menubar)
root.mainloop()
Message
Este widget proporciona un objeto multilínea y no editable que muestra textos, rompiendo
automáticamente las líneas y justificando su contenido.
Su funcionalidad es muy similar a la proporcionada por el widget Etiqueta, salvo que también puede
envolver automáticamente el texto, manteniendo una anchura o relación de aspecto determinada.
Sintaxis:
w = Message (master, option, ... )
Parametros:
anchor Esta opción controla dónde se posiciona el texto si el widget tiene más
espacio del que necesita el texto. El valor por defecto es anchor =
CENTER, que centra el texto en el espacio disponible.
bd El tamaño del borde alrededor del indicador. Por defecto es 2
bitmap Si esta opción es igual a un mapa de bits o a un objeto de imagen, la
etiqueta mostrará ese gráfico.
cursor del ratón cambiará a ese patrón cuando esté sobre el botón de
verificación.
fg Si está mostrando texto o un mapa de bits en esta etiqueta, esta opción
especifica el color del texto. Si está mostrando un mapa de bits, este es el
color que aparecerá en la posición de los bits de 1 en el mapa de bits.
font Si está mostrando texto en esta etiqueta (con la opción text o
textvariable, la opción font especifica en qué fuente se mostrará ese
texto.
image Para mostrar una imagen estática en el widget de la etiqueta, establezca
esta opción en un objeto de imagen.
justify Especifica cómo se alinearán varias líneas de texto entre sí: LEFT para la
izquierda, CENTER para el centrado (por defecto), o RIGHT para el
justificado a la derecha.
padx Espacio extra añadido a la izquierda y a la derecha del texto dentro del
widget. Por defecto es 1
pady Espacio extra añadido por encima y por debajo del texto dentro del
widget. Por defecto es 1.
valor por defecto es FLAT.
text Para mostrar una o más líneas de texto en un widget de etiqueta,
establezca esta opción en una cadena que contenga el texto. Las nuevas
líneas internas ("\n") forzarán un salto de línea.
textvariable Para esclavizar el texto mostrado en un widget de etiqueta a una variable
de control de la clase StringVar, establezca esta opción a esa variable.
underline Puede mostrar un subrayado (_) debajo de la enésima letra del texto,
contando desde 0, estableciendo esta opción como n. El valor por defecto
es subrayado = -1, lo que significa que no hay subrayado.
width Ancho de la etiqueta en caracteres (¡no en píxeles!). Si no se establece
esta opción, el tamaño de la etiqueta se ajustará a su contenido.
wraplength Puede limitar el número de caracteres de cada línea configurando esta
opción con el número deseado. El valor por defecto, 0, significa que las
líneas se romperán sólo en las nuevas líneas.
Ejemplo
# !/usr/bin/python3
root = Tk()
var = StringVar()
label = Message( root, textvariable = var, relief = RAISED )
var.set("Hey!? How are you doing?")

label.pack()
root.mainloop()
Radiobutton
Este widget implementa un botón de elección múltiple, que es una forma de ofrecer muchas selecciones
posibles al usuario y permitirle elegir sólo una de ellas.
Para implementar esta funcionalidad, cada grupo de radionbuttons debe estar asociado a la misma
variable y cada uno de los botones debe simbolizar un único valor. Se puede utilizar la tecla Tab para
pasar de un radionbutton a otro.
Sintaxis:
w = Radiobutton (master, option, ... )
Parametros:
activebackground El color de fondo cuando el ratón está sobre el radiobutton
activeforeground El color de primer plano cuando el ratón está sobre el radiobutton.
anchor Si el widget ocupa un espacio mayor del que necesita, esta opción
especifica dónde se situará el radiobutton en ese espacio. El valor por
defecto es anchor = CENTER.
bitmap Si esta opción es igual a un mapa de bits o a un objeto de imagen, la
etiqueta mostrará ese gráfico.
borderwidth El tamaño del borde alrededor de la parte del indicador en sí. Por defecto
es de 2 píxeles.
estado de este radiobutton.
cursor del ratón cambiará a ese patrón cuando esté sobre el radiobutton.
fg Color del texto
font Fuente del texto
height El número de líneas (no píxeles) de texto en el botón de radio. Por
defecto es 1.
highlightbackground El color del resaltado del foco cuando el radiobutton no tiene foco.
highlightcolor El color del resaltado del foco cuando el radiobutton tiene el foco.
image Para mostrar una imagen estática en el widget de la etiqueta, establezca
esta opción en un objeto de imagen.
texto: CENTER (por defecto), LEFT o RIGHT.
padx Cuánto espacio dejar a la izquierda y a la derecha del radiobotón y del
texto. Por defecto es 1.
pady Cuánto espacio dejar por encima y por debajo del botón de radio y del
texto. Por defecto es 1.
selectcolor El color del radiobutton cuando se selecciona. Por defecto es rojo.
selectimage Si está utilizando la opción de imagen para mostrar un gráfico en lugar de
texto cuando el botón de radio está desactivado, puede establecer la
opción selectimage a una imagen diferente que se mostrará cuando el
botón de radio está activado.
state El valor por defecto es estado = NORMAL, pero se puede establecer
estado = DISABLED para que el control se vuelva gris y no responda. Si el
cursor está actualmente sobre el botón de radio, el estado es ACTIVE.
text Etiqueta mostrada a lado del radiobutton.
textvariable Para esclavizar el texto mostrado en un widget de etiqueta a una variable
de control de la clase StringVar, establezca esta opción a esa variable.
underline Puede mostrar un subrayado (_) debajo de la enésima letra del texto,
contando desde 0, estableciendo esta opción como n. El valor por defecto
es subrayado = -1, lo que significa que no hay subrayado.
value Cuando un botón de radio es activado por el usuario, su variable de
control se establece en su opción de valor actual. Si la variable de control
es una IntVar, dé a cada botón de radio del grupo una opción de valor
entero diferente. Si la variable de control es una StringVar, dé a cada
radiobutton una opción de valor de cadena diferente.
wraplength Puede limitar el número de caracteres de cada línea configurando esta
opción con el número deseado. El valor por defecto, 0, significa que las
líneas se romperán sólo en las nuevas líneas.
Métodos
deselect() Limpia el radiobutton
flash() Hace parpadear el botón de radio unas cuantas veces entre su color activo y el normal,
pero lo deja como empezó.
invoke() Puede llamar a este método para obtener las mismas acciones que ocurrirían si el usuario
hiciera clic en el radiobutton para cambiar su estado.
select() Selecciona el radiobutton
Ejemplo
# !/usr/bin/python3
def sel():
selection = "You selected the option " + str(var.get())
label.config(text = selection)
root = Tk()
var = IntVar()
R1 = Radiobutton(root, text = "Option 1", variable = var, value = 1,
command = sel)
R1.pack( anchor = W )

command = sel)
R2.pack( anchor = W )

command = sel)
R3.pack( anchor = W)
label = Label(root)
label.pack()
root.mainloop()
Scrollbar
Este widget proporciona un controlador de deslizamiento que se utiliza para implementar widgets de
desplazamiento vertical, como Listbox, Text y Canvas. Tenga en cuenta que también puede crear barras
de desplazamiento horizontales en los widgets de entrada.
Sintaxis:
w = Scrollbar (master, option, ... )
Parametros:
activebackground El color del deslizador y de las puntas de flecha cuando el ratón está
sobre ellos.
bg El color del deslizador y de las puntas de flecha cuando el ratón no está
sobre ellos.
bd El ancho de los bordes 3D alrededor de todo el perímetro de la cubeta, y
también el ancho de los efectos 3D en las puntas de flecha y el deslizador.
Por defecto, no hay borde alrededor de la cubeta, y un borde de 2 píxeles
alrededor de las puntas de flecha y el deslizador.
command Un procedimiento que se llama cada vez que se mueve la barra de
desplazamiento.
cursor del ratón aparecerá cuando el mouse está encima del scrollbar.
elementborderwidth El ancho de los bordes alrededor de las puntas de flecha y del deslizador.
El valor por defecto es elementborderwidth = -1, lo que significa utilizar el
valor de la opción borderwidth.
highlightbackground El color del resaltado del foco cuando el scrollbar no tiene focus.
highlightcolor El color del resaltado del foco cuando el scrollbar tiene el focus.
highlightthickness El grosor del resaltado de enfoque. El valor predeterminado es 1.
Establezca 0 para suprimir la visualización del resaltado de enfoque.
jump Esta opción controla lo que ocurre cuando un usuario arrastra el
deslizador. Normalmente (salto = 0), cada pequeño arrastre del
deslizador hace que se llame al callback del comando. Si estableces esta
opción a 1, la llamada de retorno no se llama hasta que el usuario suelta
el botón del ratón.
orient Establezca orient = HORIZONTAL para una barra de desplazamiento
horizontal, orient = VERTICAL para una vertical.
repeatdelay Esta opción controla el tiempo que el botón 1 debe mantenerse pulsado
en el canal antes de que el deslizador comience a moverse en esa
dirección repetidamente. Por defecto es repeatdelay = 300, y las
unidades son milisegundos.
repeatinterval Intervalo de repetición
takefocus Normalmente, puedes tabular el foco a través de un widget de barra de
desplazamiento. Establezca takefocus = 0 si no desea este
comportamiento.
troughcolor El color del canal.
width Ancho de la barra de desplazamiento (su dimensión y si es horizontal, y su
dimensión x si es vertical). El valor por defecto es 16.
Métodos
get() Devuelve dos números (a, b) que describen la posición actual del deslizador. El
valor a da la posición del borde izquierdo o superior del deslizador, para barras de
desplazamiento horizontales y verticales respectivamente; el valor b da la
posición del borde derecho o inferior.
set ( first, last ) Para conectar una barra de desplazamiento a otro widget w, establezca
xscrollcommand o yscrollcommand de w al método set() de la barra de
desplazamiento. Los argumentos tienen el mismo significado que los valores
devueltos por el método get().
Ejemplo
# !/usr/bin/python3
root = Tk()
scrollbar = Scrollbar(root)
scrollbar.pack( side = RIGHT, fill = Y )
mylist = Listbox(root, yscrollcommand = scrollbar.set )

for line in range(100):
mylist.insert(END, "This is line number " + str(line))
mylist.pack( side = LEFT, fill = BOTH )

scrollbar.config( command = mylist.yview )
mainloop()
Text
Los widgets de texto ofrecen funciones avanzadas que permiten editar un texto de varias líneas y
formatear la forma en que debe mostrarse, como cambiar su color y fuente.
También puedes utilizar elegantes estructuras como pestañas y marcas para localizar secciones
específicas del texto y aplicar cambios en esas áreas. Además, puedes incrustar ventanas e imágenes en
el texto, ya que este widget ha sido diseñado para manejar tanto texto plano como formateado.
Sintaxis:
w = Text (master, option, ... )
Parametros:
bg El color de fondo del widget de texto
bd El ancho del borde alrededor del widget de texto. Por defecto es de 2
píxeles.
cursor Es el cursor que aparece cuando el mouse se encuentra en el widget de
texto.
exportselection Normalmente, el texto seleccionado dentro de un widget de texto se
exporta para ser la selección en el gestor de ventanas. Establezca
exportselection = 0 si no desea ese comportamiento.
fg Color del texto
height El número de líneas (no píxeles) de texto en el botón de radio. Por
defecto es 1.
highlightbackground El color del resaltado del foco cuando el widget no tiene foco.
highlightcolor El color del resaltado del foco cuando el widget tiene el foco.
highlightthickness El grosor del resaltado de enfoque. Por defecto es 1. Establezca
highlightthickness = 0 para suprimir la visualización del resaltado de
enfoque.
insertbackground El color del cursor de inserción. Por defecto es negro.
insertborderwidth Size of the 3-D border around the insertion cursor. Default is 0.
insertofftime El número de milisegundos que el cursor de inserción está apagado
durante su ciclo de parpadeo. Establezca esta opción a cero para suprimir
el parpadeo. El valor por defecto es 300.
insertontime El número de milisegundos que el cursor de inserción está encendido
durante su ciclo de parpadeo. Por defecto es 600.
insertwidth Ancho del cursor de inserción (su altura está determinada por el
elemento más alto de su línea). El valor por defecto es de 2 píxeles.
padx Cuánto espacio dejar a la izquierda y a la derecha del widget y del texto.
Por defecto es 1.
pady Cuánto espacio dejar por encima y por debajo del widget. Por defecto es
1.
selectbackground El color de fondo del texto
selectborderwidth El ancho del borde a utilizar alrededor del texto seleccionado.
spacing1 Esta opción especifica cuánto espacio vertical extra se pone encima de
cada línea de texto. Si una línea se envuelve, este espacio se añade sólo
antes de la primera línea que ocupa en la pantalla. El valor
predeterminado es 0.
spacing2 Esta opción especifica la cantidad de espacio vertical extra que se añade
entre las líneas de texto mostradas cuando se envuelve una línea lógica.
El valor predeterminado es 0.
spacing3 Esta opción especifica cuánto espacio vertical adicional se añade debajo
de cada línea de texto. Si una línea se envuelve, este espacio se añade
sólo después de la última línea que ocupa en la pantalla. El valor
predeterminado es 0.
state Normalmente, los widgets de texto responden a los eventos del teclado y
del ratón; establezca state = NORMAL para obtener este
comportamiento. Si estableces state = DISABLED, el widget de texto no
responderá, y tampoco podrás modificar su contenido mediante
programación.
tabs Esta opción controla cómo los caracteres de tabulación posicionan el
texto.
wrap Esta opción controla la visualización de las líneas que son demasiado
anchas. Si se establece wrap = WORD, se romperá la línea después de la
última palabra que quepa. Con el comportamiento por defecto, wrap =
CHAR, cualquier línea que sea demasiado larga se romperá en cualquier
carácter.
xscrollcommand Para hacer que el widget de texto sea desplazable horizontalmente,
establezca esta opción en el método set() de la barra de desplazamiento
horizontal.
yscrollcommand Para hacer que el widget de texto sea desplazable verticalmente,
establezca esta opción en el método set() de la barra de desplazamiento
vertical.
Métodos
delete(startindex [,endindex]) Borra un caracter específico o un rango de texto.
get(startindex [,endindex]) Retorna un caracter específico o un rango de texto.
index(index) Retorna el valor absolute de un índice basado en un índice.
insert(index [,string]...) Inserta una cadena de texto en un índice especificado.
see(index) Retorna true si el texto ubicado en el índice es visible.
Los widgets de texto admiten tres estructuras de ayuda distintas: Marks, Tabs e Índices:
Los marks se utilizan para marcar posiciones entre dos caracteres dentro de un texto determinado.
Disponemos de los siguientes métodos para manejar las marks.
index(mark) Retorna la linea y columna de una marca específica.
mark_gravity(mark Devuelve la gravedad de la marca dada. Si se proporciona el segundo

[,gravity]) argumento, la gravedad se establece para la marca dada.
mark_names() Devuelve todas las marcas del widget Texto.
mark_set(mark, index) Informa de una nueva posición a la marca dada.
mark_unset(mark) Elimina la marca dada del widget Texto.
Las etiquetas se utilizan para asociar nombres a regiones de texto, lo que facilita la tarea de modificar la
configuración de visualización de áreas de texto específicas. Las etiquetas también se utilizan para
vincular las devoluciones de eventos a rangos específicos de texto.
Los siguientes son los métodos disponibles para manejar las etiquetas –
tag_add(tagname, Este método etiqueta la posición definida por startindex, o un rango

startindex[,endindex] ...) delimitado por las posiciones startindex y endindex.
tag_config Puedes usar este método para configurar las propiedades de las
etiquetas, que incluyen, justificación (centro, izquierda o derecha),
tabulación (esta propiedad tiene la misma funcionalidad que la
propiedad de tabulación del widget de texto), y subrayado (usado para
subrayar el texto etiquetado).
tag_delete(tagname) Este método se utiliza para borrar y eliminar una etiqueta

determinada.
tag_remove(tagname Después de aplicar este método, la etiqueta dada se elimina del área
[,startindex[.endindex]] ...) proporcionada sin borrar la definición real de la etiqueta.
Ejemplo.
# !/usr/bin/python3
root = Tk()
text = Text(root)
text.insert(INSERT, "Hello.....")
text.insert(END, "Bye Bye.....")
text.pack()
text.tag_add("here", "1.0", "1.4")

text.tag_add("start", "1.8", "1.13")
text.tag_config("here", background = "yellow", foreground = "blue")
text.tag_config("start", background = "black", foreground = "green")
root.mainloop()
Toplevel
Los widgets de nivel superior funcionan como ventanas gestionadas directamente por el gestor de
ventanas. No tienen necesariamente un widget padre encima.
Tu aplicación puede utilizar cualquier número de ventanas de nivel superior.
Sintaxis:
w = Toplevel (option, ... )
Parametros:
bg El color de fondo de la ventana
bd Ancho del borde en píxeles; por defecto es 0.
cursor Es el cursor que aparece cuando el mouse se encuentra en la ventana.
class_ Normalmente, el texto seleccionado dentro de un widget de texto se
exporta para ser la selección en el gestor de ventanas. Establezca
exportselection = 0 si no desea ese comportamiento.
fg Color del texto
height Altura de la ventana
relief Normalmente, una ventana de nivel superior no tendrá bordes
tridimensionales a su alrededor. Para obtener un borde sombreado,
establezca la opción bd más grande que su valor por defecto de cero, y
establezca la opción relieve a una de las constantes.
width La anchura deseada de la ventana
Métodos
deiconify() Muestra la ventana, después de utilizar los métodos de iconificación o de

retirada.
frame() Devuelve un identificador de ventana específico del sistema.
group(window) Añade la ventana al grupo de ventanas administrado por la ventana dada.
iconify() Convierte la ventana en un icono, sin destruirla.
protocol(name, Registra una función como callback que será llamada para el protocolo dado.
function)
iconify() Convierte la ventana en un icono, sin destruirla.
state() Devuelve el estado actual de la ventana. Los valores posibles son normal,
icónico, retirado e icono.
transient([master]) Convierte la ventana en una ventana temporal(transitoria) para el maestro

dado o al padre de la ventana, cuando no se da ningún argumento.
withdraw() Elimina la ventana de la pantalla, sin destruirla.
maxsize(width, Define el tamaño máximo de esta ventana.

height)
minsize(width, Define el tamaño mínimo de esta ventana.

height)
Ejemplo.
# !/usr/bin/python3
root = Tk()
root.title("hello")
top = Toplevel()
top.title("Python")
top.mainloop()
Spinbox
El widget Spinbox es una variante del widget estándar Tkinter Entry, que puede utilizarse para
seleccionar entre un número fijo de valores.
Sintaxis:
w = Spinbox (master, option, ... )
Parametros:
activebackground El color del deslizador y de las puntas de flecha cuando el ratón está
sobre ellos
bg El color del deslizador y de las puntas de flecha cuando el ratón no está
sobre ellos.
bd El ancho de los bordes 3D alrededor de todo el perímetro de la cubeta, y
también el ancho de los efectos 3D en las puntas de flecha y el deslizador.
Por defecto, no hay borde alrededor de la cubeta, y un borde de 2 píxeles
alrededor de las puntas de flecha y el deslizador.
command Un procedimiento que se llama cada vez que se mueve la barra de
desplazamiento.
cursor El cursor que aparece cuando el ratón está sobre la barra de
desplazamiento.
disablebackground El color de fondo a utilizar cuando el widget está desactivado.
disableforeground El color del texto que se utilizará cuando el widget esté desactivado.
fg Color del texto
format Formato de texto.
from_ El valor mínimo. Se utiliza junto con to para limitar el rango de la caja de
giro.
Justify Valor default es LEFT
repeatdelay Junto con el intervalo de repetición, esta opción controla la repetición
automática del botón. Ambos valores se dan en milisegundos.
repeatinterval repetición del retardo.
state Estado del widget. NORMAL, DISABLED o readonly.
to Valor límite
validate Modo de validación, el valor default es NONE
validatecommand Llamada de retorno de validación. No hay valor por defecto.
values Una tupla que contiene valores válidos para este widget. Anula
desde/hasta/incremento.
width Ancho del widget, en unidades de caracteres. Por defecto es 20.
wrap Si es true, los botones de subida y bajada se envolverán.
xscrollcommand Se utiliza para conectar un campo spinbox a una barra de desplazamiento
horizontal. Esta opción debe establecerse en el método set de la barra de
desplazamiento correspondiente.
Métodos
delete(startindex [,endindex]) Este método borra un carácter específico o un rango de texto.
get(startindex [,endindex]) Este método devuelve un carácter específico o un rango de texto.
identify(x, y) Identifica el elemento del widget en la ubicación dada.
index(index) Devuelve el valor absoluto de un índice basado en el índice dado.
insert(index [,string]...) Este método inserta cadenas en la ubicación del índice especificado.
invoke(element) Invoca un botón de caja giratoria.
Ejemplo
from Tkinter import *

master = Tk()
w = Spinbox(master, from_ = 0, to = 10)

w.pack()
mainloop()
Labelframe
Un labelframe es un simple widget contenedor. Su propósito principal es actuar como un espaciador o
contenedor para diseños de ventanas complejas. Este widget tiene las características de un marco más
la capacidad de mostrar una etiqueta.
Sintaxis:
w = LabelFrame (master, option, ... )
Parametros:
indicador.
bd El tamaño del borde alrededor del indicador. Por defecto es de 2 píxeles.
cursor El cursor que aparece cuando el ratón está sobre el widget
height Dimensión vertical
labelAnchor Especifica en donde colocar la etiqueta
highlightbackground Color del resalte de enfoque cuando el cuadro no tiene enfoque.
highlightcolor Color que se muestra en el resalte de enfoque cuando el marco tiene el
enfoque.
highlightthickness Grosor del resalte de enfoque.
destaca de su fondo. Puede ajustar esta opción a cualquiera de los otros
estilos
text Especifica una cadena que se mostrará dentro del widget.
width Ancho del widget, en unidades de caracteres.
Ejemplo
# !/usr/bin/python3
root = Tk()
labelframe = LabelFrame(root, text = "This is a LabelFrame")

labelframe.pack(fill = "both", expand = "yes")
left = Label(labelframe, text = "Inside the LabelFrame")

left.pack()
root.mainloop()
tkMessageBox
El módulo tkMessageBox se utiliza para mostrar cuadros de mensajes en sus aplicaciones. Este módulo
proporciona una serie de funciones que puede utilizar para mostrar un mensaje apropiado.
Algunas de estas funciones son showinfo, showwarning, showerror, askquestion, askokcancel, askyesno,
y askretryignore.
Sintaxis:
tkMessageBox.FunctionName(title, message [, options])
Parametros:
 FunctionName - Es el nombre de la función del cuadro de mensaje correspondiente.
 title - Es el texto que se mostrará en la barra de título de un cuadro de mensaje.
 message - Es el texto que se mostrará como mensaje.
 options - las opciones son opciones alternativas que puede utilizar para adaptar un cuadro de
mensaje estándar. Algunas de las opciones que puede utilizar son por defecto y por defecto. La
opción por defecto se utiliza para especificar el botón por defecto, como ABORT, RETRY o
IGNORE en el cuadro de mensaje. La opción padre se utiliza para especificar la ventana sobre la
que se mostrará el cuadro de mensaje.
Puede utilizar una de las siguientes funciones con el cuadro de diálogo:

 showinfo()
 showwarning()
 showerror ()
 askyesno ()
 askretrycancel ()
Función Descripción
askokcancel (title=None, Pregunta si la operación debe continuar; devuelve true si la respuesta es
message=None, **options) correcta.
askquestion(title=None, Realiza una pregunta
message=None, **options)
askretrycancel(title=None, Pregunta si se debe reintentar la operación; devuelve true si la respuesta
message=None, **options) es afirmativa
askyesno(title=None, Hacer una pregunta; devolver true si la respuesta es afirmativa
askyesnocancel(title=None, Hacer una pregunta; devolver true si la respuesta es afirmativa, None si
message=None, **options) se anula.
showerror(title=None, Mostrar un mensaje de error
showinfo(title=None, Muestra mensaje de información
showwarning(title=None, Mostrar un mensaje de advertencia
Ejemplo de showinfo
# !/usr/bin/python3
top = Tk()
top.geometry("100x100")
def hello():
messagebox.showinfo("Say Hello", "Hello World")
B1 = Button(top, text = "Say Hello", command = hello)

B1.place(x = 35,y = 50)
top.mainloop()
Ejemplo de askyesno:
from tkinter import ttk
from tkinter.messagebox import askyesno, askquestion
class App(tk.Tk):
def __init__(self):
super().__init__()
self.title('Tkinter Yes/No Dialog')

self.geometry('300x150')
# Quit button
quit_button = ttk.Button(self, text='Quit', command=self.confirm)
quit_button.pack(expand=True)
def confirm(self):
answer = askyesno(title='Confirmation',
message='Are you sure that you want to quit?')
if answer:
self.destroy()
if __name__ == "__main__":
app = App()
app.mainloop()
Open File Dialog
Cuando se desarrolla una aplicación Tkinter que trata con el sistema de archivos, es necesario
proporcionar un diálogo que permita la selección de archivos. Para ello, puede utilizar el módulo
tkinter.filedialog. Los siguientes pasos muestran cómo mostrar un diálogo de archivo abierto:
Primero, importe el módulo tkinter.filedialog:
from tkinter import filedialog as fd
En segundo lugar, llama a la función fd.askopenfilename() para mostrar un cuadro de diálogo que
permita seleccionar un solo archivo:
filename = fd.askopenfilename()
La función askopenfilename() devuelve el nombre del archivo seleccionado.
La función askopenfilename() también admite otras opciones útiles, como el directorio inicial que
muestra el diálogo o el filtrado de archivos por sus extensiones.
El siguiente programa muestra un botón que a su vez abre una ventana de diálogo para seleccionar un
archivo:
from tkinter.messagebox import showinfo
# create the root window

root = tk.Tk()
root.title('Tkinter Open File Dialog')
root.resizable(False, False)
root.geometry('300x150')
def select_file():
filetypes = ( ('text files', '*.txt'), ('All files', '*.*') )
filename = fd.askopenfilename( title='Open a file', initialdir='/', filetypes=filetypes)
showinfo( title='Selected File', message=filename )
# open button
open_button = ttk.Button( root, text='Open a File', command=select_file )
open_button.pack(expand=True)
# run the application

root.mainloop()
Output:
Al hacer clic en el botón, se abre una ventana de diálogo

Después de seleccionar un archivo, el programa mostrará la ruta completa del archivo seleccionado
Selección de Múltiples Archivos
La función askopenfilenames() muestra un diálogo de archivos para la selección de múltiples archivos.

Devuelve los nombres de los archivos seleccionados como una tupla. Por ejemplo:
# create the root window

root = tk.Tk()
root.title('Tkinter File Dialog')
def select_files():
filetypes = (
('text files', '*.txt'),
('All files', '*.*')
)
filenames = fd.askopenfilenames(
title='Open files',
initialdir='/',
filetypes=filetypes)
showinfo(
title='Selected Files',
message=filenames
)
# open button
open_button = ttk.Button(
root,
text='Open Files',
command=select_files
)
open_button.pack(expand=True)
root.mainloop()
Output:
Abrir archivos directamente
Después de obtener los nombres de los archivos seleccionados, puede abrirlos utilizando el método
open().
Para hacerlo más conveniente, el módulo tkinter.filedialog también proporciona algunas funciones que
permiten seleccionar uno o más archivos y devolver los objetos archivo directamente.
La función askopenfile() muestra un diálogo de archivo y devuelve un objeto archivo del archivo
seleccionado:
f = fd.askopenfile()
Y la función askopenfiles() muestra un diálogo de archivos y devuelve objetos de archivo de los archivos
seleccionados:
f = fd.askopenfiles()
Le permitirá abrir un archivo de texto y mostrar el contenido del archivo en un widget de texto:
# Root window
root = tk.Tk()
root.title('Display a Text File')
# Text editor
text = tk.Text(root, height=12)
text.grid(column=0, row=0, sticky='nsew')
def open_text_file():
# file type
filetypes = (
('text files', '*.txt'),
('All files', '*.*')
)
# show the open file dialog
f = fd.askopenfile(filetypes=filetypes)
# read the text file and show its content on the Text
text.insert('1.0', f.readlines())
# open file button

open_button = ttk.Button(
root,
text='Open a File',
command=open_text_file
)
open_button.grid(column=0, row=1, sticky='w', padx=10, pady=10)

root.mainloop()
Output:
Al hacer clic en el botón se abre una ventana de diálogo para seleccionar un archivo
Al seleccionar un archivo, se mostrará el contenido en la pantalla principal:
Resumen:
 Utilice la función askopenfilename() para mostrar un diálogo de apertura de archivos que

permita a los usuarios seleccionar un archivo.
 Utilice la función askopenfilenames() para mostrar un diálogo de apertura de archivos que
permita a los usuarios seleccionar varios archivos.
 Utilice la función askopenfile() o askopenfiles() para mostrar un diálogo de apertura de archivos
que permita a los usuarios seleccionar uno o varios archivos y recibir un archivo o varios objetos
de archivo.
Widgets temáticos (ttk)
Tkinter tiene dos generaciones de widgets:
 Los antiguos widgets tk clásicos. Tkinter los introdujo en 1991.

 Los nuevos widgets ttk temáticos añadidos en 2007 con Tk 8.5. Los nuevos widgets temáticos de
Tk sustituyen a muchos (pero no a todos) los widgets clásicos.
Tenga en cuenta que ttk significa Tk themed. Por lo tanto, los widgets temáticos Tk son los mismos que
los widgets ttk
El módulo tkinter.ttk contiene todos los nuevos widgets ttk. Es una buena práctica utilizar siempre los
widgets temáticos cuando estén disponibles.
Las siguientes declaraciones importan los widgets temáticos clásicos y los nuevos de Tk:
Los siguientes widgets ttk sustituyen a los widgets Tkinkter con los mismos nombres:
 Button
 Checkbutton
 Entry
 Frame
 Label
 Labelframe
 Menubutton
 PanedWindow
 Radiobutton
 Scale
 Scrollbar
 Spinbox
Y los siguientes widgets son nuevos y específicos de ttk:
 Combobox
 Notebook
 Progressbar
 Separator
 Sizegrip
 Treeview
El siguiente programa ilustra cómo crear etiquetas clásicas y temáticas:
root = tk.Tk()
tk.Label(root, text='Classic Label').pack()
ttk.Label(root, text='Themed Label').pack()
root.mainloop()
Output:
Su aspecto es similar. Sin embargo, su apariencia depende de la plataforma en la que se ejecuta el

programa.
Ventajas de utilizar los widgets temáticos de Tk

Al utilizar los widgets temáticos Tk, se obtienen las siguientes ventajas:
 Separación del comportamiento y la apariencia del widget - los widgets ttk intentan separar el
código que implementa los comportamientos de los widgets de su apariencia a través del
sistema de estilos.
 Aspecto nativo - los widgets ttk tienen el aspecto nativo de la plataforma en la que se ejecuta el
programa.
 Simplificar los comportamientos de los widgets específicos del estado - los widgets ttk
simplifican y generalizan el comportamiento de los widgets específicos del estado
Combobox
Un combobox es una combinación de un widget Entry y un widget Listbox. Un widget combobox

permite seleccionar un valor de un conjunto de valores. Además, permite introducir un valor
personalizado.
Creación de combobox
Para crear un widget combobox, utilizarás el constructor ttk.Combobox(). El siguiente ejemplo crea un
widget combobox y lo vincula a una variable string:
current_var = tk.StringVar()
combobox = ttk.combobox(container, textvariable=current_var)
El container es la ventana o el marco en el que se quiere colocar el widget combobox.
El argumento textvariable vincula una variable current_var al valor actual del combobox.
Para obtener el valor seleccionado actualmente, puede utilizar la variable current_var:
current_value = current_var.get()
También puede utilizar el método get() del objeto combobox:
current_value = combobox.get()
Para establecer el valor actual, se utiliza la variable current_var o el método set() del objeto combobox:
current_value.set(new_value)
combobox.set(new_value)
Definir lista de valores
El combobox tiene la propiedad values con la que puedes asignar una lista de valores como esta:
combobox['values'] = ('value1', 'value2', 'value3')
Por defecto, puede introducir un valor personalizado en el combobox. Si no quieres esto, puedes
establecer la opción de estado como 'readonly:
combobox['state'] = 'readonly'
Para volver a habilitar la edición del combobox, se utiliza el estado "normal" así:
combobox['state'] = 'normal'
Eventos de enlace
Cuando un valor de selección cambia, el widget combobox genera un evento virtual

<<ComboboxSelected>>. Para manejar el evento, puedes utilizar el método bind() de la siguiente
manera:
combobox.bind('<<ComboboxSelected>>', callback)
En este ejemplo, la función callback se ejecutará cuando el valor seleccionado del combobox cambie.
Establecer el valor actual
Para establecer el valor actual, se utiliza el método set():
combobox.set(self, value)
Además, puedes utilizar el método current():
current(self, newindex=None)
El newindex especifica el índice de los valores de la lista que se desea seleccionar como valor actual.
Si no se especifica el newindex, el método current() devolverá el índice del valor actual en la lista de
valores o -1 si el valor actual no aparece en la lista.
Ejemplo de combobox en Python Tkinter
El siguiente programa ilustra cómo crear un widget combobox:
from calendar import month_name
root = tk.Tk()
# config the root window
root.title('Combobox Widget')
# label
label = ttk.Label(text="Please select a month:")
label.pack(fill=tk.X, padx=5, pady=5)
# create a combobox
selected_month = tk.StringVar()
month_cb = ttk.Combobox(root, textvariable=selected_month)
# get first 3 letters of every month name
month_cb['values'] = [month_name[m][0:3] for m in range(1, 13)]
# prevent typing a value
month_cb['state'] = 'readonly'
# place the widget
month_cb.pack(fill=tk.X, padx=5, pady=5)
# bind the selected value changes
def month_changed(event):
""" handle the month changed event """
showinfo(
title='Result',
message=f'You selected {selected_month.get()}!'
)
month_cb.bind('<<ComboboxSelected>>', month_changed)
root.mainloop()
Output:
El siguiente programa muestra el mismo widget combobox del mes y utiliza el método set() para
establecer el valor actual al mes actual:
from calendar import month_name
from datetime import datetime
root = tk.Tk()
# config the root window
root.title('Combobox Widget')
# label
label = ttk.Label(text="Please select a month:")
label.pack(fill=tk.X, padx=5, pady=5)
# create a combobox
selected_month = tk.StringVar()
month_cb = ttk.Combobox(root, textvariable=selected_month)
# get first 3 letters of every month name
month_cb['values'] = [month_name[m][0:3] for m in range(1, 13)]
# prevent typing a value
month_cb['state'] = 'readonly'
# place the widget
month_cb.pack(fill=tk.X, padx=5, pady=5)
# bind the selected value changes
def month_changed(event):
""" handle the month changed event """
showinfo(
title='Result',
message=f'You selected {selected_month.get()}!'
)
month_cb.bind('<<ComboboxSelected>>', month_changed)
# set the current month
current_month = datetime.now().strftime('%b')
month_cb.set(current_month)
root.mainloop()
Resumen
Utilice ttk.Combobox(root, textvariable) para crear un combobox.
Establece la propiedad state como readonly para evitar que los usuarios introduzcan valores
personalizados.
Un widget combobox emite el evento <<ComboboxSelected>> cuando el valor seleccionado cambia.
Notebook
El widget Notebook le permite seleccionar las páginas de contenido haciendo clic en las pestañas:
Al hacer clic en una de estas pestañas, el widget de Notebook mostrará un panel secundario asociado a
la pestaña seleccionada. Normalmente, un panel hijo es un widget Frame.
Para crear un widget de Notebook, se utiliza la clase ttk.Notebook de la siguiente manera:
notebook = ttk.Notebook(container,**options)
En esta sintaxis, el contenedor es el padre del cuaderno. Normalmente, es la ventana raíz.

El cuaderno tiene algunas opciones útiles. Por ejemplo, se utilizan las opciones de altura y anchura para
especificar la altura y la anchura en píxeles asignadas al widget.
Además, puedes añadir algo de espacio alrededor del exterior del widget utilizando la opción padding.
Métodos de Notebook
La clase ttk.Notebook le proporciona muchos métodos prácticos que le permiten gestionar las pestañas
de forma eficaz.
A continuación, se describen los más utilizados:
add(child, **kwargs)
 El método add() añade un widget hijo a una ventana.

 El argumento **kwargs es una o más opciones.
Éstas son las más importantes:
 El child es un widget que se añade al cuaderno.

 La opción text especifica la etiqueta que aparece en la pestaña
 La opción de image especifica la imagen que se mostrará en la pestaña.
 Si utiliza tanto la opción de texto como la de imagen, debe utilizar la opción compuesta. La
opción compuesta describe la posición de la imagen en relación con el texto. Puede ser tk.TOP,
tk.BOTTOM, tk.LEFT, tk.RIGHT, tk.CENTER. Por ejemplo, tk.LEFT colocaría la imagen a la
izquierda del texto.
La opción underline toma cero o un número entero positivo. Especifica el carácter en una posición del
texto en la pestaña para ser subrayado.
hide(tabId)
El método hide() elimina temporalmente la pestaña identificada por el tabId del Cuaderno. Las pestañas
tienen un índice basado en cero. Esto significa que la primera pestaña comienza en cero.
Para mostrar la pestaña, es necesario llamar de nuevo al método add(). No hay un método show()
correspondiente.
forget(child)
La función forget() elimina permanentemente el widget hijo especificado del cuaderno.
Ejemplo de widget de cuaderno Tkinter
El siguiente programa muestra cómo crear un cuaderno con dos pestañas:
# root window
root = tk.Tk()
root.title('Notebook Demo')
# create a notebook
notebook = ttk.Notebook(root)
notebook.pack(pady=10, expand=True)
# create frames
frame1 = ttk.Frame(notebook, width=400, height=280)
frame1.pack(fill='both', expand=True)
# add frames to notebook
notebook.add(frame1, text='General Information')
notebook.add(frame2, text='Profile')
root.mainloop()
Output:
Cómo funciona.
Primero, cree un widget de cuaderno cuyo padre sea la ventana raíz:
notebook = ttk.Notebook(root)
notebook.pack(pady=10, expand=True)
En segundo lugar, crea dos marcos cuyo padre es el cuaderno:
En tercer lugar, añade estos marcos al cuaderno utilizando el método add():
notebook.add(frame1, text='General Information')
notebook.add(frame2, text='Profile')
Resumen
Utiliza la clase ttk.Notebook para crear un widget de cuaderno.
Utiliza el método add() para añadir una pestaña al cuaderno.
Utiliza el método hide() para eliminar temporalmente una pestaña del cuaderno. Para eliminar una
pestaña permanentemente, utilice el método forget().
Progressbar
Un widget Progressbar le permite dar información al usuario sobre el progreso de una tarea de larga
duración. Para crear un widget Progressbar, se utiliza la clase ttk.Progressbar:
ttk.Progressbar(container, **options)
A continuación se muestran los parámetros típicos para crear un widget Progressbar:
ttk.Progressbar(container, orient, length, mode)
En esta sintaxis:
 El container es el componente padre de la barra de progreso.

 Orient puede ser "horizontal" o "vertical".
 Length representa la anchura de una barra de progreso horizontal o la altura de una barra de
progreso vertical.
 Mode puede ser "determinate" o "indeterminate".
El modo indeterminate
En el modo indeterminado, la barra de progreso muestra un indicador que rebota entre los extremos del
widget.
Normalmente, se utiliza el modo indeterminado cuando no se sabe cómo medir con precisión el tiempo
que tarda en completarse una tarea de larga duración.
El modo determinate
En el modo determinado, la barra de progreso muestra un indicador desde el principio hasta el final del
widget.
Si sabes cómo medir el progreso relativo, puedes utilizar el modo determinado.
Métodos importantes de una progressbar
 start([interval]) - comienza a mover el indicador cada milisegundo de intervalo. El intervalo por

defecto es de 50ms.
 step([delta]) - aumenta el valor del indicador en delta. El delta está predeterminado a 1
milisegundo.
 stop() - dejar de mover el indicador de la barra de progreso.
Ejemplos de Tkinter Progressbar
1) Ejemplo de Tkinter Progressbar en modo indeterminado
El siguiente programa ilustra cómo crear una barra de progreso en modo indeterminado. Si se hace clic
en el botón de inicio, la barra de progreso comienza a mover el indicador. Al hacer clic en el botón de
parada, la barra de progreso deja de mover el indicador de progreso:
# root window
root = tk.Tk()
root.title('Progressbar Demo')
root.grid()
# progressbar
pb = ttk.Progressbar( root, orient='horizontal', mode='indeterminate', length=280 )
# place the progressbar
pb.grid(column=0, row=0, columnspan=2, padx=10, pady=20)
# start button
start_button = ttk.Button( root, text='Start', command=pb.start )
start_button.grid(column=0, row=1, padx=10, pady=10, sticky=tk.E)
# stop button
stop_button = ttk.Button( root, text='Stop', command=pb.stop )
stop_button.grid(column=1, row=1, padx=10, pady=10, sticky=tk.W)
root.mainloop()
Output:
Cómo funciona:
Primero, cree una barra de progreso horizontal cuya longitud sea de 280 píxeles y el modo sea
"indeterminado":
pb = ttk.Progressbar( root, orient='horizontal', mode='indeterminate', length=280 )
En segundo lugar, pasa el método Progressbar.start al comando del botón de inicio:
start_button = ttk.Button( root, text='Start', command=pb.start )
Tercero, pasa el método Progressbar.stop al comando del botón de parada:
stop_button = ttk.Button( root, text='Stop', command=pb.stop )
2) Ejemplo de Tkinter Progressbar en modo determinado
El siguiente programa muestra cómo utilizar una barra de progreso en el modo determinado:

# root window
root = tk.Tk()
root.title('Progressbar Demo')
def update_progress_label():
return f"Current Progress: {pb['value']}%"
def progress():
if pb['value'] < 100:
pb['value'] += 20
value_label['text'] = update_progress_label()
else:
showinfo(message='The progress completed!')
def stop():
pb.stop()
# progressbar
pb = ttk.Progressbar( root, orient='horizontal', mode='determinate', length=280)
# place the progressbar
pb.grid(column=0, row=0, columnspan=2, padx=10, pady=20)
# label
value_label = ttk.Label(root, text=update_progress_label())
value_label.grid(column=0, row=1, columnspan=2)
# start button
start_button = ttk.Button( root, text='Progress', command=progress)
start_button.grid(column=0, row=2, padx=10, pady=10, sticky=tk.E)
stop_button = ttk.Button( root, text='Stop', command=stop)

stop_button.grid(column=1, row=2, padx=10, pady=10, sticky=tk.W)
root.mainloop()
Output:
Cómo funciona.
Primero, crea una barra de progreso en el modo determinado:
pb = ttk.Progressbar( root, orient='horizontal', mode='determinate', length=280 )
En segundo lugar, vincula la función progress() al evento de clic del botón de progreso. Una vez que se
hace clic en el botón, el valor de la barra de progreso se incrementa en un 20% y la etiqueta de progreso
se actualiza. Además, el programa muestra un cuadro de mensaje indicando que el progreso se ha
completado si el valor llega a 100:
def progress():
if pb['value'] < 100:
pb['value'] += 20
else:
showinfo(message='The progress completed!')
En tercer lugar, enlaza la función stop() con el evento de clic del botón de parada. Además, la función
stop() actualiza la etiqueta de progreso.
def stop():
pb.stop()
Separator
Un widget separator coloca una fina regla horizontal o vertical entre grupos de widgets.
Para crear un widget separador, se utiliza el constructor ttk.Separator así:
sep = ttk.Separator(container,orient='horizontal')
La opción de orientación puede ser "horizontal" o "vertical".
El siguiente ejemplo ilustra cómo utilizar un widget separador para separar dos etiquetas:
root = tk.Tk()
root.title('Separator Widget Demo')
ttk.Label(root, text="First Label").pack()
separator = ttk.Separator(root, orient='horizontal')
separator.pack(fill='x')
ttk.Label(root, text="Second Label").pack()
root.mainloop()
Output:
Observe que el tamaño de un separador es de 1px. Por lo tanto, es necesario establecer la propiedad fill
o sticky para ajustar su tamaño.
Sizegrip
El widget Sizegrip suele situarse en la esquina inferior derecha de la ventana. Permite cambiar el tamaño
de la ventana de la aplicación de entrada:
Para crear un widget Sizegrip, se utiliza la siguiente sintaxis:
ttk.Sizegrip(parent, **option)
Para que el widget Sizegrip funcione correctamente, es necesario hacer que la ventana raíz sea
redimensionable.
Si utiliza el gestor de geometría de grid, debe configurar los tamaños de las columnas y las filas.
Ejemplo de widget Tkinter Sizegrip
El siguiente programa muestra un Sizegrip en la parte inferior derecha de la ventana raíz:
root = tk.Tk()
root.title('Sizegrip Demo')
root.resizable(True, True)
# grid layout
root.columnconfigure(0, weight=1)
root.rowconfigure(0, weight=1)
# create the sizegrip

sg = ttk.Sizegrip(root)
sg.grid(row=1, sticky=tk.SE)
root.mainloop()
Output:
Cómo funciona.
En primer lugar, asegúrese de que la ventana raíz resizable:
root.resizable(True, True)
En segundo lugar, configure el diseño de la cuadrícula:
En tercer lugar, crea un widget de Sizegrip:
sg = ttk.Sizegrip(root)
sg.grid(row=1, sticky=tk.SE)
Treeview
Un widget Treeview le permite mostrar datos en estructuras tabulares y jerárquicas. Para crear un
widget Treeview, se utiliza la clase ttk.Treeview:
tree = ttk.Treeview(container, **options)

Un widget Treeview contiene una lista de elementos. Cada elemento tiene una o más columnas.
La primera columna puede contener texto y un icono que indica si es expansible o no. Las restantes
columnas contienen los valores de cada fila.
La primera fila del Treeview consiste en encabezados que identifican cada columna con un nombre.
Treeview para mostrar datos tabulares

El siguiente programa muestra cómo utilizar el widget Treeview para mostrar datos tabulares:
root = tk.Tk()
root.title('Treeview demo')
# define columns
columns = ('first_name', 'last_name', 'email')
tree = ttk.Treeview(root, columns=columns, show='headings')
# define headings
tree.heading('first_name', text='First Name')
tree.heading('last_name', text='Last Name')
tree.heading('email', text='Email')
# generate sample data

contacts = []
for n in range(1, 100):
contacts.append((f'first {n}', f'last {n}', f'email{n}@example.com'))
# add data to the treeview

for contact in contacts:
tree.insert('', tk.END, values=contact)
def item_selected(event):
for selected_item in tree.selection():
item = tree.item(selected_item)
record = item['values']
# show a message
showinfo(title='Information', message=','.join(record))
tree.bind('<<TreeviewSelect>>', item_selected)
tree.grid(row=0, column=0, sticky='nsew')
# add a scrollbar
scrollbar = ttk.Scrollbar(root, orient=tk.VERTICAL, command=tree.yview)
tree.configure(yscroll=scrollbar.set)
scrollbar.grid(row=0, column=1, sticky='ns')
# run the app

root.mainloop()
Output:
Cómo funciona.
Primero, importa el módulo tkinter, el submódulo ttk y el showinfo de tkinter.messagebox:
Lenguaje de código: Python (python)
En segundo lugar, crea la ventana raíz, establece su título y tamaño:
root = tk.Tk()
root.title('Treeview demo')
En tercer lugar, definir los identificadores para las columnas:
columnas = ('nombre', 'apellido', 'correo electrónico')

Cuarto, crear un widget Treeview de Tkinter:
tree = ttk.Treeview(root, columns=columns, show='headings')
En este código, pasamos las columnas a la opción columns. La opción show='heading' oculta la primera
columna (columna #0) del Treeview.
La opción show acepta uno de los siguientes valores:
 'tree' - muestra la columna #0.

 'heading' - muestra la fila de cabecera.
 'tree headings' - muestra tanto la columna #0 como la fila de cabecera. Este es el valor por
defecto.
 '' - no muestra la columna #0 ni la fila de cabecera.
En quinto lugar, especifica los encabezados de las columnas:

En sexto lugar, generar una lista de tuplas para mostrar en el Treeview:

contacts = []
En séptimo lugar, crea nuevos elementos, uno por uno, utilizando el método insert() del widget
Treeview:

Octavo, define una función para manejar el evento <>. Cuando se selecciona uno o más elementos, el
programa mostrará un cuadro de mensaje:
def item_selected(event):
for selected_item in tree.selection():
item = tree.item(selected_item)
# show a message
tree.bind('<<TreeviewSelect>>', item_selected)
En noveno lugar, colocar el widget Treeview en la ventana raíz:
Décimo, añade una barra de desplazamiento vertical al widget Treeview:
# add a scrollbar
scrollbar = ttk.Scrollbar(root, orient=tk.VERTICAL, command=tree.yview)
Por último, visualice la ventana raíz:
root.mainloop()
Vista de árbol
La vista de árbol (o lista jerárquica) es un elemento gráfico que presenta información de modo
jerárquico y, opcionalmente, en forma de tabla o grilla (filas y columnas). Fue introducido en Tk 8.5 y en
Python es provisto por el modulo ttk.
Para crear una vista de árbol, creamos una ventana básica de tkinter y una instancia de la
clase ttk.Treeview.
class Application(ttk.Frame):
def __init__(self, main_window):

super().__init__(main_window)
# Establecer un título.
main_window.title("Vista de árbol en Tkinter")
# Creación de la vista de árbol.
self.treeview = ttk.Treeview(self)
self.treeview.insert("", tk.END, text="Elemento 1")
self.treeview.pack()
self.pack()
# Creación de la ventana principal.

main_window = tk.Tk()
app = Application(main_window)
app.mainloop()
Output:
Añadir y obtener elementos
Una vez creado el objeto treeview (o self.treeview en la versión orientada a objetos), añadimos
información en forma de ítems o filas vía el método Treeview.insert().

# Establecer un título.
# Creación de la vista de árbol.
self.pack()
# Creación de la ventana principal.

app.mainloop()
Ya que la vista en árbol presenta información de forma jerárquica, el primer argumento que le pasamos
a insert() es un ítem o una cadena vacía ("") para indicar que el nuevo ítem no tiene predecesor.
El segundo argumento indica la posición en la que queremos insertar el ítem o tk.END para ubicarlo al
final del árbol. Así, insert("", 0, text="Elemento 1") lo ubicaría al comienzo.

item = self.treeview.insert("", tk.END, text="Elemento 1")
self.treeview.insert(item, tk.END, text="Subelemento 1")
self.pack()
app.mainloop()
Output:
Incluso Subelemento 1 puede tener otros ítems dentro de él; y así sucesivamente.
Tk crea automáticamente un ID para cada ítem, en forma de cadena, con el formato I001, I002, etc. Rara
vez querrás crear por tu cuenta un ID para un nuevo ítem; pero de ser necesario, puedes hacerlo
indicando el parámetro iid.

self.my_iid = "id_unico" # Cualquier cadena es aceptable.
self.treeview.insert("", tk.END, text="Elemento 1", iid=self.my_iid)
self.pack()
app.mainloop()
Esto puede ser en ocasiones útil para obtener o modificar información más adelante sobre dicho ítem.
Por ejemplo, el siguiente código muestra el texto del ítem en un cuadro de diálogo (messagebox) al ser
presionado un botón:

self.my_iid = "id_unico"
self.button = ttk.Button(text="Mostrar información",
command=self.show_info)
self.button.pack(after=self.treeview)
self.pack()
def show_info(self):
# Obtener el texto del Elemento 1.
text = self.treeview.item(self.my_iid, option="text")
# Mostrarlo en un cuadro de diálogo.
messagebox.showinfo(title="Información", message=text)
app.mainloop()
Output:
La función Treeview.item() permite acceder a los datos de un ítem y eventualmente modificarlos. El

código anterior muestra en el cuadro de diálogo la propiedad text del ítem con ID my_iid. Si no se
especifica ninguna opción, la función retorna un diccionario con toda la información disponible.

self.pack()
# Obtener toda la información del Elemento 1.
info = self.treeview.item(self.my_iid)
# Mostrarla en un cuadro de diálogo.
messagebox.showinfo(title="Información", message=info)
app.mainloop()
Output:
Aquí la variable info contiene un diccionario con la información el elemento seleccionado, para alterar
alguno de estos valores, simplemente se lo pasamos como argumento:

self.button = ttk.Button(text="Cambia elemento",
command=self.cambia_elemento)
self.pack()
# Obtener toda la información del Elemento 1.
info = self.treeview.item(self.my_iid)
# Mostrarla en un cuadro de diálogo.
messagebox.showinfo(title="Información", message=info)
def cambia_elemento(self):
# Modificar el texto del ítem con ID my_iid.
self.treeview.item(self.my_iid, text="Nuevo elemento")
app.mainloop()
Output:
Resultado después de clic en botón Cambia elemento:
Pueden obtenerse todos los elementos dentro del árbol o contenidos en otro elemento con la función
get_children(), que retorna una tupla de IDs.

self.item = self.treeview.insert("", tk.END, text="Elemento 1")
self.treeview.insert(self.item, tk.END, text="Subelemento 1")
self.pack()
# Imprime los elementos del árbol.
treeview_children = self.treeview.get_children()
print(treeview_children)
# Imprime los elementos dentro del Elemento 1.
item_children = self.treeview.get_children(self.item)
print(item_children)
app.mainloop()
Output:
Mover y eliminar elementos
Es posible mover un elemento de un lugar a otro utilizando move(). Por ejemplo, considerando los
siguientes dos ítems que se encuentran en la raíz del árbol:
self.item1 = self.treeview.insert("", tk.END, text="Elemento 1")

Podemos mover el Elemento 1 dentro del Elemento 2 de la siguiente manera:
self.treeview.move(self.item1, self.item2, tk.END)
La función obtiene el ítem que queremos mover como primer argumento. En segundo lugar, o bien otro
elemento dentro del cual queremos colocar el ítem original o bien "" para ubicarlo en la raíz de la lista.
El tercer argumento indica la posición.
Para remover uno o varios elementos, Tk provee dos funciones: delete() y detach(). La diferencia es que
la primera elimina completamente los ítems que se le pasan como argumento. La segunda, en cambio,
únicamente los desvincula del árbol, pudiendo ser re-vinculados utilizando move().
# Elimina el elemento 2.
self.treeview.delete(self.item2)
# Desvincula el elemento 1.
self.treeview.detach(self.item1)
Luego del código anterior, la función Treeview.exists, que posibilita saber si un elemento existe dentro
del árbol, retorna False para exists(item2) pero True para exists(item1).
print(treeview.exists(item2)) # False.
print(treeview.exists(item1)) # True.
Ejemplo de uso de Treeview con enfoque de programación orientada a objetos:
class App(tk.Tk):
def __init__(self):
super().__init__()
self.title('Treeview demo')
self.tree = self.create_tree_widget()
def create_tree_widget(self):
tree = ttk.Treeview(self, columns=columns, show='headings')
# define headings
tree.bind('<<TreeviewSelect>>', self.item_selected)
tree.grid(row=0, column=0, sticky=tk.NSEW)
# add a scrollbar
scrollbar = ttk.Scrollbar(self, orient=tk.VERTICAL, command=tree.yview)
# generate sample data

contacts = []
# add data to the treeview

return tree
def item_selected(self, event):

for selected_item in self.tree.selection():
item = self.tree.item(selected_item)
# show a message
if __name__ == '__main__':
app = App()
app.mainloop()
Output:
Añadir un elemento al widget Treeview
Para añadir un elemento (o una fila) a un widget Treeview, se utiliza el método insert() del objeto widget
Treeview. El siguiente ejemplo añade un elemento al final de la lista de elementos:
Para añadir un elemento al principio de la lista, se utiliza el cero (0) en lugar de la constante tk.END:
tree.insert('', 0, values=contact)
El siguiente programa ilustra cómo añadir elementos al Treeview:
class App(tk.Tk):
def __init__(self):
super().__init__()
# define headings
# adding an item
tree.insert('', tk.END, values=('John', 'Doe', 'john.doe@email.com'))
# insert a the end

tree.insert('', tk.END, values=('Jane', 'Miller', 'jane.miller@email.com'))
# insert at the beginning

tree.insert('', 0, values=('Alice', 'Garcia', 'alice.garcia@email.com'))
return tree
if __name__ == '__main__':
app = App()
app.mainloop()
Borrar elementos de un Treeview
Para eliminar un elemento del Treeview, se utiliza el método delete() del objeto Treeview. El siguiente
programa muestra un Treeview con algunos elementos. Al hacer clic en un elemento, éste se eliminará
del árbol:
class App(tk.Tk):
def __init__(self):
super().__init__()
# define headings
# adding an item
tree.insert('', tk.END, values=('John', 'Doe', 'john.doe@email.com'))
# insert a the end

tree.insert('', tk.END, values=('Jane', 'Miller', 'jane.miller@email.com'))
# insert at the beginning

tree.insert('', 0, values=('Alice', 'Garcia', 'alice.garcia@email.com'))
return tree

self.tree.delete(selected_item)
if __name__ == '__main__':
app = App()
app.mainloop()
En este programa.
En primer lugar, vincula el evento de elemento seleccionado:
En segundo lugar, elimina el elemento seleccionado del árbol. Para obtener el elemento seleccionado,
se utiliza el método selection() del objeto Treeview:

self.tree.delete(selected_item)
Eliminación de todos los elementos de un treeview:
for item in tree.get_children():

tree.delete(item)
Personalización de columnas
Para cambiar el tamaño de una columna y el ancla del elemento, puede utilizar el método column() del
objeto Treeview:
tree.column(size, width, anchor)
El siguiente ejemplo establece el ancho de la columna de nombre y apellido a 100 y el de correo

electrónico a 200. También establece el ancla para el elemento en cada columna en consecuencia:
tree.column('first_name', width=100, anchor=tk.W)

tree.column('last_name', width=100, anchor=tk.W)
tree.column('email', width=200, anchor=tk.CENTER)
Uso de Tkinter Treeview para mostrar datos jerárquicos
El siguiente programa ilustra cómo utilizar el widget TreeView para mostrar datos jerárquicos:
# create root window

root = tk.Tk()
root.title('Treeview Demo - Hierarchical Data')
root.geometry('400x200'
# configure the grid layout
# create a treeview
tree = ttk.Treeview(root)
tree.heading('text', text='Departments', anchor='w')
# adding data
tree.insert('', tk.END, text='Administration', iid=0, open=False)
tree.insert('', tk.END, text='Logistics', iid=1, open=False)
tree.insert('', tk.END, text='Sales', iid=2, open=False)
tree.insert('', tk.END, text='Finance', iid=3, open=False)
tree.insert('', tk.END, text='IT', iid=4, open=False)
# adding children of first node

tree.insert('', tk.END, text='John Doe', iid=5, open=False)
tree.insert('', tk.END, text='Jane Doe', iid=6, open=False)
tree.move(5, 0, 0)
tree.move(6, 0, 1)
# place the Treeview widget on the root window

# run the app
root.mainloop()
Output:
Cómo funciona.
Nos centraremos en la parte del widget Treeview. En primer lugar, crear un widget Treeview y
establecer su título.
tree = ttk.Treeview(root)
tree.heading('text', text='Departments', anchor='w')
Este widget Treeview sólo tiene una columna.
En segundo lugar, añada elementos al widget TreeView:
tree.insert('', tk.END, text='Administration', iid=0, open=False)

tree.insert('', tk.END, text='Logistics', iid=1, open=False)
tree.insert('', tk.END, text='Sales', iid=2, open=False)
tree.insert('', tk.END, text='Finance', iid=3, open=False)
tree.insert('', tk.END, text='IT', iid=4, open=False)
Cada elemento se identifica con un iid. Si se omite el iid, el método de inserción generará uno
automáticamente. En este caso, necesitas tener un iid explícito para añadir elementos hijos.
En tercer lugar, añada dos elementos hijos al elemento con iid 0 utilizando los métodos insert() y
move():
# adding children of first node

tree.insert('', tk.END, text='John Doe', iid=5, open=False)
tree.insert('', tk.END, text='Jane Doe', iid=6, open=False)
tree.move(5, 0, 0)
tree.move(6, 0, 1)
Por último, coloque el widget Treeview en la ventana raíz y muéstrelo.
# place the Treeview widget on the root window

# run the app
root.mainloop()
Obtener y establecer elementos seleccionados
La función Treeview.selection() retorna una tupla con los ID de los elementos seleccionados o una tupla
vacía en caso de no haber ninguno. Por ejemplo, el siguiente programa contiene un botón que al ser
presionado muestra un cuadro de diálogo con el elemento seleccionado:

self.button = ttk.Button(text="Mostrar selección",
command=self.show_selection)
self.pack()
def show_selection(self):
try:
# Obtener el ID del primer elemento seleccionado.
item = self.treeview.selection()[0]
print(item)
except IndexError:
# Si la tupla está vacía, entonces no hay ningún
# elemento seleccionado.
messagebox.showwarning(
message="Debe seleccionar un elemento.",
title="No hay selección"
)
else:
# A partir de este ID retornar el texto del elemento.
text = self.treeview.item(item, option="text")
# Mostrarlo en un cuadro de diálogo.
messagebox.showinfo(message=text, title="Selección")
app.mainloop()
Por defecto una vista de árbol permite seleccionar múltiples elementos. Para permitir únicamente una
selección debe pasarse el valor tk.BROWSE al parámetro selectmode.
self.treeview = ttk.Treeview(self, selectmode=tk.BROWSE)
Otras funciones para manejar los elementos seleccionados incluyen:
 selection_add(): añade elementos a la selección.

 selection_remove(): remueve elementos de la selección.
 selection_set(): similar a selection_add(), pero remueve los elementos previamente
seleccionados.
 selection_toggle(): cambia la selección de un elemento.
Por ejemplo, el siguiente código selecciona los Elementos 1 y 2 luego de añadirlos a la tabla:
# O simplemente:
# self.treeview.selection_add((self.item1, self.item2))
self.treeview.selection_add(self.item1)
self.treeview.selection_add(self.item2)
Eventos
Es posible conocer cuándo un elemento es seleccionado y, si contiene otros elementos dentro de él,
también conocer si se abre o se cierra.
La vista de árbol provee tres eventos virtuales para logarlo: <<TreeviewSelect>>, <<TreeviewOpen>> y
<<TreeviewClose>>.

# Crear una nueva etiqueta.
self.treeview.tag_bind("mytag", "<<TreeviewSelect>>",
self.item_selected)
self.treeview.tag_bind("mytag", "<<TreeviewOpen>>",
self.item_opened)
self.treeview.tag_bind("mytag", "<<TreeviewClose>>",
self.item_closed)
# Añadir dos elementos indicando la etiqueta anterior para
# que respondan a los eventos.
item = self.treeview.insert("", tk.END, text="Elemento 1",
tags=("mytag",))
self.treeview.insert(item, tk.END, text="Subelemento 1",
tags=("mytag",))
self.pack()

"""Item seleccionado."""
print("Seleccionado.")
def item_opened(self, event):

"""Item abierto."""
print("Abierto.")
def item_closed(self, event):

"""Item cerrado."""
print("Cerrado.")
app.mainloop()
En Tk los eventos se asocian a una etiqueta determinada (mytag en el código anterior), y luego cada
ítem puede asociarse a una o más etiquetas para responder a aquellos eventos.
Configuración de widgets
Cuando creas un widget en Tkinter, tienes que pasar varios valores como parámetros, utilizados para
configurar ciertas características de ese Widget. La pregunta que puede surgir en algún momento es si
se pueden cambiar estas configuraciones después de haber creado el widget.
Para esto tenemos la función Tkinter config() o configure(), que puede ser usada en cualquier widget
para cambiar las configuraciones que puedas haber aplicado antes, o que aún no hayas aplicado.
Ejemplo:
root = tk.Tk()
frame = tk.Frame(root)
def dosomething():
mylabel.config(text = "Goodbye World")
mylabel = tk.Label(frame, text = "Hello World", bg = "red")
mylabel.pack(padx = 5, pady = 10)
mybutton = tk.Button(frame, text = "Click Me", command = dosomething)

mybutton.pack(padx = 5, pady = 10)
frame.pack(padx = 5, pady = 5)
root.mainloop()
Resultado:
Command binding
Para que la aplicación sea más interactiva, los widgets deben responder a eventos como:
 Clics del ratón

 Pulsación de teclas
Esto requiere asignar una función callback a un evento específico. Cuando el evento ocurre, el callback
será invocado automáticamente para manejar el evento.
En Tkinter, algunos widgets le permiten asociar una función callback con un evento usando la unión de
comandos.
Esto significa que puedes asignar el nombre de una función a la opción de comando del widget para que
cuando el evento ocurra en el widget, la función sea llamada automáticamente.
Para utilizar la vinculación de comandos, sigue estos pasos:

Primero, defina una función como devolución de llamada.
A continuación, asigne el nombre de la función a la opción de comando del widget.
Por ejemplo, lo siguiente define una función llamada button_clicked():
def button_clicked():
print('Button clicked')
Después, puedes asociar la función con la opción de comando de un widget de botón:

ttk.Button(root, text='Click Me',command=button_clicked)
Tenga en cuenta que debe pasar la llamada de retorno sin paréntesis () dentro de la opción de comando.
De lo contrario, el callback sería llamado tan pronto como el programa se ejecute.
El siguiente es el programa completo que ilustra cómo asociar la función callback button_clicked con el
widget Button:
root = tk.Tk()
def button_clicked():
print('Button clicked')
button = ttk.Button(root, text='Click Me', command=button_clicked)

button.pack()
root.mainloop()
Argumentos del comando del botón Tkinter
Si quieres pasar argumentos a una función de devolución de llamada, puedes utilizar una expresión
lambda.
Primero, defina una función que acepte argumentos:

def callback_function(args):
# do something
A continuación, define una expresión lambda y asígnala a la opción de comando. Dentro de la expresión
lambda, invoca la función de devolución de llamada:
ttk.Button(
root,
text='Button',
command=lambda: callback(args))
El siguiente programa ilustra cómo pasar un argumento a la función de devolución de llamada asociada
al comando botón:
root = tk.Tk()
def select(option):
print(option)
ttk.Button(root, text='Rock', command=lambda: select('Rock')).pack()

ttk.Button(root, text='Paper',command=lambda: select('Paper')).pack()
ttk.Button(root, text='Scissors', command=lambda: select('Scissors')).pack()
root.mainloop()
Al pulsar un botón, se ejecutará la expresión lamda ligada al comando de ese botón. Llamará a la función
select() y le pasará un argumento de cadena.
Limitaciones de binding por command

En primer lugar, la opción de command no está disponible en todos los widgets. Está limitada al Botón y
a algunos otros widgets.
En segundo lugar, el botón de comando se vincula con el clic izquierdo y el retroceso. No se vincula a la
tecla Retorno.
Para comprobarlo, puedes mover el foco a un botón del programa anterior y pulsar las teclas de
retroceso y retorno. Esto no es realmente fácil de usar. Desgraciadamente, no se puede cambiar el
enlace de la función de comando fácilmente.
Para superar estas limitaciones, Tkinter proporciona una forma alternativa de asociar una función con
un evento, que se llama evento binding.
Event binding
Una aplicación Tkinter se ejecuta la mayor parte de su tiempo dentro de un bucle de eventos, al que se
entra mediante el método mainloop. En él se espera a que se produzcan eventos. Los eventos pueden
ser pulsaciones de teclas u operaciones del ratón por parte del usuario.
Tkinter provee un mecanismo para que el programador pueda manejar los eventos. Para cada widget, es
posible vincular funciones y métodos de Python a un evento.
Sintaxis: widget.bind(event, handler, add=None)
Si el evento definido se produce en el widget, se llama a la función "handler" con un objeto de evento.
que describe el evento. Si quieres registrar un manejador adicional, puedes pasar el '+' al argumento
add. Esto significa que puedes tener múltiples manejadores de eventos que respondan al mismo evento.
Ejemplo.
def hello(event):
print("Single Click, Button-l")
def quit(event):
print("Double Click, so let's stop")
import sys; sys.exit()
widget = Button(None, text='Mouse Clicks')

widget.pack()
widget.bind('<Button-1>', hello)
widget.bind('<Double-1>', quit)
widget.mainloop()
Output:
Veamos otro ejemplo sencillo, que muestra cómo utilizar el evento motion, es decir, si el ratón se
mueve dentro de un widget:
def motion(event):
print("Mouse position: (%s %s)" % (event.x, event.y))
return
master = Tk()
whatever_you_do = "Whatever you do will be insignificant, but it is very
important that you do it.\n(Mahatma Gandhi)"
msg = Message(master, text = whatever_you_do)
msg.config(bg='lightgreen', font=('times', 24, 'italic'))
msg.bind('<Motion>',motion)
msg.pack()
mainloop()
Output:
Cada vez que movemos el ratón en el widget Mensaje, se imprime la posición del puntero del ratón.
Cuando salimos de este widget, ya no se llama a la función motion().
Ejemplos de vinculación de eventos Tkinter
El siguiente programa ilustra cómo vincular la función return_pressed al evento Return key pressed del
botón 'Save':
def return_pressed(event):
print('Return key pressed.')
root = tk.Tk()
btn = ttk.Button(root, text='Save')
btn.bind('<Return>', return_pressed)
btn.focus()
btn.pack(expand=True)
root.mainloop()
En este ejemplo, la siguiente sentencia llama al método bind() del widget de botón para vincular el
evento Return key pressed:
El siguiente ejemplo ilustra cómo utilizar el método bind() para registrar múltiples manejadores
(handlers) para el mismo evento:
def return_pressed(event):
print('Return key pressed.')
def log(event):
print(event)
root = tk.Tk()
btn = ttk.Button(root, text='Save')
btn.bind('<Return>', log, add='+')
btn.focus()
btn.pack(expand=True)
root.mainloop()
Cuando se mueve el foco al botón y se presiona la tecla Return, Tkinter invoca automáticamente las
funciones return_pressed y log.
Lo siguiente vincula la función log() al evento Return key pressed del botón 'Save':
btn.bind('<Return>', log, add='+')
En esta declaración, el tercer argumento add='+' registró un manejador adicional, que es la función log().
Si no se especifica el argumento add='+', el método bind() sustituirá el manejador existente
(return_pressed) por el nuevo (log).
Eventos.
Tkinter utiliza las llamadas secuencias de eventos para permitir al usuario definir qué eventos, tanto
específicos como generales, quiere vincular a los manejadores. Es el primer argumento "event" del
método bind. La secuencia de eventos se da como una cadena, utilizando la siguiente sintaxis:
<modifier-type-detail>
El campo tipo es la parte esencial de un especificador de evento, mientras que los campos "modificador"
y "detalle" no son obligatorios y se omiten en muchos casos. Se utilizan para proporcionar información
adicional sobre el "tipo" elegido. El "tipo" de evento describe el tipo de evento que se va a vincular, por
ejemplo, acciones como clics del ratón, pulsaciones de teclas o que el widget tenga el foco de entrada.
Evento Descripción
<Activate> La opción de estado de un widget cambia de inactivo a activo.
<Button> Un botón del ratón se pulsa con el puntero del ratón sobre el widget. La parte
detallada especifica qué botón, por ejemplo, el botón izquierdo del ratón está
definido por el evento <Button-1>, el botón del medio por <Button-2>, y el botón
más a la derecha del ratón por <Button-3>.
<Botón-4> define el evento de desplazamiento hacia arriba en los ratones con
soporte de rueda y y <Botón-5> el desplazamiento hacia abajo.
Si usted presiona un botón del ratón sobre un widget y lo mantiene presionado,
Tkinter automáticamente "agarrará" el puntero del ratón. Otros eventos del ratón
como los eventos de movimiento y liberación serán enviados al widget actual,
incluso si el ratón se mueve fuera del widget actual. La posición actual, relativa al
widget, del puntero del ratón se proporciona en los miembros x e y del objeto de
evento pasado a la llamada de retorno. Puede utilizar ButtonPress en lugar de
Button, o incluso omitirlo por completo: , , y <1> son todos sinónimos.
<Deactivate> La opción de estado de un widget cambia de activo a inactivo.
<Destroy> El widget ha sido destruido.
<Expose> Alguna parte del widget o de la aplicación
<Motion> El ratón se mueve manteniendo pulsado un botón del ratón. Para especificar el
botón izquierdo, central o derecho del ratón, utilice <B1-Motion>, <B2-Motion> y
<B3-Motion> respectivamente. La posición actual del puntero del ratón se
proporciona en los miembros x e y del objeto de evento pasado a la devolución de
llamada, es decir, event.x, event.y
<ButtonRelease> Evento, si se libera un botón. Para especificar el botón izquierdo, medio o derecho
del ratón, utilice <ButtonRelease-1>, <ButtonRelease-2> y <ButtonRelease-3>
respectivamente. La posición actual del puntero del ratón se proporciona en los
miembros x e y del objeto de evento pasado a la devolución de llamada, es decir,
event.x, event.y
<Double- Similar al evento Button, ver arriba, pero el botón es doble clic en lugar de un solo
Button> clic. Para especificar el botón izquierdo, medio o derecho del ratón utilice <Double-
Button-1>, <Double-Button-2>, y <Double-Button-3> respectivamente.
Puede utilizar Doble o Triple como prefijos. Tenga en cuenta que si se vincula a un
solo clic (<Botón-1>) y a un doble clic (<Doble-Botón-1>), se llamarán ambas
vinculaciones.
<Enter> El puntero del ratón ha entrado en el widget. Atención: Esto no significa que el
usuario haya pulsado la tecla Enter. Para ello se utiliza <Return>.
<Leave> El puntero del ratón dejó el widget.
<FocusIn> El foco del teclado se ha movido a este widget, o a un hijo de este widget.
<FocusOut> El foco del teclado se ha movido de este widget a otro.
<Return> El usuario ha pulsado la tecla Enter. Se pueden vincular prácticamente todas las
teclas del teclado: Las teclas especiales son Cancelar (la tecla Break), BackSpace,
Tab, Return(la tecla Enter), Shift_L (cualquier tecla Shift), Control_L (cualquier tecla
Control), Alt_L (cualquier tecla Alt), Pausa, Caps_Lock, Escape, Anterior (Avance de
página), Siguiente (Retroceso de página), Fin, Inicio, Izquierda, Arriba, Derecha,
Abajo, Imprimir, Insertar, Borrar, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
Bloqueo_Numérico y Bloqueo_de_Desplazamiento.
<Key> El usuario ha pulsado una tecla cualquiera. La tecla se proporciona en el miembro
char del objeto de evento pasado a la devolución de llamada (es una cadena vacía
para las teclas especiales).
<KeyPress> Una tecla ha sido presionada
<KeyRelease> Una tecla ha sido liberada
a El usuario escribió una tecla "a". La mayoría de los caracteres imprimibles pueden
utilizarse tal cual. Las excepciones son el espacio (<space>) y menos que (<less>).
Tenga en cuenta que 1 es un enlace de teclado, mientras que <1> es un enlace de
botón.
<Shift-Up> El usuario presionó la flecha hacia arriba, mientras mantenía presionada la tecla
Shift. Se pueden utilizar prefijos como Alt, Shift y Control.
<Configure> El tamaño del widget ha cambiado. El nuevo tamaño se proporciona en los atributos
de anchura y altura del objeto de evento pasado a la llamada de retorno. En algunas
plataformas, puede significar que la ubicación cambió.
<Map> Se está colocando un widget en un contenedor, por ejemplo, llamando al método
pack() o grid().
<Visibility> Al menos una parte de la ventana de la aplicación se hace visible en la pantalla.
Gestión de geometría
Gestión de la geometríaTodos los widgets de Tkinter tienen acceso a los métodos específicos de gestión
de la geometría, que tienen el propósito de organizar los widgets en toda el área del widget padre.
Tkinter expone las siguientes clases de manejo de geometría: pack, grid y place.
Pack
El método pack() organiza los widgets en bloques horizontales y verticales que están limitadas a las
posiciones izquierda, derecha, superior e inferior. Cada caja está desplazada y es relativa a las demás.
Este método es el más sencillo de los tres. En lugar de especificar las coordenadas de un elemento,
simplemente le decimos que debe ir arriba, abajo, a la izquierda o a la derecha respecto de algún otro
control o bien la ventana principal.
El gestor de la geometría del paquete tiene muchas configuraciones. Las siguientes son las opciones más
utilizadas: fill, expand, side, ipadx, ipady, padx y pady.
Parámetros Valores
mi_Frame.pack(fill=”valor”) ‘x’, ‘y’, ‘both’, ‘none’
mi_Frame.pack(expand=”valor”) 0, 1, “True”, “False”
mi_Frame.pack(side=”valor”) ‘left’, ‘right’, ‘top’, ‘bottom’
Ejemplo:
root = tk.Tk()
root.title('Pack Demo')
root.geometry("300x200")
# box 1
box1 = tk.Label(
root,
text="Box 1",
bg="green",
fg="white"
)
box1.pack(
ipadx=10,
ipady=10
)
# box 2
box2 = tk.Label(
root,
text="Box 2",
bg="red",
fg="white"
)
box2.pack(
ipadx=10,
ipady=10
)
root.mainloop()
Output:
Este ejemplo utiliza las opciones ipadx e ipady para el relleno interno. Estas opciones crean espacios
entre las etiquetas y sus bordes.
Como puede ver, el gestor de geometría del paquete apila los widgets de las etiquetas unos encima de
otros.
1) Uso de la opción de relleno

La opción de relleno acepta tres valores 'x', 'y', y 'ambos'. Estas opciones permiten que el widget rellene
el espacio disponible a lo largo del eje x, del eje y y de ambos.
Si añades la opción fill='x' al primer widget así

box1.pack(
ipadx=10,
ipady=10,
fill='x'
)
verás que el widget llena todo el espacio disponible en el eje x:
Sin embargo, si se cambia a fill='y' de la siguiente manera:

box1.pack(
ipadx=10,
ipady=10,
fill='y'
)
verás que el primer widget no llena todo el espacio verticalmente:
Básicamente, el gestor de la geometría del paquete asigna espacio a cada widget como se destaca en la
siguiente imagen:
Cuando se utiliza la opción de relleno, el área de cada widget puede rellenar está limitada por esas áreas
asignadas.
Uso de la opción de expansión

La opción expandir asigna más espacio disponible a un widget.
Si añade la opción de expansión al primer widget:
box1.pack(
ipadx=10,
ipady=10,
expand=True
)
obtendrá la siguiente salida:
El primer widget ocupa todo el espacio disponible en la ventana, excepto el espacio asignado al segundo
widget.
Como el primer widget no tiene la opción de relleno, flota en el centro del área asignada.
Si se establece la opción fill como "both":

box1.pack( ipadx=10, ipady=10, fill='both', expand=True )
verás que el primer widget llena la mayor parte de la ventana así:
Si añades la opción de expansión a ambos widgets, el gestor de paquetes les asignará el espacio de
forma equitativa. Por ejemplo:
root = tk.Tk()
# box 1
box1 = tk.Label( root, text="Box 1", bg="green", fg="white" )
box1.pack( ipadx=10, ipady=10, expand=True, fill='both' )
# box 2
box2 = tk.Label( root, text="Box 2", bg="red", fg="white" )
box2.pack( ipadx=10, ipady=10, expand=True )
root.mainloop()
Output:
Observa que el segundo widget no utiliza todo el espacio asignado porque no tiene la opción de relleno.
Cuando se ajusta la expansión a Verdadero para todos los widgets, el gestor de paquetes les asignará el
espacio de manera uniforme.
Sin embargo, esto sólo es cierto cuando todos los widgets comparten el mismo lado de anclaje.
Uso de la opción side
La opción lateral especifica la alineación del widget. Puede ser "left", "top", "right" y "bottom".
El lado por defecto es "top". En otras palabras, los widgets se alinean en la parte superior de su
contenedor.
El siguiente ejemplo establece el lado del primer widget a la izquierda:
root = tk.Tk()
# box 1
box1.pack( ipadx=10, ipady=10, expand=True, fill='both', side='left' )
# box 2
box2.pack( ipadx=10, ipady=10, expand=True, fill='both' )
root.mainloop()
Output:
En este ejemplo, es posible que la opción de expansión no funcione como esperaba. La razón es que los
widgets tienen lados diferentes.
Para volver a igualar su espacio, puedes establecer el lado de ambos widgets como "left" o que uno sea
"left" y el otro "right":
root = tk.Tk()
# box 1
# box 2
root.mainloop()
Output:
El gestor de geometría es adecuado para lo siguiente:

 Colocar widgets en un diseño de arriba abajo.
 Colocar widgets uno al lado del otro.
Vea el siguiente ejemplo:
root = tk.Tk()
# place widgets top down

label1 = tk.Label( root, text='Box 1', bg="red", fg="white")
label1.pack( ipadx=10, ipady=10, fill='x' )
label2 = tk.Label( root, text='Box 2', bg="green", fg="white")
label2.pack( ipadx=10, ipady=10, fill='x')
label3 = tk.Label( root, text='Box 3', bg="blue", fg="white" )
label3.pack( ipadx=10, ipady=10, fill='x' )
# place widgets side by side

label4 = tk.Label( root, text='Left', bg="cyan", fg="black" )
label4.pack( ipadx=10, ipady=10, expand=True, fill='both', side='left' )
label5 = tk.Label( root, text='Center', bg="magenta", fg="black" )
label6 = tk.Label( root, text='Right', bg="yellow", fg="black" )
root.mainloop()
Output:
Utilice el gestor de geometría de paquetes de Tkinter para organizar los widgets en un diseño de arriba a
abajo o de lado a lado.
Utilice las opciones de relleno, expansión y lateral del gestor de geometría de paquetes para controlar la
disposición de los widgets.
Grid
El gestor de la geometría de la cuadrícula utiliza los conceptos de filas y columnas para organizar los
widgets.
Parámetros de grid()
Parámetros Sentido
El índice de la columna donde desea colocar el widget, el valor default es
column
0.
row El índice de fila donde desea colocar el widget. El valor default es 0.
Establece el número de filas adyacentes que puede abarcar el widget. El
rowspan
valor default es 1.
Establece el número de columnas adyacentes que puede abarcar el
columnspan
widget. El valor default es 1.
Si la celda es más grande que el widget, La opción stick especifica en qué
lado debe adherirse el widget y cómo distribuir cualquier espacio
adicional dentro de la celda que no esté ocupado por el widget en su
sticky tamaño original.
Se puede inicializar el valor sticky en las siguientes direcciones: N, E, S,
W, NE, NW, SE, SW y 0. También se puede tomar el valor NESW para que
el widget tome el tamaño total de la celda.
padx Agrega relleno externo por encima y por debajo del widget.
pady Agrega relleno externo a la izquierda y derecha del widget.
Agrega relleno interno dentro del widget desde los lados izquierdo y
ipadx
derecho.
ipady Agrega relleno interno dentro del widget desde los lados superior e
inferior.
Sticky
Por defecto, cuando una celda es más grande que el widget que contiene, el gestor de la geometría de la
cuadrícula coloca el widget en el centro de la celda horizontal y verticalmente.
Para cambiar este comportamiento por defecto, puedes utilizar la opción sticky. La opción sticky
especifica a qué borde de la celda debe pegarse el widget.
El sticky tiene los siguientes valores válidos:
sticky Descripción
N Norte o centro superior
S Centro Sur o Inferior
E Este o centro derecho
W Oeste o centro izquierdo
NW Noroeste o arriba a la izquierda
NE Nordeste o arriba a la derecha
SE Sureste o abajo a la derecha
SW Suroeste o abajo a la izquierda
NS estira el widget verticalmente. Sin embargo, deja el widget centrado
NS
horizontalmente.
EW estira el widget horizontalmente. Sin embargo, deja el widget centrado
EW
verticalmente.
Si quieres posicionar el widget en la esquina de la celda, puedes utilizar la N, S, E y W.
El siguiente ejemplo ilustra cómo posicionar un widget con la opción adhesiva establecida en N:
Si quieres posicionar el widget centrado en un lado de la celda, puedes utilizar el NW (arriba a la
izquierda), NE (arriba a la derecha), SE (abajo a la derecha) y SW (abajo a la izquierda).
El siguiente ejemplo muestra cómo posicionar un widget con la opción pegajosa establecida en NW:
NS estira el widget verticalmente. Sin embargo, deja el widget centrado horizontalmente:

EW estira el widget horizontalmente. Sin embargo, deja el widget centrado verticalmente:
Padding
Para añadir rellenos entre las celdas de una cuadrícula, se utilizan las opciones padx y pady. El padx y el
pady son rellenos externos:
grid(column, row, sticky, padx, pady)
Para añadir paddings dentro de un widget mismo, se utilizan las opciones ipadx e ipady. Los ipadx e
ipady son acolchados internos:
grid(column, row, sticky, padx, pady, ipadx, ipady)
Los rellenos interno y externo son por defecto cero.
Ejemplo de gestor de geometría de grid Tkinter
En este ejemplo, utilizaremos el gestor de geometría de grid para diseñar una pantalla de acceso como
la siguiente:
La pantalla de inicio de sesión utiliza una cuadrícula que tiene dos columnas y tres filas. Además, la
segunda columna es tres veces más ancha que la primera:
A continuación, se muestra la ventana de inicio de sesión completa:
# root window
root = tk.Tk()
root.title('Login')
root.resizable(0, 0)
# configure the grid

# username
username_label = ttk.Label(root, text="Username:")
username_label.grid(column=0, row=0, sticky=tk.W, padx=5, pady=5)
username_entry = ttk.Entry(root)
username_entry.grid(column=1, row=0, sticky=tk.E, padx=5, pady=5)
# password
password_label = ttk.Label(root, text="Password:")
password_label.grid(column=0, row=1, sticky=tk.W, padx=5, pady=5)
password_entry = ttk.Entry(root, show="*")
password_entry.grid(column=1, row=1, sticky=tk.E, padx=5, pady=5)
# login button
login_button = ttk.Button(root, text="Login")
login_button.grid(column=1, row=3, sticky=tk.E, padx=5, pady=5)
root.mainloop()
¿Cómo funciona?
En primer lugar, utilice el método columnconfigure() para establecer el peso de la primera y la segunda
columna de la cuadrícula. El ancho de la segunda columna es tres veces mayor que el ancho de la
primera columna.
En segundo lugar, coloque la etiqueta del nombre de usuario en la primera columna y la entrada del
nombre de usuario en la segunda columna de la primera fila de la cuadrícula:
username_label = ttk.Label(root, text="Username:")

username_label.grid(column=0, row=0, sticky=tk.W, padx=5, pady=5)
username_entry = ttk.Entry(root, textvariable=username)

username_entry.grid(column=1, row=0, sticky=tk.E, padx=5, pady=5
En tercer lugar, coloque la etiqueta y la entrada de la contraseña en la primera y segunda columna de la

segunda fila:
password_label = ttk.Label(root, text="Password:")
password_label.grid(column=0, row=1, sticky=tk.W, padx=5, pady=5)
password_entry = ttk.Entry(root, textvariable=password, show="*")

password_entry.grid(column=1, row=1, sticky=tk.E, padx=5, pady=5)
Por último, coloque el botón de inicio de sesión en la tercera fila. Dado que su opción de adhesión se
establece en E, el botón se alinea a la derecha de la tercera fila.
login_button = ttk.Button(root, text="Login")
login_button.grid(column=1, row=3, sticky=tk.E, padx=5, pady=5)
Place
El gestor de geometría place de Tkinter permite posicionar con precisión los widgets dentro de su
contenedor utilizando el sistema de coordenadas (x, y).
Para acceder al gestor de geometría de lugar, se utiliza el método place() en todos los widgets estándar
así:
widget.place(**options)
Posiciones absolutas y relativas

El gestor de geometría de lugares ofrece opciones de posicionamiento absoluto y relativo.
 El posicionamiento absoluto se especifica mediante las opciones x, y.
 Las posiciones relativas se especifican mediante las opciones relx y rely.
Especificación de la anchura y la altura

Para establecer la anchura y la altura absolutas del widget en píxeles, se utilizan las opciones de anchura
y altura.
El gestor de geometría de lugares también te proporciona la anchura y la altura relativas mediante las
opciones relwidth y relheight.
Las opciones relwidth y relheight tienen un valor de un número de punto flotante entre 0,0 y 1,0. Este
valor representa una fracción de la anchura y la altura del contenedor.
anchor
Para especificar la posición exacta del widget, se utiliza la opción anchor.
El valor de anchor puede ser N, E, S, W, NW, SE o SW.
El anchor es por defecto NW, que es la esquina superior izquierda del contenedor padre.
Cuando utilizar el gestor de geometría place

En la práctica, rara vez utilizará el gestor de geometría de lugar. La razón es que, si haces un pequeño
cambio en la posición de un widget, necesitas cambiar la posición de otros widgets, lo que es muy
engorroso.
El gestor de lugares sólo es útil cuando quieres construir aplicaciones que permitan a los usuarios finales
decidir dónde colocar los widgets en un contenedor.
Ejemplo de gestor place de Tkinter

El siguiente programa ilustra cómo utilizar el gestor de geometría de lugares:
root = tk.Tk()
root.title('Tkinter place Geometry Manager')
# label 1
label1 = tk.Label( root, text="Absolute placement", bg='red', fg='white' )
label1.place(x=20, y=10)
# label 2
label2 = tk.Label( root, text="Relative placement", bg='blue', fg='white' )
label2.place(relx=0.8, rely=0.2, relwidth=0.5, anchor='ne')
root.mainloop()
Output:
Cambia el tamaño de la ventana:
Cómo funciona.
En primer lugar, este programa coloca dos etiquetas en la ventana raíz utilizando tanto la posición
absoluta como la relativa.
Segundo, si cambias el tamaño de la ventana, verás que la primera etiqueta con la posición absoluta no
cambia su coordenada. Sin embargo, la segunda etiqueta con posición relativa cambia su coordenada
para adaptarse al nuevo tamaño de la ventana.
Resumen
Utilice el gestor de geometría place de Tkinter para posicionar con precisión los widgets dentro de su
contenedor utilizando el sistema de coordenadas (x, y).
Manejo de Imágenes
En Tkinter, algunos widgets pueden mostrar una imagen como Label y Button. Estos widgets toman
un image argumento que les permite mostrar una imagen.
Sin embargo, no puede simplemente pasar la ruta a un archivo de imagen al image argumento. En su
lugar, necesita crear un PhotoImage objeto y páselo image argumento.
Para crear un nuevo PhotoImage objeto, utiliza la siguiente sintaxis:

photo_image = tk.PhotoImage(file=path_to_image)
En esta sintaxis, pasa la ruta de la imagen a la file argumento para crear un nuevo PhotoImage objeto.
Alternativamente, pasa un objeto de bytes que contiene datos de imagen al argumento.
Después de crear un PhotoImage objeto, puede utilizarlo en otros widgets que aceptan un argumento
de imagen:
label = ttk.Label(root, image=photo_image)
Es importante tener en cuenta que mantenga la referencia al objeto PhotoImage en el alcance durante
el tiempo que se muestre la imagen. De lo contrario, la imagen no aparecerá.
El siguiente ejemplo intenta mostrar una imagen con la ruta 'pythonImg.png' en la ventana raíz:
class App(tk.Tk):
def __init__(self):
super().__init__()
python_image = tk.PhotoImage(file='pythonImg.png')
ttk.Label(self, image=python_image).pack()
if __name__ == "__main__":
app = App()
app.mainloop()
Si ejecuta el programa, notará que la ventana no muestra la imagen.
¿Por qué?
Eso es porque el python_image se destruye tan pronto como el __init__() termine. Dado que el
programa no hace referencia al objeto PhotoImage, la imagen desaparece aunque la haya empaquetado
en el diseño.
Para solucionar este problema, debe asegurarse de que el python_image no sale del alcance después de
la finalización del método __init__(). Por ejemplo, puede mantenerlo en la instancia del App clase
como self.python_image:
class App(tk.Tk):
def __init__(self):
super().__init__()
self.title('Tkinter PhotoImage Demo')
self.python_image = tk.PhotoImage(file='pythonImg.png')
ttk.Label(self, image=self.python_image).pack()
if __name__ == "__main__":
app = App()
app.mainloop()
Formatos de archivo de Tkinter PhotoImage
Python Imaging Library (PIL) es una librería gratuita que permite la edición de imágenes directamente
desde Python. Soporta una variedad de formatos, incluídos los más utilizados como GIF, JPEG y PNG.
Una gran parte del código está escrito en C, por cuestiones de rendimiento.
Debido a que la librería soporta únicamente hasta la versión 2.7 de Python y, al parecer, no pretende
avanzar con el desarrollo, Alex Clark y en colaboración con otros programadores ha desarrollado Pillow,
una bifuración más «amigable», según el autor, de PIL que pretende mantener una librería estable y que
se adapte a las nuevas teconologías (Python 3.x). Por esta razón, recomiendo siempre preferir Pillow en
lugar de PIL.
De todas maneras, independientemente de la librería que se desee utilizar, su implementación para los
usuarios se mantiene casi idéntica.
Actualmente, el PhotoImage admite los formatos de archivo GIF, PGM, PPM y PNG a partir de Tkinter
8.6.
Para admitir otros formatos de archivo como JPG, JPEG o BMP, puede utilizar una biblioteca de
imágenes como Pillow para convertirlos a un formato que el PhotoImage widget entiende.
De hecho, la biblioteca Pillow tiene una versión compatible con Tkinter, el widget PhotoImage ubicado
en el PIL.ImageTk módulo.
Librería Pillow:
Instalación: pip install PIL o pip install Pillow
En caso de haber descargado el código de fuente, deberás extraer el archivo ZIP, situarte en el directorio
y ejecutar: python setup.py install
Pillow es algo más organizado, con mayor documentación y, por lo tanto, cuenta con una guía de
instalación bastante completa. Su página en PyPI
https://pypi.python.org/pypi/Pillow/2.5.0#downloads reúne las descargas para todas las plataformas,
incluido el código de fuente comprimido en un archivo ZIP.
Documentación: https://pypi.org/project/Pillow/2.5.0/#downloads
Para utilizar la biblioteca pillow, siga estos pasos:
Primero, importe el Image y ImageTk clases:

from PIL import Image, ImageTk
En segundo lugar, abra el archivo de imagen y cree un nuevo PhotoImage objeto:
image = Image.open('pythonjpg.jpg')
python_image = ImageTk.PhotoImage(image)
En tercer lugar, asigne el ImageTk.PhotoImage objetar a la opción de imagen:

image_label = ttk.Label(root, image=python_image)
El siguiente programa ilustra cómo utilizar el PhotoImage widget de la biblioteca Pillow:

class App(tk.Tk):
def __init__(self):
super().__init__()
self.image = Image.open('pythonjpg.jpg')
self.python_image = ImageTk.PhotoImage(self.image)
if __name__ == "__main__":
app = App()
app.mainloop()
Output:
Cambio de tipo de imagen
Cuando haya terminado de procesar una imagen, puede guardarla en un archivo con el método save(),
pasando el nombre que se utilizará para etiquetar el archivo de imagen. Al guardar una imagen, puede
especificar una extensión diferente a la original, y la imagen guardada se convertirá al formato
especificado.
image = Image.open('demo_image.jpg')
image.save('new_image.png')
Lo anterior crea un objeto Image cargado con la imagen demo_image.jpg y lo guarda en un nuevo
archivo, new_image.png.
Pillow ve que la extensión del archivo ha sido especificada como PNG y por lo tanto lo convierte a PNG
antes de guardarlo en el archivo. Puede proporcionar un segundo argumento a save() para especificar
explícitamente un formato de archivo. Este image.save('new_image.png', 'PNG') hará lo mismo que el
anterior save(). Normalmente, no es necesario suministrar este segundo argumento, ya que Pillow
determinará el formato de almacenamiento de archivos a utilizar a partir de la extensión del nombre del
archivo, pero si está utilizando extensiones no estándar, siempre debe especificar el formato de esta
manera.
Cambio de tamaño de las imágenes (Resizing Images)

Para cambiar el tamaño de una imagen, se llama al método resize() sobre ella, pasando un argumento
de dos tuplas enteras que representan la anchura y la altura de la imagen redimensionada. La función no
modifica la imagen utilizada, sino que devuelve otra imagen con las nuevas dimensiones.
class App(tk.Tk):
def __init__(self):
super().__init__()
self.image = Image.open('pythonjpg.jpg')
new_image = self.image.resize((250,150))
self.python_image = ImageTk.PhotoImage(new_image)
if __name__ == "__main__":
app = App()
app.mainloop()
Output:
Transformación de color
Conversión entre modos

La biblioteca Pillow permite convertir imágenes entre diferentes representaciones de píxeles mediante
el método convert(). Soporta conversiones entre los modos L (escala de grises), RGB y CMYK.
En el siguiente ejemplo, convertimos la imagen de RGB a modo L (luminancia), lo que dará como
resultado una imagen en escala de grises.
image = Image.open('paisaje.jpg')
greyscale_image = image.convert('L')
greyscale_image.save('greyscale_image.jpg')
print(image.mode) # Output: RGB

print(greyscale_image.mode)
Una alternativa para cambiar a escala de grises es la siguiente instrucción:

new_image = ImageOps.grayscale(self.resizedImg)
Mejoras de imagen
Pillow permite mejorar una imagen ajustando su contraste, color, brillo y nitidez mediante las clases del
módulo ImageEnhance.
from PIL import Image, ImageEnhance

image = Image.open(paisaje.jpg')
contrast = ImageEnhance.Contrast(image)
contrast.enhance(1.5).save('contrast.jpg')
En este caso, ajustamos el contraste de la imagen con un factor de 1,5. El factor utilizado en las clases de
mejora es un valor de punto flotante que determina el nivel de mejora. Un factor de 1,0 devuelve una
copia de la imagen original; los factores más bajos significan menos de la mejora particular y los valores
más altos más. No hay ninguna restricción para este valor.
Imagen antes de contraste:
Imagen después de contraste:
Recorte de imagen
Cuando se recorta una imagen, se selecciona una región rectangular dentro de la imagen y se conserva,
mientras que todo lo demás fuera de la región se elimina. Con la biblioteca Pillow, puede recortar una
imagen con el método crop() de la clase Image.
El método toma una tupla de caja que define la posición y el tamaño de la región recortada y devuelve
un objeto Image que representa la imagen recortada. Las coordenadas de la caja son (izquierda,
superior, derecha, inferior). La sección recortada incluye la columna izquierda y la fila superior de píxeles
y llega hasta (pero no incluye) la columna derecha y la fila inferior de píxeles. Esto se explica mejor con
un ejemplo.
from PIL import Image, ImageEnhance
image = Image.open('paisaje.jpg')
box = (200, 300, 700, 600)
cropped_image = image.crop(box)
cropped_image.save('cropped_image.jpg')
# Print size of cropped image

print(cropped_image.size) # Output: (500, 300)
La Python Imaging Library utiliza un sistema de coordenadas que comienza con (0, 0) en la esquina
superior izquierda.
Los dos primeros valores de la tupla box especifican la posición inicial superior izquierda de la caja de
recorte.
El tercer y cuarto valor especifican la distancia en píxeles desde esta posición inicial hacia la derecha y
hacia abajo, respectivamente. Las coordenadas se refieren a las posiciones entre los píxeles, por lo que
la región del ejemplo anterior tiene exactamente 500x300 píxeles.
Referencias
https://aprendepython.org/tutorial-de-tkinter/
https://www.academia.edu/15210965/Manual_interaz_grafica_en_python_tkinter
https://www.academia.edu/13973806/MANUAL_PROGRAMACI%C3%93N_PYTHON_3_4_AUTOR_CARL
OS_VIZCARRA_LUGO
http://sagitario.itmorelia.edu.mx/~rogelio/python_tkinter.pdf
https://www.pythontutorial.net/tkinter/tkinter-ttk/
https://pythonprogramming.altervista.org/tkinter-vs-ttk-better-
widgets/?doing_wp_cron=1656562562.0326929092407226562500
https://www.tutorialspoint.com/python/tk_pack.htm
https://www.educba.com/tkinter-place/?source=leftnav
https://pythonlobby.com/geometry-manager-in-tkinter-place-layout-python-tkinter-tutorial/
https://www.askpython.com/python-modules/tkinter/python-tkinter-grid-example
https://www.tutorialspoint.com/python3/python_gui_programming.htm ***
https://guia-tkinter.readthedocs.io/es/develop/chapters/6-widgets/6.1-Intro.html
https://recursospython.com/guias-y-manuales/apariencia-y-estilos-de-los-controles-en-tkinter/
https://docs.python.org/es/3/library/tkinter.ttk.html
https://www.oulub.com/es-ES/Python/library.tkinter.ttk.html
http://sagitario.itmorelia.edu.mx/~rogelio/python_tkinter.pdf
https://recursospython.com/guias-y-manuales/boton-button-en-tkinter/
https://recursospython.com/guias-y-manuales/posicionar-elementos-en-tkinter/
https://recursospython.com/guias-y-manuales/panel-de-pestanas-notebook-tkinter/
https://www.pythontutorial.net/tkinter/tkinter-place/
https://www.correosdemexico.gob.mx/SSLServicios/SeguimientoEnvio/Seguimiento.aspx
MP491586252MX
https://10.240.35.120:6082/php/uid.php?vsys=1&rule=1&url=http://10.240.35.120%2f
https://gitlab.icelab.lenovo.com/labrador/drumbuildtools/-
/blob/master/scripts/generateDrumMetadata.py
https://lenovobeijing-
my.sharepoint.com/:o:/r/personal/wvetter_lenovo_com/_layouts/15/Doc.aspx?sourcedoc=%7B554692
e3-01b0-4db3-89f3-
fa97c64ddc5d%7D&action=edit&wd=target(OSS%20Core%20System.one%7Cf42e0771-d8b3-417b-
b226-fb5556b22630%2FPayload%5C%2FPackage%7Ce3124d80-823e-46e6-aff0-
a9ca633c4554%2F)&wdorigin=NavigationUrl
https://zetcode.com/tkinter/
https://aprendepython.org/administrador-de-geometria-de-cuadricula-de-tkinter/
https://www.pythontutorial.net/tkinter/tkinter-grid/
https://programacionfacil.org/cursos/tkinter/tkinter_index.html
https://recursospython.com/guias-y-manuales/lista-desplegable-combobox-en-tkinter/
https://www.tutorialspoint.com/python3/python_gui_programming.htm
https://aprendepython.org/administrador-de-geometria-de-cuadricula-de-tkinter/
https://www.pythontutorial.net/tkinter/tkinter-event-binding/
https://python-course.eu/tkinter/events-and-binds-in-tkinter.php
https://pillow.readthedocs.io/en/latest/
https://recursospython.com/guias-y-manuales/vista-de-arbol-treeview-en-tkinter/

Manual Tkinter

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual Tkinter

Cargado por

Copyright:

Formatos disponibles

MANUAL DE TKINTER

I.S.C. Liliana Guadalupe Hernández Rodríguez

from tkinter import messagebox

B = Button(top, text = "Hello", command = helloCallBack)

Pasar los argumentos a command en el botón Tkinter con parciales

def suma(numero1 , numero2):

Sintaxis de lambda: lambda: argument_list: expression

def suma(numero1 , numero2):

Llamada a función sin parámetros por medio de command:

El widget Canvas puede admitir los siguientes elementos estándar -

filename = PhotoImage(file = "sunshine.gif")

line . Crea una línea.

from tkinter import messagebox

C = Canvas(top, bg = "blue", height = 250, width = 300)

coord = 10, 50, 240, 210

También puede mostrar imágenes en lugar de texto.

xview_scroll ( number, what Se utiliza para desplazar la entrada horizontalmente. El argumento

greenbutton = Button(frame, text = "Brown", fg="brown")

bluebutton = Button(frame, text = "Blue", fg = "blue")

blackbutton = Button(bottomframe, text = "Black", fg = "black")

var.set("Hey!? How are you doing?")

 BROWSE - Normalmente, sólo se puede seleccionar una línea de

width Ancho de la etiqueta en caracteres, el default es 20.

activate ( index ) Selecciona la línea especificada por el índice dado.

nearest ( y ) Devuelve el índice de la línea visible más cercana a la coordenada y relativa

size() Devuelve el número de líneas en el cuadro de lista.

xview_moveto ( fraction Desplaza el listbox de forma que la fracción más a la izquierda de la

mb = Menubutton ( top, text = "condiments", relief = RAISED )

mb.menu.add_checkbutton ( label = "mayo",

bg El color de fondo para las opciones que no están bajo el ratón.

add_command (options) Agrega un element al menú.

add_radiobutton( Crea un element de tipo radiobutton en el menú.

add_checkbutton( Crea un elemento de tipo check button en el menú.

add_separator() Agrega una línea separadora al menú.

add( type, options ) Agrega un tipo especifico de elemento al menú

index(item) Devuelve el número de índice del elemento de menú dado.

insert_separator ( index ) Inserta un nuevo separador en la posición especificada por el índice.

filemenu.add_command(label = "Exit", command = root.quit)

editmenu.add_command(label = "Cut", command = donothing)

menubar.add_cascade(label = "Edit", menu = editmenu)

var.set("Hey!? How are you doing?")

deselect() Limpia el radiobutton

R2 = Radiobutton(root, text = "Option 2", variable = var, value = 2,

R3 = Radiobutton(root, text = "Option 3", variable = var, value = 3,

mylist = Listbox(root, yscrollcommand = scrollbar.set )

mylist.pack( side = LEFT, fill = BOTH )

delete(startindex [,endindex]) Borra un caracter específico o un rango de texto.

get(startindex [,endindex]) Retorna un caracter específico o un rango de texto.

index(index) Retorna el valor absolute de un índice basado en un índice.

insert(index [,string]...) Inserta una cadena de texto en un índice especificado.

see(index) Retorna true si el texto ubicado en el índice es visible.

index(mark) Retorna la linea y columna de una marca específica.

mark_gravity(mark Devuelve la gravedad de la marca dada. Si se proporciona el segundo

mark_names() Devuelve todas las marcas del widget Texto.

mark_set(mark, index) Informa de una nueva posición a la marca dada.

mark_unset(mark) Elimina la marca dada del widget Texto.

tag_add(tagname, Este método etiqueta la posición definida por startindex, o un rango

tag_delete(tagname) Este método se utiliza para borrar y eliminar una etiqueta

text.tag_add("here", "1.0", "1.4")

deiconify() Muestra la ventana, después de utilizar los métodos de iconificación o de

frame() Devuelve un identificador de ventana específico del sistema.

group(window) Añade la ventana al grupo de ventanas administrado por la ventana dada.

iconify() Convierte la ventana en un icono, sin destruirla.