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

Tkinter 8.5 reference: a GUI for 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")

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

    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

  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.