Tkinter Event Binding

Summary: in this tutorial, you’ll learn about the Tkinter event binding mechanism.

Introduction to the Tkinter event binding

Assigning a function to an event of a widget is known as event binding. The assigned function is invoked automatically when the event occurs.

In the previous tutorial, you learned how to bind a function to an event of a widget via the command option. However, it’s important to note that not all Tkinter widgets support the command option.

Therefore, Tkinter provides you with an alternative way for event binding via the bind() method.

The following shows the general syntax of the bind() method:

widget.bind(event, handler, add=None)

When an event occurs in the widget, Tkinter will automatically invoke the handler with the event details.

If you want to register an additional handler, you can pass the '+' to the add argument. This allows you to have multiple event handlers responding to the same event.

Tkinter event binding examples

The following program illustrates how to bind the return_pressed function to the Return key pressed event of the 'Save' button:

import tkinter as tk
from tkinter import ttk


def return_pressed(event):
    print('Return key pressed.')


root = tk.Tk()

btn = ttk.Button(root, text='Save')
btn.bind('<Return>', return_pressed)


btn.focus()
btn.pack(expand=True)

root.mainloop()Code language: Python (python)

In this example, the following statement calls the bind() method on the button widget to bind the Return key pressed event:

btn.bind('<Return>', return_pressed)Code language: HTML, XML (xml)

The following example illustrates how to use the bind() method to register multiple handlers for the same event:

import tkinter as tk
from tkinter import ttk


def return_pressed(event):
    print('Return key pressed.')


def log(event):
    print(event)


root = tk.Tk()

btn = ttk.Button(root, text='Save')
btn.bind('<Return>', return_pressed)
btn.bind('<Return>', log, add='+')


btn.focus()
btn.pack(expand=True)

root.mainloop()Code language: Python (python)

When you move the focus to the button and press the Return key, Tkinter automatically invokes the return_pressed and log functions.

The following binds the log() function to the Return key pressed event of the 'Save' button:

btn.bind('<Return>', log, add='+')Code language: Python (python)

In this statement, the third argument add='+' registered additional handler, which is the log() function.

If you don’t specify the add='+' argument, the bind() method will replace the existing handler (return_pressed) by the new one (log).

Event patterns

Tkinter uses event patterns to map event names with handlers. For example, the <Return> denotes the Return key pressed.

The following shows the general syntax of an event pattern:

<modifier-type-detail>Code language: HTML, XML (xml)

In this syntax, an event is surrounded by angle brackets (<>). Inside the angle brackets, there are zero or more modifiers, an event type, and detailed information about the event.

For example, the <KeyPress-A> denotes a keyboard press of the key A . and <Alt-Control-KeyPress-KP_Delete> represents a keypress of Alt + Ctrl + Delete.

The following section shows the most commonly used event modifiers, event types, and event details.

1) Event modifiers

The following table lists the most commonly used event modifiers:

Event types

The following table shows the most commonly used event types:

Event Detail

The following table shows several ways to name keys:

Binding events to root window

So far, you have learned how to bind an event to a particular widget. Tkinter also allows you to bind an event to the top-level window.

In this case, the syntax for the bind() is the same except that you can call it on the root window like this:

root.bind('<Return>', handler)Code language: HTML, XML (xml)

The levels of binding

In the previous example, you have learned how to bind an event to a particular instance of a widget. This is called an instance-level binding.

Tkinter also allows you to bind an event to all the instances of a widget. For example, you can bind the event to all the textboxes in a program:

root.bind_class('Entry', '<Control-V>', paste)Code language: JavaScript (javascript)

By the way, you use the Entry widget to create a textbox in Tkinter.

This is called class-level binding because you bind the event to a class instead of an instance.

Unbinding events

Sometimes, you may want to undo the effect of an earlier binding. To do it, you can use the unbind() method:

widget.unbind(event)Code language: CSS (css)

The following example unbinds the event from the btn button:

btn.unbind('<Return>')Code language: HTML, XML (xml)

Summary

• Use the bind() method to bind an event to a widget.
• Tkinter supports both instance-level and class-level bindings.