# `tkinter` — Python interface to 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.

Running `python -m tkinter` from the command line should open a window demonstrating a simple Tk interface, letting you know that `tkinter` is properly installed on your system, and also showing what version of Tcl/Tk is installed, so you can read the Tcl/Tk documentation specific to that version.

Tkinter soporta un amplio rango de versiones TCL/TK, construidos con o sin soporte de hilo. La versión oficial del binario de python incluye Tcl/Tk 8.6 con subprocesos. Vea el código fuente para el módulo `_tkinter` para mayor información acerca de las versiones soportadas.

Tkinter no es un subproceso liviano pero agrega una buena cantidad de su propia lógica para hacer la experiencia mas pythónico. Esta documentación se concentrará en estas adiciones y cambios, refiriéndose sobre la documentación oficial de Tcl-Tk para los detalles que no han sido cambiados.

Nota

Tcl/Tk 8.5 (2007) introdujo un moderno conjunto de componentes temáticos de interfaz de usuario en conjunto con una nueva API para ser usada. Ambas API tanto la antigua como la nueva están disponibles. La mayor parte de la documentación que podrá encontrar en línea aún usa la antigua versión de la API y por lo tanto podría estar desactualizada.

This is an optional module. If it is missing from your copy of CPython, look for documentation from your distributor (that is, whoever provided Python to you). If you are the distributor, see Requirements for optional modules.

Ver también

- TkDocs

    Es un extenso tutorial sobre como crear interfaces de usuario con Tkinter. Explica conceptos clave y muestra enfoques recomendados para usar la API moderna.

- Tkinter 8.5 reference: a GUI for Python

    Documentación de referencia sobre Tkinter 8.5 donde se detallan clases disponibles, métodos y opciones.

Recursos de Tcl/Tk:

- Comandos Tk

    Referencia exhaustiva para cada uno de los comandos subyacentes utilizados por Tkinter.

- Tcl/Tk Home Page

    Documentación adicional y enlaces al núcleo de desarrollo de Tcl/Tk.

Libros:

- Modern Tkinter for Busy Python Developers

    Escrito por Mark Roseman (ISBN 978-1999149567)

- Python GUI programming with Tkinter

    By Alan D. Moore. (ISBN 978-1788835886)

- Programming Python

    Escrito por Mark Lutz, que cubre los tópicos de Tkinter de forma excelente. (ISBN 978-0596158101)

- Tcl and the Tk Toolkit

    Escrito por John Ousterhout, creador de Tcl/Tk y Kevin Jones, el cual no cubre Tkinter. (ISBN 978-0321336330)

## Arquitectura

Tcl/Tk no es una biblioteca única mas bien consiste en unos pocos módulos distintivos entre si. cada uno separados por funcionalidades y que poseen su documentación oficial. Las versiones del binario de Python también incluyen un módulo adicional con esto.

Tcl

  Tcl es un lenguaje de programación interpretado y dinámico, tal como Python. Aunque puede ser usado en si mismo como un lenguaje de programación de uso general, lo más común es que se utilice en aplicaciones del lenguaje C como un motor de secuencias de comandos o como una interfaz hacia el kit de herramientas de Tk. La librería TCL contiene una interfaz con C que crea y gestiona una o más instancias del intérprete de TCL, corre los comandos en TCL en esas instancias y agrega comandos personalizados tanto en Tcl o C. Cada intérprete tiene su cola de eventos y entrega facilidades para enviar procesos a la cola y procesarlos. A diferencia de Python, el modelo de ejecución en Tcl es diseñado alrededor de cooperar en múltiples asignaciones y Tkinter ayuda a salvar estas diferencias (ver Threading model para más detalles).

Tk

  Tk es un paquete de Tcl implementado en C que agrega comandos personalizados que permiten manipular widget en la GUI. Cada objeto de la clase `Tk` agrega su instancia de interprete Tcl con Tk cargado en el. Los widget de Tk son muy personalizables, aunque a costa de una apariencia anticuada. Tk usa eventos de la cola de Tcl para generar y procesar eventos de la GUI.

Ttk

  El nuevo tema Tk (Ttk) es una nueva familia de widgets de Tk que proveen una mejor apariencia en diferentes plataformas mas que varios de los widgets clásicos de Tk. Ttk es distribuido como parte de Tk estando disponible a partir de la versión 8.5. Enlaces para Python son entregados en un módulo aparte, `tkinter.ttk`.

Internamente, Tk y Ttk usan funcionalidades del sistema operativo subyacente, en otras palabras, Xlib en Unix/X11, Cocoa en macOS o GDI en Windows.

When your Python application uses a class in Tkinter, e.g., to create a widget, the `tkinter` module first assembles a Tcl/Tk command string. It passes that Tcl command string to an internal `_tkinter` binary module, which then calls the Tcl interpreter to evaluate it. The Tcl interpreter will then call into the Tk and/or Ttk packages, which will in turn make calls to Xlib, Cocoa, or GDI.

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

  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.

  La clase `Tk` normalmente se instancia utilizando los valores predeterminados. No obstante, se reconocen los siguientes argumentos de palabra clave:

  screenName

    Cuando se proporciona (como cadena de caracteres), establece la variable de entorno `DISPLAY`. (solo X11)

  baseName

    Nombre del archivo de perfil. De forma predeterminada, baseName se deriva del nombre del programa (`sys.argv[0]`).

  className

    Nombre de la clase del widget. Se utiliza como archivo de perfil y como nombre con el que se invoca a Tcl (argv0 en interp).

  useTk

    Si es True, inicializa el subsistema Tk. La función `tkinter.Tcl()` se establece en False.

  sync

    Si es `True`, ejecuta todos los comandos del servidor X de forma síncrona, por lo tanto, los errores se notifican inmediatamente. Se puede utilizar en el proceso de depuración. (solo X11)

  use

    Especifica el id de la ventana en la que se incrustar la aplicación, en lugar de crearla como una ventana independiente de nivel superior. El id debe especificarse de la misma manera que el valor para la opción -use de los widgets de nivel superior (es decir, emplea el formato de retorno de `winfo_id()`).

    Hay que tener en cuenta que en algunas plataformas, esto solo funcionará correctamente si el id se refiere a un marco Tk o a un nivel superior que tenga habilitada la opción -container.

  `Tk` lee e interpreta los archivos de perfil, nombrados `.className.tcl` y `. baseName.tcl`, en el intérprete Tcl y llama a `exec()` sobre el contenido de `.className.py` y `.baseName.py`. La ruta de los archivos de perfil se encuentra en la variable de entorno `HOME` o, si no está definida, en `os.curdir`.

  tk

    El objeto de la aplicación Tk creado al instanciar `Tk`. Esto proporciona acceso al intérprete de Tcl. Todos los widget que se adjuntan a la misma instancia de `Tk` tienen el mismo valor para el atributo `tk`.

  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 (or container)/content reflects the container structure.

  children

    Los descendientes directos de este widget como `dict` con los nombres del widget secundario como clave y los objetos de instancia secundarios como valor.

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

Otros módulos que proporcionan soporte a Tk incluyen:

`tkinter`

  Módulos de Tkinter.

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

Módulos adicionales:

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

`turtle`

  Gráficos de tortuga en una ventana Tk.

## Guía de supervivencia de Tkinter

Esta sección no fue pensada en ser un tutorial exhaustivo sobre cada tópico de Tk o Tkinter. Para esto, puede consultar en alguno de los recursos externos que fueron presentados anteriormente. En vez de eso, esta apartado entrega una orientación breve sobre como es ve una aplicación en Tkinter, identifica conceptos claves de Tk y explica como el empaquetador de Tkinter está estructurado.

Es resto de esta sección lo ayudará a identificar las clases, métodos y opciones que necesitará en una aplicación de Tkinter y donde se puede encontrar documentación más detallada sobre esto, incluida en la guía de referencia oficial de Tcl/Tk.

### Un programa simple de Hola Mundo

Comenzaremos a explorar Tkinter a través de una simple aplicación «Hola Mundo». Esta no es la aplicación mas pequeña que podríamos escribir, pero es suficiente para ilustrar algunos conceptos claves que necesitará saber.

    from tkinter import *
    from tkinter import ttk
    root = Tk()
    frm = ttk.Frame(root, padding=10)
    frm.grid()
    ttk.Label(frm, text="Hello World!").grid(column=0, row=0)
    ttk.Button(frm, text="Quit", command=root.destroy).grid(column=1, row=0)
    root.mainloop()

Después de las declaraciones de import, la línea siguiente será la de crear la instancia de la clase `Tk` la cual iniciativa Tk y crea el interprete asociado a Tcl. Esto también crea una ventana de nivel superior, conocida como la ventana raíz la cual sirve como la ventana principal de la aplicación.

En la siguiente línea se crea el marco del widget, el cual en este caso contendrá la etiqueta y el botón que crearemos después. El marco encaja dentro de la ventana raíz.

La próxima línea crea una etiqueta para el widget que contiene una cadena de texto estática. El método `grid()` es usado para especificar la posición del diseño de la etiqueta que está dentro del marco del widget, similar a como trabajan las tablas en HTML.

Es entonces cuando el botón del widget es creado y dejado a la derecha de la etiqueta. Una vez pulsado llamará al método `destroy()` de la ventana raíz.

Finalmente el método `mainloop()` muestra todo en pantalla y responde a la entrada del usuario hasta que el programa termina.

### Conceptos importantes de Tk

Incluso con este sencillo programa se pueden mostrar conceptos claves de Tk:

widgets

  Una interfaz de usuario de Tkinter está compuesta de varios widgets individuales. Cada widget es representado como un objeto de Python, instanciado desde clases tales como `ttk.Frame`, `ttk.Label` y `ttk.Button`.

jerarquía de los widgets

  Los widgets se organizan en jerarquías. La etiqueta y el botón estaban dentro del marco el que a su vez estaba contenido dentro del marco raíz. Cuando se crea cada child del widget su parent es pasado como el primer argumento del constructor del widget.

opciones de configuración

  Los widgets tienen opciones de configuración los cuales modifican su apariencia y comportamiento, como el texto que se despliega en la etiqueta o el botón. Diferentes clases de widgets tendrán diferentes conjuntos de opciones.

gestión del diseño de formularios

  Los widgets no son añadidos automáticamente a la interfaz de usuario una vez que han sido creados. Un administrador de geometrías como `grid` controla donde la interfaz de usuario es colocada.

ejecución del evento

  Tkinter reacciona a la entrada del usuario, realiza los cambios del programa e incluso actualiza lo que se muestra en pantalla solo cuando se ejecuta activamente un event loop. Si el programa no esta ejecutando el evento, su interfaz de usuario no se actualizará.

### Entendiendo como funcionan los empaquetadores de Tcl/Tk

Cuando su aplicación utiliza las clases y métodos de Tkinter, internamente Tkinter está ensamblando cadenas que representan comandos Tcl/Tk, y ejecutando esos comandos en el intérprete Tcl adjunto a la instancia `Tk` de su aplicación.

Tanto si se está intentando navegar en la documentación de referencia o intentando encontrar el método u opción correcta o adaptando algún código ya existente o depurando su aplicación en Tkinter, hay veces que es útil entender como son esos comandos subyacentes de Tcl/Tk.

Para ilustrar, aquí se tiene un equivalente en Tcl/Tk de la parte principal del script Tkinter anterior.

    ttk::frame .frm -padding 10
    grid .frm
    grid [ttk::label .frm.lbl -text "Hello World!"] -column 0 -row 0
    grid [ttk::button .frm.btn -text "Quit" -command "destroy ."] -column 1 -row 0

La sintaxis es similar a varios lenguajes de línea de comandos, donde la primera palabra es el comando que debe ser ejecutado con los argumentos que le siguen al comando, separados por espacios, Sin entrar en demasiados detalles, note lo siguiente:

- Los comandos usados para crear widgets (tales como `ttk::frame`) corresponden a las clases de widgets en Tkinter.

- Opciones de widget en Tcl (por ejemplo `-text`) corresponden a argumentos clave en Tkinter.

- Los widgets son reverenciados con un pathname in Tcl (por ejemplo `.frm.btn`) mientras que Tkinter no usa nombres sino que referencia a objetos.

- El lugar del widget en la jerarquía es codificada (jerárquicamente) en nombre de archivo, usando un `.` (punto) como separador de búsqueda. El nombre de ruta del archivo para la ventana raíz es un `.` (punto), la jerarquía no es definida por la ruta del archivo pero si por la especificación del widget padre cuando se crea cada widget hijo.

- Operations which are implemented as separate commands in Tcl (like `grid` or `destroy`) are represented as methods on Tkinter widget objects. As you’ll see shortly, at other times Tcl uses what appear to be method calls on widget objects, which more closely mirror what is used in Tkinter.

### ¿Cómo lo hago?, ¿Cómo funciona?

Si no esta seguro sobre como realizar ciertas acciones en Tkinter y no se puede encontrar información de forma rápida en el tutorial o en la documentación de referencias que estas usando, aquí hay varias estrategias que pueden ser de mucha ayuda.

Primero, recordar que los detalles sobre como cada widget trabaja en las diferentes versiones de Tcl/Tk pueden variar según la versión. Si está buscando información, asegúrese de que corresponde a la versión tanto de Python como de Tcl/Tk instaladas en su sistema.

Cuando se busca sobre como usar una API, puede ser muy útil el saber exactamente el nombre de la clase, opción o método que está utilizando. Tener esto en cuenta de antemano, ya sea en un shell de Python interactivo o con `print()`, puede ayudar a identificar lo que necesitas.

Para encontrar que opciones de configuración están disponibles en cada widget, se utiliza la llamada al método `configure()`, el cual retorna un diccionario que contiene una gran variedad de información sobre cada objeto, incluyendo valores por defecto y actuales. Utilice el `keys()` para saber los nombres de cada opción.

    btn = ttk.Button(frm, ...)
    print(btn.configure().keys())

La mayoría de los widgets tienen varias opciones de configuraciones en común, puede ser útil averiguar cuales son específicos de una clase de widget en particular. Comparando la lista de opciones de un widget sencillo como por ejemplo un frame es una de las formas de hacerlo.

    print(set(btn.configure().keys()) - set(frm.configure().keys()))

De manera similar se pueden encontrar los métodos disponibles para un objeto de un widget utilizando la función standard `dir()`. Si lo intentas podrás ver alrededor de 200 métodos comunes para los widgets por lo que de nuevo, es muy importante identificar las especificaciones de un widget.

    print(dir(btn))
    print(set(dir(btn)) - set(dir(frm)))

### Navegando en el manual de referencia de Tcl/Tk

Como se ha señalado, el manual oficial de referencia de Tk commands (en las páginas del manual) es a menudo la descripción mas precisa sobre que hacen las operaciones especificas de los widgets. Incluso sabiendo el nombre de la opción o método que necesitas, es posible que puedas encontrar información adicional.

Mientras todas las operaciones en Tkinter son implementadas como llamadas de método sobre objetos del widget, se puede ver cuantas operaciones de Tcl/Tk aparecen como comandos que toman el nombre de ruta del widget como el primer parámetro, seguido de parámetros opcionales, por ejemplo.

    destroy .
    grid .frm.btn -column 0 -row 0

Otros, sin embargo, se parecen más a métodos llamados en un objeto del widget (de hecho, cuando se crea un widget en Tcl / Tk, este a su vez crea un comando Tcl con el nombre de la ruta del widget, siendo el primer parámetro de ese comando el nombre de un método para llamar).

    .frm.btn invoke
    .frm.lbl configure -text "Goodbye"

En la documentación oficial de referencia para Tcl/Tk, se podrán encontrar mas operaciones que son similares a las llamadas a métodos de la pagina principal de un widget en especifico ( p.ej., se podrá encontrar el método `invoke()` en la página principal de ttk::button ) mientras que las funciones que toman un widget como un parámetro a menudo tienen su propia página principal (p.ej., grid).

Se podrán encontrar varias opciones en común y metidos en las páginas del manual options o ttk::widget, mientras que otras opciones se encuentran en las páginas del manual de una clase de widget específica.

También se puede encontrar cuantos métodos de Tkinter poseen nombres compuestos, p.ej, `winfo_x()`, `winfo_height()`, `winfo_viewable()`. Usted también encuentra información para todo esto en las páginas del manual en winfo <https://www.tcl.tk/man/tcl8.6/TkCmd/winfo.htm>`_.

Nota

Puede ser algo confuso, pero también hay métodos en todos los widgets de Tkinter los cuales no operan directamente en el widget pero operan a nivel global, independiente del widget. Ejemplos de esto son los métodos para acceder al portapapeles o a llamados del sistema. (Ellos aparecen al ser implementados como métodos en la clase base `Widget` clase que todos los widgets en Tkinter heredan).

## Modelo de subprocesamiento

Python and Tcl/Tk have very different threading models, which `tkinter` tries to bridge. If you use threads, you may need to be aware of this.

Un interprete de Python puede tener varios hilos asociados. En Tcl, diferentes hilos pueden ser creados, pero cada hilo tiene una instancia del interprete de Tcl asociada por separado. Los hilos también pueden crear mas de una instancia del interprete, aunque cada instancia del intérprete puede ser usada solo por el hilo que ha sido creado.

Each `Tk` object created by `tkinter` contains a Tcl interpreter. It also keeps track of which thread created that interpreter. Calls to `tkinter` can be made from any Python thread. Internally, if a call comes from a thread other than the one that created the `Tk` object, an event is posted to the interpreter’s event queue, and when executed, the result is returned to the calling Python thread.

Las aplicaciones de Tcl/Tk son normalmente basados en eventos, lo que significa que después de la inicialización, el interprete corre un bucle de eventos (p.ej. `Tk.mainloop()`) que responde a los eventos. Al ser un evento de un solo proceso, los controladores responden rápidamente, en caso contrario ellos bloquearán el procesamiento de otros eventos. Para evitar esto, cualquier procesamiento de larga duración no deben ser procesados en el controlador de eventos, o en caso contrario ser separados en pequeñas piezas usando temporizadores o correr el proceso en otro hilo. Esto es diferente a muchos kits de herramientas de GUI donde GUI se ejecuta en un hilo completamente separado del código de la aplicación, incluido el controlador de eventos.

If the Tcl interpreter is not running the event loop and processing events, any `tkinter` calls made from threads other than the one running the Tcl interpreter will fail.

Existen varios casos especiales:

- Tcl/Tk libraries can be built so they are not thread-aware. In this case, `tkinter` calls the library from the originating Python thread, even if this is different than the thread that created the Tcl interpreter. A global lock ensures only one call occurs at a time.

- While `tkinter` allows you to create more than one instance of a `Tk` object (with its own interpreter), all interpreters that are part of the same thread share a common event queue, which gets ugly fast. In practice, don’t create more than one instance of `Tk` at a time. Otherwise, it’s best to create them in separate threads and ensure you’re running a thread-aware Tcl/Tk build.

- Bloquear los controladores de eventos no son la única manera de prevenir que el intérprete de Tcl reingrese al bucle de eventos. Es incluso posible ejecutar una cantidad de bucles de eventos anidados o abandonar el bucle de forma completa, Si está realizando alguna tarea complicada cuando se trata de eventos o hilos hay que tener en cuenta estas posibilidades.

- There are a few select `tkinter` functions that presently work only when called from the thread that created the Tcl interpreter.

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

The packer is one of Tk’s geometry-management mechanisms. Geometry managers are used to specify the relative positioning of widgets within their container. 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.

The size of any container widget is determined by the size of the «content widgets» inside. The packer is used to control where content widgets appear inside the container into which they are packed. You can pack widgets into frames, and frames into other frames, in order to achieve the kind of layout you desire. Additionally, the arrangement is dynamically adjusted to accommodate incremental changes to the configuration, once it is packed.

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

  Anchor type. Denotes where the packer is to place each content in its parcel.

expand

  Un valor booleano, `0` o `1`.

fill

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

ipadx y ipady

  A distance - designating internal padding on each side of the content.

padx y pady

  A distance - designating external padding on each side of the content.

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.

Unfortunately, in the current implementation of `tkinter` it is not possible to hand over an arbitrary Python variable to a widget through a `variable` or `textvariable` option. The only kinds of variables for which this works are variables that are subclassed from a class called Variable, defined in `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

In Tk, there is a utility command, `wm`, for interacting with the window manager. Options to the `wm` command allow you to control things like titles, placement, icon bitmaps, and the like. In `tkinter`, these commands have been implemented as methods on the `Wm` class. Toplevel widgets are subclassed from the `Wm` class, and so can call the `Wm` methods directly.

To get at the toplevel window that contains a given widget, you can often just refer to the widget’s `master`. Of course if the widget has been packed inside of a frame, the `master` won’t represent a toplevel window. To get at the toplevel window that contains an arbitrary widget, you can call the `_root()` method. This method begins with an underscore to denote the fact that this function is part of the implementation, and not an interface to Tk functionality.

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

  Los colores se pueden dar como nombres de colores de X en el archivo `rgb.txt`, o como cadenas que representan valores RGB. La cadena que representa el valor RGB toma un rango de 4 bits:`"#RGB"`, 8 bits: `"#RRGGBB"`, 12 bits» `"#RRRGGGBBB"`, o 16 bits `"#RRRRGGGGBBBB"` donde R, G, B representan cualquier dígito hexadecimal legal. Consulte la página 160 del libro de Ousterhout para más detalles.

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

  Legal values are the strings: `"left"`, `"center"`, and `"right"`.

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 de tipo índice. Esto 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.)

  Entry widgets have options that refer to character positions in the text being displayed. You can use these `tkinter` functions to access these special points in text widgets:

Í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).

Distinto en la versión 3.13: Added the `PhotoImage` method `copy_replace()` to copy a region from one image to other image, possibly with pixel zooming and/or subsampling. Add from_coords parameter to `PhotoImage` methods `copy()`, `zoom()` and `subsample()`. Add zoom and subsample parameters to `PhotoImage` method `copy()`.

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.