# `tkinter` — Interface de Python para Tcl/Tk

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

The `tkinter` package («Tk interface») is the standard Python interface to the Tcl/Tk GUI toolkit. Both Tk and `tkinter` are available on most Unix platforms, including macOS, as well as on Windows systems.

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

- TkDocs

    Extensive tutorial on creating user interfaces with Tkinter. Explains key concepts, and illustrates recommended approaches using the modern API.

- Tkinter 8.5 reference: a GUI for Python

    Reference documentation for Tkinter 8.5 detailing available classes, methods, and options.

Tcl/Tk Resources:

- Comandos Tk

    Comprehensive reference to each of the underlying Tcl/Tk commands used by Tkinter.

- Tcl/Tk Home Page

    Additional documentation, and links to Tcl/Tk core development.

Books:

- Modern Tkinter for Busy Python Developers

    By Mark Roseman. (ISBN 978-1999149567)

- Python and Tkinter Programming

    By Alan Moore. (ISBN 978-1788835886)

- Programming Python

    By Mark Lutz; has excellent coverage of Tkinter. (ISBN 978-0596158101)

- Tcl and the Tk Toolkit (2nd edition)

    By John Ousterhout, inventor of Tcl/Tk, and Ken Jones; does not cover Tkinter. (ISBN 978-0321336330)

## Módulos Tkinter

Support for Tkinter is spread across several modules. Most applications will need the main `tkinter` module, as well as the `tkinter.ttk` module, which provides the modern themed widget set and API:

    from tkinter import *
    from tkinter import ttk

class `tkinter.``Tk`(screenName=None, baseName=None, className='Tk', useTk=True, sync=False, use=None)

  Construct a toplevel Tk widget, which is usually the main window of an application, and initialize a Tcl interpreter for this widget. Each instance has its own associated Tcl interpreter.

  The `Tk` class is typically instantiated using all default values. However, the following keyword arguments are currently recognized:

  screenName

    When given (as a string), sets the `DISPLAY` environment variable. (X11 only)

  baseName

    Name of the profile file. By default, baseName is derived from the program name (`sys.argv[0]`).

  className

    Name of the widget class. Used as a profile file and also as the name with which Tcl is invoked (argv0 in interp).

  useTk

    If `True`, initialize the Tk subsystem. The `tkinter.Tcl()` function sets this to `False`.

  sync

    If `True`, execute all X server commands synchronously, so that errors are reported immediately. Can be used for debugging. (X11 only)

  use

    Specifies the id of the window in which to embed the application, instead of it being created as an independent toplevel window. id must be specified in the same way as the value for the -use option for toplevel widgets (that is, it has a form like that returned by `winfo_id()`).

    Note that on some platforms this will only work correctly if id refers to a Tk frame or toplevel that has its -container option enabled.

  `Tk` reads and interprets profile files, named `.className.tcl` and `.baseName.tcl`, into the Tcl interpreter and calls `exec()` on the contents of `.className.py` and `.baseName.py`. The path for the profile files is the `HOME` environment variable or, if that isn’t defined, then `os.curdir`.

  `tk`

    The Tk application object created by instantiating `Tk`. This provides access to the Tcl interpreter. Each widget that is attached the same instance of `Tk` has the same value for its `tk` attribute.

  `master`

    The widget object that contains this widget. For `Tk`, the master is `None` because it is the main window. The terms master and parent are similar and sometimes used interchangeably as argument names; however, calling `winfo_parent()` returns a string of the widget name whereas `master` returns the object. parent/child reflects the tree-like relationship while master/slave reflects the container structure.

  `children`

    The immediate descendants of this widget as a `dict` with the child widget names as the keys and the child instance objects as the values.

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

  La función `Tcl()` es una función de fábrica que crea un objeto muy similar al creado por la clase `Tk`, excepto que no inicializa el subsistema Tk. Esto suele ser útil cuando se maneja el intérprete de Tcl en un entorno en el que no se desean crear ventanas de nivel superior extrañas o donde no se puede (como los sistemas Unix/Linux sin un servidor X). Un objeto creado por el objeto `Tcl()` puede tener una ventana Toplevel creada (y el subsistema Tk inicializado) llamando a su método `loadtk()`.

The modules that provide Tk support include:

`tkinter`

  Main Tkinter module.

`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.scrolledtext`

  Widget de texto con una barra de desplazamiento vertical integrada.

`tkinter.simpledialog`

  Cuadros de diálogo simples y funciones útiles.

`tkinter.ttk`

  Themed widget set introduced in Tk 8.5, providing modern alternatives for many of the classic widgets in the main `tkinter` module.

Additional modules:

`_tkinter`

  A binary module that contains the low-level interface to Tcl/Tk. It is automatically imported by the main `tkinter` module, and should never be used directly by application programmers. It is usually a shared library (or DLL), but might in some cases be statically linked with the Python interpreter.

`idlelib`

  Python’s Integrated Development and Learning Environment (IDLE). Based on `tkinter`.

`tkinter.constants`

  Symbolic constants that can be used in place of strings when passing various parameters to Tkinter calls. Automatically imported by the main `tkinter` module.

`tkinter.dnd`

  (experimental) Drag-and-drop support for `tkinter`. This will become deprecated when it is replaced with the Tk DND.

`tkinter.tix`

  (deprecated) An older third-party Tcl/Tk package that adds several new widgets. Better alternatives for most can be found in `tkinter.ttk`.

`turtle`

  Gráficos de tortuga en una ventana Tk.

## Guía de supervivencia de Tkinter

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.

- El renderizado HTML, y algunas ediciones libres, fueron producidas a partir de una versión de FrameMaker por 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

Esta sección está diseñada en dos partes: la primera mitad (aproximadamente) cubre el material de fondo, mientras que la segunda mitad se puede llevar al teclado como referencia práctica.

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.

- La clase `Widget` no está destinada a ser instanciada, solo está destinada a subclases para crear widgets «reales» (en C++, esto se llama una “clase abstracta”).

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()

El constructor de un objeto está implícito en el nuevo nombre que se le dio durante la creación. En Tkinter, los constructores se especifican explícitamente.

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

Las opciones de configuración en Tk se dan en listas de etiquetas con guiones seguidas de valores. En Tkinter, las opciones se especifican como argumentos de palabras clave en el constructor de instancias y argumentos de palabras clave para llamadas de configuración o como índices de instancias, en estilo diccionario, para instancias establecidas. Consulte la sección Configuración de opciones sobre las opciones de configuración.

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

En Tk, para realizar una acción en un widget, use el nombre del widget como un comando y siga con un nombre de acción, posiblemente con argumentos (opciones). En Tkinter, llamas a métodos en la instancia de clase para invocar acciones en el widget. Las acciones (métodos) que puede realizar un widget determinado se enumeran en `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")

## Cómo se relacionan Tk y Tkinter

De arriba para abajo:

Tu aplicación (Python)

  Una aplicación Python hace una llamada `tkinter`.

tkinter (paquete de Python)

  Esta llamada (por ejemplo, crear un widget de botón) se implementa en el paquete `tkinter`, que está escrito en Python. Esta función de Python analizará los comandos y los argumentos y los convertirá en una forma que los haga ver como si vinieran de un script Tk en lugar de un script Python.

_tkinter (C)

  Estos comandos y sus argumentos se pasarán a una función C en el módulo de extensión `_tkinter` -obsérvese el guión bajo-.

Tk Widgets (C y Tcl)

  Esta función en C puede realizar llamadas a otros módulos C, incluidas las funciones de C que forman la biblioteca Tk. Tk se implementa usando C y un poco de Tcl. La parte Tcl de los widgets Tk se usa para vincular ciertos comportamientos predeterminados de los widgets, y se ejecuta una vez cuando se importa el paquete Python `tkinter` (el usuario nunca ve esta etapa).

Tk (C)

  La parte Tk de los widgets Tk implementa el mapeo final a…

Xlib (C)

  la biblioteca Xlib para dibujar elementos gráficos en la pantalla.

## 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 | nombre de la opción para la búsqueda en la base de datos | `'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

El empaquetador es uno de los mecanismos de gestión de geometría de Tk. Los administradores de geometría se utilizan para especificar la posición relativa de los widgets dentro de su contenedor: su master mutuo. En contraste con el placer más engorroso (que se usa con menos frecuencia, y no cubrimos aquí), el empaquetador toma la especificación de relación cualitativa - above, to the left of, filling, etc - y funciona todo para determinar las coordenadas de ubicación exactas para usted.

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:

    import tkinter as tk

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

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

            # Create the application variable.
            self.contents = tk.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

            # Define a callback for when the user hits return.
            # It prints the current value of the variable.
            self.entrythingy.bind('<Key-Return>',
                                 self.print_contents)

        def print_contents(self, event):
            print("Hi. The current entry content is:",
                  self.contents.get())

    root = tk.Tk()
    myapp = App(root)
    myapp.mainloop()

### 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

  Hay ocho nombres de bitmaps integrados: `'error'`, `'gray25'`, `'gray50'`, `'hourglass'`, `'info'`, `'questhead'`, `'question'`, `'warning'`. Para especificar un nombre de archivo de mapa de bits de X, indique la ruta completa del archivo, precedida por una `@`, como en `"@/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

  Las distancias de pantalla se pueden especificar tanto en píxeles como en distancias absolutas. Los píxeles se dan como números y las distancias absolutas como cadenas con el carácter final que indica unidades: `c` para centímetros, `i` para pulgadas, `m` para milímetros, `p` para puntos de impresora. Por ejemplo, 3.5 pulgadas se expresa como `"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

  es una función de Python que toma un argumento y se llama cuando ocurre el evento. La instancia del evento se pasa como el argumento mencionado. (Las funciones implementadas de esta manera a menudo se llaman 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)

Observe cómo se accede al campo del widget del evento en la devolución de llamada `turn_red()`. Este campo contiene el widget que capturó el evento de X. La siguiente tabla enumera los otros campos de eventos a los que puede acceder y cómo se indican en Tk, lo que puede ser útil cuando se hace referencia a las páginas del manual de Tk.

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 permite registrar y anular el registro de una función de devolución de llamada que se llamará desde el mainloop de Tk cuando la E/S sea posible en un descriptor de archivo. Solo se puede registrar un controlador por descriptor de archivo. Código de ejemplo:

    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.