Advertencia

¡Ayúdanos a traducir la documentación oficial de Python al Español! Puedes encontrar más información en Como contribuir. Ayuda a acercar Python a más personas de habla hispana.

tkinter — Interface de Python para Tcl/Tk

Código fuente: Lib/tkinter/__init__.py


El paquete tkinter («interfaz Tk») es la interfaz por defecto de Python para el toolkit de la GUI Tk. Tanto Tk como tkinter están disponibles en la mayoría de las plataformas Unix, así como en sistemas Windows (Tk en sí no es parte de Python, es mantenido por ActiveState).

Ejecutar python -m tkinter desde la línea de comandos debería abrir una ventana que demuestre una interfaz Tk simple para saber si tkinter está instalado correctamente en su sistema. También muestra qué versión de Tcl/Tk está instalada para que pueda leer la documentación de Tcl/Tk específica de esa versión.

Ver también

Documentación Tkinter:

Recursos de Python Tkinter

La Guía de temas de Python Tkinter proporciona una gran cantidad de información sobre cómo usar Tk desde Python y enlaces a otras fuentes de información sobre Tk.

TKDocs

Extensive tutorial plus friendlier widget pages for some of the widgets.

Referencia de Tkinter 8.5: una GUI para Python

Material online de referencia.

Documentos de Tkinter de effbot

Referencia en línea para Tkinter producida por effbot.org.

Programming Python

Libro de Mark Lutz, que cubre Tkinter excelentemente bien.

Modern Tkinter for Busy Python Developers

Libro de Mark Roseman sobre la construcción de interfaces gráficas de usuario atractivas y modernas con Python y Tkinter.

Python and Tkinter Programming

Libro de John Grayson (ISBN 1-884777-81-3).

Documentación de Tcl/Tk:

Comandos Tk

La mayoría de los comandos están disponibles como tkinter o tkinter.ttk. Cambie a “8.6” para que coincida con la versión de su instalación Tcl/Tk.

Páginas recientes del manual de Tcl/Tk

Manual reciente de Tcl/Tk en www.tcl.tk.

Página de Inicio de ActiveState Tcl

El desarrollo de Tk/Tcl se está llevando a cabo en gran medida en ActiveState.

Tcl and the Tk Toolkit

Libro de John Ousterhout, el inventor de Tcl.

Practical Programming in Tcl and Tk

Enciclopedia de Brent Welch.

Módulos Tkinter

La mayoría de las veces tkinter es todo lo que realmente necesita, pero también hay disponible varios módulos adicionales. La interfaz Tk se encuentra en un módulo binario llamado _tkinter. Este módulo contiene la interfaz de bajo nivel para Tk, y nunca debe ser utilizado directamente por los desarrolladores. Por lo general, es una biblioteca compartida (o DLL), pero en algunos casos puede estar vinculada estáticamente con el intérprete de Python.

Además del módulo de interfaz Tk, tkinter incluye varios módulos de Python, tkinter.constants es uno de los más importantes. Al Importar tkinter importará automáticamente tkinter.constants, por lo tanto, para usar Tkinter todo lo que se necesita es una simple declaración import:

import tkinter

O, más a menudo:

from tkinter import *
class tkinter.Tk(screenName=None, baseName=None, className='Tk', useTk=1)

La clase Tk se instancia sin argumentos. Esto crea un widget de nivel superior de Tk que generalmente es la ventana principal de una aplicación. Cada instancia tiene su propio intérprete Tcl asociado.

tkinter.Tcl(screenName=None, baseName=None, className='Tk', useTk=0)

The Tcl() function is a factory function which creates an object much like that created by the Tk class, except that it does not initialize the Tk subsystem. This is most often useful when driving the Tcl interpreter in an environment where one doesn’t want to create extraneous toplevel windows, or where one cannot (such as Unix/Linux systems without an X server). An object created by the Tcl() object can have a Toplevel window created (and the Tk subsystem initialized) by calling its loadtk() method.

Otros módulos que proporcionan soporte Tk incluyen:

tkinter.scrolledtext

Widget de texto con una barra de desplazamiento vertical integrada.

tkinter.colorchooser

Cuadro de diálogo que permite al usuario elegir un color.

tkinter.commondialog

Clase base para cuadros de diálogo definidos en los otros módulos listados aquí.

tkinter.filedialog

Cuadros de diálogo por defecto que permiten al usuario especificar un archivo para abrir o guardar.

tkinter.font

Utilidades para ayudar a trabajar con fuentes.

tkinter.messagebox

Acceso a cuadros de diálogo estándar de Tk.

tkinter.simpledialog

Cuadros de diálogo simples y funciones útiles.

tkinter.dnd

Soporte de arrastrar y soltar (drag-and-drop) para tkinter. Esto es experimental y ya no se mantendrá cuando sea reemplazado por Tk DND.

turtle

Gráficos de tortuga en una ventana Tk.

Tkinter Life Preserver

Esta sección no está diseñada para ser un tutorial exhaustivo sobre Tk o Tkinter. Más bien, está pensado como un espacio intermedio que proporciona una orientación introductoria en el sistema.

Créditos:

  • Tk fue escrito por John Ousterhout mientras estaba en Berkeley.

  • Tkinter fue escrito por Steen Lumholt y Guido van Rossum.

  • Esta guía de supervivencia fue escrita por Matt Conway en la Universidad de Virginia.

  • The HTML rendering, and some liberal editing, was produced from a FrameMaker version by Ken Manheimer.

  • Fredrik Lundh elaboró ​​y revisó las descripciones de la interfaz de clase para actualizarlas con Tk 4.2.

  • Mike Clarkson convirtió la documentación a LaTeX y compiló el capítulo de Interfaz de usuario del manual de referencia.

Cómo usar esta sección

This section is designed in two parts: the first half (roughly) covers background material, while the second half can be taken to the keyboard as a handy reference.

Al tratar de responder preguntas sobre cómo hacer «esto o aquello», a menudo es mejor descubrir cómo hacerlo en Tk y luego convertirlo a la función correspondiente tkinter. Los programadores de Python a menudo pueden adivinar el comando Python correcto consultando la documentación de Tk. Esto significa que para usar Tkinter deberá conocer un poco sobre Tk. Este documento no puede cumplir esa función, por lo que lo mejor que podemos hacer es señalarle la mejor documentación que existe. Aquí hay algunos consejos:

  • Los autores sugieren encarecidamente obtener una copia de las páginas del manual de Tk. Específicamente, las páginas del directorio manN son las más útiles. Las páginas del manual man3 describen la interfaz C para la biblioteca Tk y, por lo tanto, no son especialmente útiles para los desarrolladores de scripts.

  • Addison-Wesley publica un libro llamado «Tcl and the Tk Toolkit» de John Ousterhout (ISBN 0-201-63337-X) que es una buena introducción a Tcl y Tk para novatos. El libro no es exhaustivo y para muchos detalles difiere de las páginas del manual.

  • tkinter/__init__.py es el último recurso para la mayoría, pero puede ser un buen lugar para ir cuando nada más tiene sentido.

Un simple programa Hola Mundo

import tkinter as tk

class Application(tk.Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.pack()
        self.create_widgets()

    def create_widgets(self):
        self.hi_there = tk.Button(self)
        self.hi_there["text"] = "Hello World\n(click me)"
        self.hi_there["command"] = self.say_hi
        self.hi_there.pack(side="top")

        self.quit = tk.Button(self, text="QUIT", fg="red",
                              command=self.master.destroy)
        self.quit.pack(side="bottom")

    def say_hi(self):
        print("hi there, everyone!")

root = tk.Tk()
app = Application(master=root)
app.mainloop()

Una (muy) rápida mirada a Tcl/Tk

La jerarquía de clases parece complicada, pero en la práctica, los programadores de aplicaciones casi siempre se refieren a las clases en la parte inferior de la jerarquía.

Notas:

  • Estas clases se proporcionan con el propósito de organizar ciertas funciones en un solo un espacio de nombres. No están destinadas a ser instanciadas independientemente.

  • La clase Tk está destinada a ser instanciada solo una vez en una aplicación. Los desarrolladores no necesitan crear una instancia explícitamente. El sistema crea una cada vez que se instancia cualquiera de las otras clases.

  • The Widget class is not meant to be instantiated, it is meant only for subclassing to make «real» widgets (in C++, this is called an “abstract class”).

Para hacer uso de este material de referencia, habrá momentos en los que necesitará saber cómo leer pasajes cortos de Tk y cómo identificar las diversas partes de un comando Tk. Consulte la sección Mapeo básico de Tk en Tkinter para los equivalentes tkinter de lo que se muestra a continuación.

Los scripts Tk son programas Tcl. Como todos los programas Tcl, los scripts Tk son solo listas de tokens separados por espacios. Un widget Tk es solo su clase, las opciones que ayudan a configurarlo y las acciones que lo hacen hacer cosas útiles.

Para hacer un widget en Tk, el comando siempre tiene la siguiente forma:

classCommand newPathname options
classCommand

denota qué tipo de widget hacer (un botón, una etiqueta, un menú…)

newPathname

es el nuevo nombre para este widget. Todos los nombres en Tk deben ser únicos. Para ayudar a aplicar esto, los widgets en Tk se nombran con rutas, al igual que los archivos en un sistema de archivos. El widget de nivel superior, el root, se llama . (punto) y los elementos secundarios están delimitados por más puntos. Por ejemplo, .myApp.controlPanel.okButton podría ser el nombre de un widget.

options

configurar la apariencia del widget y, en algunos casos, su comportamiento. Las opciones vienen en forma de una lista de parámetros y valores. Los parámetros están precedidas por un “-“, como los parámetros en una shell de Unix, y los valores se ponen entre comillas si son más de una palabra.

Por ejemplo:

button   .fred   -fg red -text "hi there"
   ^       ^     \______________________/
   |       |                |
 class    new            options
command  widget  (-opt val -opt val ...)

Una vez creado, la ruta de acceso al widget se convierte en un nuevo comando. Este nuevo comando de widget es el identificador para que el nuevo widget realice alguna acción. En C, expresarías esto como someAction(fred, someOptions); en C++, expresarías esto como fred.someAction(someOptions), y en Tk:

.fred someAction someOptions

Tenga en cuenta que el nombre del objeto, .fred, comienza con un punto.

Como era de esperar, los valores legales para someAction dependerán de la clase del widget: .fred disable funciona si fred es un botón (se atenúa), pero no funciona si fred es una etiqueta (la desactivación de etiquetas no es compatible con Tk).

Los valores legales de someOptions dependen de la acción. Algunas acciones, como disable, no requieren argumentos; otras, como el comando delete de un cuadro de entrada de texto, necesitarían argumentos para especificar qué rango de texto eliminar.

Mapeo básico de Tk en Tkinter

Los comandos de clase en Tk corresponden a constructores de clase en Tkinter.:

button .fred                =====>  fred = Button()

The master of an object is implicit in the new name given to it at creation time. In Tkinter, masters are specified explicitly.

button .panel.fred          =====>  fred = Button(panel)

The configuration options in Tk are given in lists of hyphened tags followed by values. In Tkinter, options are specified as keyword-arguments in the instance constructor, and keyword-args for configure calls or as instance indices, in dictionary style, for established instances. See section Configuración de opciones on setting options.

button .fred -fg red        =====>  fred = Button(panel, fg="red")
.fred configure -fg red     =====>  fred["fg"] = red
                            OR ==>  fred.config(fg="red")

In Tk, to perform an action on a widget, use the widget name as a command, and follow it with an action name, possibly with arguments (options). In Tkinter, you call methods on the class instance to invoke actions on the widget. The actions (methods) that a given widget can perform are listed in tkinter/__init__.py.

.fred invoke                =====>  fred.invoke()

Para pasar el widget al empaquetador (que administra el diseño de la pantalla) en Tk, llame al comando pack con argumentos opcionales. En Tkinter, la clase Pack tiene todas estas funcionalidades y las diferentes formas del comando pack se implementan como métodos. Todos los widgets en tkinter son subclases del empaquetador, por lo que heredan todos los métodos de empaquetado. Consulte la documentación del módulo tkinter.tix para obtener más información sobre el administrador de diseño de formularios.

pack .fred -side left       =====>  fred.pack(side="left")

Guía práctica

Configuración de opciones

Las opciones controlan parámetros como el color y el ancho del borde de un widget. Las opciones se pueden configurar de tres maneras:

En el momento de la creación del objeto, utilizando argumentos de palabras clave
fred = Button(self, fg="red", bg="blue")
Después de la creación del objeto, tratando el nombre de la opción como un índice de diccionario
fred["fg"] = "red"
fred["bg"] = "blue"
Usando el método config() para actualizar múltiples atributos después de la creación del objeto
fred.config(fg="red", bg="blue")

Para obtener una explicación completa de las opciones y su comportamiento, consulte las páginas de manual de Tk para el widget en cuestión.

Tenga en cuenta que las páginas del manual enumeran «OPCIONES ESTÁNDAR» y «OPCIONES ESPECÍFICAS DE WIDGET» para cada widget. La primera es una lista de opciones que son comunes a muchos widgets, la segunda son las opciones que son específicas para ese widget en particular. Las opciones estándar están documentadas en la página del manual options(3).

No se hace distinción entre las opciones estándar y las opciones específicas del widget en este documento. Algunas opciones no se aplican a algunos tipos de widgets. Si un determinado widget responde a una opción particular depende de la clase del widget. Los botones tienen la opción command, las etiquetas no.

Las opciones admitidas por un widget dado se enumeran en la página de manual de ese widget, o se pueden consultar en tiempo de ejecución llamando al método config() sin argumentos, o llamando al método keys() en ese widget. El valor retornado en esas llamadas es un diccionario cuya clave es el nombre de la opción como una cadena (por ejemplo, 'relief') y cuyo valor es una tupla de 5 elementos.

Algunas opciones, como bg, son sinónimos de opciones comunes con nombres largos (bg es la abreviatura de «background»). Al pasar el método config(), el nombre de una opción abreviada retornará una tupla de 2 elementos (en lugar de 5). Esta tupla contiene nombres de sinónimos y nombres de opciones «reales» (como ('bg', 'background')).

Índice

Significado

Ejemplo

0

nombre de la opción

'relief'

1

option name for database lookup

'relief'

2

clase de la opción para la consulta de base de datos

'Relief'

3

valor por defecto

'raised'

4

valor actual

'groove'

Ejemplo:

>>> print(fred.config())
{'relief': ('relief', 'relief', 'Relief', 'raised', 'groove')}

Por supuesto, el diccionario impreso incluirá todas las opciones disponibles y sus valores. Esto es solo un ejemplo.

El empaquetador

The packer is one of Tk’s geometry-management mechanisms. Geometry managers are used to specify the relative positioning of the positioning of widgets within their container - their mutual master. In contrast to the more cumbersome placer (which is used less commonly, and we do not cover here), the packer takes qualitative relationship specification - above, to the left of, filling, etc - and works everything out to determine the exact placement coordinates for you.

El tamaño de cualquier widget master está determinado por el tamaño del «widget esclavo» interno. El empaquetador se usa para controlar dónde se colocará el widget esclavo en el widget maestro de destino. Para lograr el diseño deseado, puede empaquetar el widget en un marco y luego empaquetar ese marco en otro. Además, una vez empaquetado, la disposición se ajusta dinámicamente de acuerdo con los cambios de configuración posteriores.

Tenga en cuenta que los widgets no aparecen hasta que su geometría no se haya especificado con un administrador de diseño de pantalla. Es un error común de principiante ignorar la especificación de la geometría, y luego sorprenderse cuando se crea el widget pero no aparece nada. Un objeto gráfico solo aparece después que, por ejemplo, se le haya aplicado el método pack() del empaquetador.

Se puede llamar al método pack() con pares palabra-clave/valor que controlan dónde debe aparecer el widget dentro de su contenedor y cómo se comportará cuando se cambie el tamaño de la ventana principal de la aplicación. Aquí hay unos ejemplos:

fred.pack()                     # defaults to side = "top"
fred.pack(side="left")
fred.pack(expand=1)

Opciones del empaquetador

Para obtener más información sobre el empaquetador y las opciones que puede tomar, consulte el manual y la página 183 del libro de John Ousterhout.

anchor

Tipo de anclaje. Indica dónde debe colocar el empaquetador a cada esclavo en su espacio.

expand

Un valor booleano, 0 o 1.

fill

Los valores legales son: 'x', 'y', 'both', 'none'.

ipadx y ipady

Una distancia que designa el relleno interno a cada lado del widget esclavo.

padx y pady

Una distancia que designa el relleno externo a cada lado del widget esclavo.

side

Los valores legales son: 'left', 'right', 'top', 'bottom'.

Asociación de variables de widget

La asignación de un valor a ciertos objetos gráficos (como los widgets de entrada de texto) se puede vincular directamente a variables en su aplicación utilizando opciones especiales. Estas opciones son variable, textvariable, onvalue, offvalue, y value. Esta conexión funciona en ambos sentidos: si la variable cambia por algún motivo, el widget al que está conectado se actualizará para reflejar el nuevo valor.

Desafortunadamente, en la implementación actual de tkinter no es posible entregar una variable arbitraria de Python a un widget a través de una opción variable o textvariable . Los únicos tipos de variables para las cuales esto funciona son variables que son subclases de la clase Variable, definida en tkinter.

Hay muchas subclases útiles de Variable ya definidas: StringVar, IntVar, DoubleVar, and BooleanVar. Para leer el valor actual de dicha variable, es necesario llamar al método get(), y para cambiar su valor, al método set(). Si se sigue este protocolo, el widget siempre rastreará el valor de la variable, sin ser necesaria ninguna otra intervención.

Por ejemplo:

class App(Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.pack()

        self.entrythingy = Entry()
        self.entrythingy.pack()

        # here is the application variable
        self.contents = StringVar()
        # set it to some value
        self.contents.set("this is a variable")
        # tell the entry widget to watch this variable
        self.entrythingy["textvariable"] = self.contents

        # and here we get a callback when the user hits return.
        # we will have the program print out the value of the
        # application variable when the user hits return
        self.entrythingy.bind('<Key-Return>',
                              self.print_contents)

    def print_contents(self, event):
        print("hi. contents of entry is now ---->",
              self.contents.get())

El gestor de ventanas

En Tk hay un comando útil, wm, para interactuar con el gestor de ventanas. Las opciones del comando wm le permiten controlar cosas como títulos, ubicación, iconos de ventana y similares. En tkinter, estos comandos se han implementado como métodos de la clase Wm. Los widgets de Toplevel son subclases de Wm, por lo que se puede llamar directamente a los métodos de Wm.

Para acceder a la ventana Toplevel que contiene un objeto gráfico dado, a menudo puede simplemente referirse al padre de este objeto gráfico. Por supuesto, si el objeto gráfico fue empaquetado dentro de un marco, el padre no representará la ventana de nivel superior. Para acceder a la ventana de nivel superior que contiene un objeto gráfico arbitrario, puede llamar al método _root() . Este método comienza con un subrayado para indicar que esta función es parte de la implementación y no de una interfaz a la funcionalidad Tk.

Aquí hay algunos ejemplos típicos:

import tkinter as tk

class App(tk.Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.pack()

# create the application
myapp = App()

#
# here are method calls to the window manager class
#
myapp.master.title("My Do-Nothing Application")
myapp.master.maxsize(1000, 400)

# start the program
myapp.mainloop()

Tipos de datos de opciones Tk

anchor

Los valores legales son los puntos de la brújula: "n", "ne", "e", "se", "s", "sw", "w", "nw", y también "center".

bitmap

There are eight built-in, named bitmaps: 'error', 'gray25', 'gray50', 'hourglass', 'info', 'questhead', 'question', 'warning'. To specify an X bitmap filename, give the full path to the file, preceded with an @, as in "@/usr/contrib/bitmap/gumby.bit".

boolean

Se puede pasar enteros 0 o 1 o las cadenas "yes" or "no".

callback

Esto es cualquier función de Python que no toma argumentos. Por ejemplo:

def print_it():
    print("hi there")
fred["command"] = print_it
color

Colors can be given as the names of X colors in the rgb.txt file, or as strings representing RGB values in 4 bit: "#RGB", 8 bit: "#RRGGBB", 12 bit» "#RRRGGGBBB", or 16 bit "#RRRRGGGGBBBB" ranges, where R,G,B here represent any legal hex digit. See page 160 of Ousterhout’s book for details.

cursor

Los nombres estándar del cursor X de cursorfont.h se pueden usar sin el prefijo XC_. Por ejemplo, para obtener un cursor de mano (XC_hand2), use la cadena "hand2". También se puede especificar su propio mapa de bits y archivo de máscara. Ver página 179 del libro de Ousterhout.

distance

Screen distances can be specified in either pixels or absolute distances. Pixels are given as numbers and absolute distances as strings, with the trailing character denoting units: c for centimetres, i for inches, m for millimetres, p for printer’s points. For example, 3.5 inches is expressed as "3.5i".

font

Tk usa un formato de lista para los nombres de fuentes, como {courier 10 bold}. Los tamaños de fuente expresados en números positivos se miden en puntos, mientras que los tamaños con números negativos se miden en píxeles.

geometry

Es una cadena de caracteres del estilo widthxheight, donde el ancho y la altura se miden en píxeles para la mayoría de los widgets (en caracteres para widgets que muestran texto). Por ejemplo: fred["geometry"] = "200x100".

justify

Los valores legales son las cadenas de caracteres: "left", "center", "right", y "fill".

region

Es una cadena de caracteres con cuatro elementos delimitados por espacios, cada uno de ellos es una distancia legal (ver arriba). Por ejemplo: "2 3 4 5" , "3i 2i 4.5i 2i" y "3c 2c 4c 10.43c" son todas regiones legales.

relief

Determina cuál será el estilo de borde de un widget. Los valores legales son: "raised", "sunken", "flat", "groove", y "ridge".

scrollcommand

Este es casi siempre el método set() de algún widget de barra de desplazamiento, pero puede ser cualquier método de un widget que tome un solo argumento.

wrap:

Debe ser uno de estos: "none", "char", o "word".

Enlaces y eventos

El método de enlace (binding) del comando del widget le permite observar ciertos eventos y hacer que la función de devolución de llamada se active cuando se produce ese tipo de evento. La forma del método de enlace es:

def bind(self, sequence, func, add=''):

donde:

sequence

es una cadena que denota el tipo de evento objetivo. Para obtener más información, consulte la página del manual de Bind y la página 201 del libro de John Ousterhout.

func

is a Python function, taking one argument, to be invoked when the event occurs. An Event instance will be passed as the argument. (Functions deployed this way are commonly known as callbacks.)

add

es opcional, ya sea '' o '+'. Pasar una cadena de caracteres vacía indica que este enlace anulará cualquier otro enlace asociado con este evento. Pasar '+' agrega esta función a la lista de funciones vinculadas a este tipo de evento.

Por ejemplo:

def turn_red(self, event):
    event.widget["activeforeground"] = "red"

self.button.bind("<Enter>", self.turn_red)

Notice how the widget field of the event is being accessed in the turn_red() callback. This field contains the widget that caught the X event. The following table lists the other event fields you can access, and how they are denoted in Tk, which can be useful when referring to the Tk man pages.

Tk

Campo evento de Tkinter

Tk

Campo evento de Tkinter

%f

focus

%A

char

%h

height

%E

send_event

%k

keycode

%K

keysym

%s

state

%N

keysym_num

%t

time

%T

type

%w

width

%W

widget

%x

x

%X

x_root

%y

y

%Y

y_root

El parámetro índice

Muchos widgets requieren que se pase un parámetro índice. Se utiliza para señalar ubicaciones específicas en el widget de texto, caracteres específicos en el widget de entrada, o elementos particulares en el widget de menú.

Índice de widget de entrada (índice, índice de vista, etc.)

El widget entrada tiene una opción para referirse a la posición de los caracteres del texto que se muestra. Puede acceder a estos puntos especiales en un widget de texto utilizando la siguiente función de tkinter:

Índice de widget de texto

La notación de índice del widget de texto es muy rica y se detalla mejor en las páginas del manual de Tk.

Índices de menú (menu.invoke(), menu.entryconfig(), etc.)

Algunas opciones y métodos para menús manipulan entradas de menú específicas. Cada vez que se necesita un índice de menú para una opción o un parámetro, se puede pasar:

  • un número entero que se refiere a la posición numérica de la entrada en el widget, contada desde arriba, comenzando con 0;

  • la cadena "active", que se refiere a la posición del menú que está actualmente debajo del cursor;

  • la cadena de caracteres "last" que se refiere al último elemento del menú;

  • Un número entero precedido por @, como en @6, donde el entero es interpretado como una coordenada y de píxeles en el sistema de coordenadas del menú;

  • la cadena de caracteres "none", que indica que no hay entrada de menú, usado frecuentemente con menu.activate() para desactivar todas las entradas; y, finalmente,

  • una cadena de texto cuyo patrón coincide con la etiqueta de la entrada del menú, tal como se explora desde la parte superior del menú hasta la parte inferior. Tenga en cuenta que este tipo de índice se considera después de todos los demás, lo que significa que las coincidencias para los elementos del menú etiquetados last, active, o none pueden interpretarse de hecho como los literales anteriores.

Imágenes

Se pueden crear imágenes de diferentes formatos a través de la correspondiente subclase de tkinter.Image:

  • BitmapImage para imágenes en formato XBM.

  • PhotoImage para imágenes en formatos PGM, PPM, GIF y PNG. Este último es compatible a partir de Tk 8.6.

Cualquier tipo de imagen se crea a través de la opción file o data (también hay otras opciones disponibles).

El objeto imagen se puede usar siempre que algún widget admita una opción de image (por ejemplo, etiquetas, botones, menús). En estos casos, Tk no mantendrá una referencia a la imagen. Cuando se elimina la última referencia de Python al objeto de imagen, los datos de la imagen también se eliminan, y Tk mostrará un cuadro vacío donde se utilizó la imagen.

Ver también

El paquete Pillow añade soporte para los formatos del tipo BMP, JPEG, TIFF, y WebP, entre otros.

Gestor de archivos

Tk allows you to register and unregister a callback function which will be called from the Tk mainloop when I/O is possible on a file descriptor. Only one handler may be registered per file descriptor. Example code:

import tkinter
widget = tkinter.Tk()
mask = tkinter.READABLE | tkinter.WRITABLE
widget.tk.createfilehandler(file, mask, callback)
...
widget.tk.deletefilehandler(file)

Esta función no está disponible en Windows.

Dado que no se sabe cuántos bytes están disponibles para su lectura, no use métodos de BufferedIOBase o TextIOBase read() o readline(), ya que estos requieren leer un número predefinido de bytes. Para sockets, los métodos recv() o recvfrom() trabajan bien; para otros archivos, use lectura sin formato o os.read(file.fileno(), maxbytecount).

Widget.tk.createfilehandler(file, mask, func)

Registra la función callback gestor de archivos func. El argumento file puede ser un objeto con un método fileno() (como un archivo u objeto de socket), o un descriptor de archivo entero. El argumento mask es una combinación ORed de cualquiera de las tres constantes que siguen. La retrollamada se llama de la siguiente manera:

callback(file, mask)
Widget.tk.deletefilehandler(file)

Anula el registro de un gestor de archivos.

tkinter.READABLE
tkinter.WRITABLE
tkinter.EXCEPTION

Constantes utilizadas en los argumentos mask.