Blog

Hey there! In this tutorial, I’m going to help you understand how Tkinter event binding works.

It’s a cool feature in Tkinter that allows you to connect functions to specific events.

Basically, when something happens in your app—like a button press or a key press—Tkinter can trigger a function you’ve written.

This is called event binding.

Tkinter event binding

Tkinter event binding Tkinter event binding

What Is Event Binding in Tkinter?

Event binding is when you link a function to a widget’s event.

When that event happens, the function gets called automatically.

Simple, right?

If you’ve used the command option before to bind a function to a widget, that’s great.

But here’s the catch—not all widgets in Tkinter support the command option.

That’s where the bind() method comes in.

It’s a more powerful way to handle events.

Syntax of the bind() Method

Here’s how the bind() method works:

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

When the event happens, Tkinter triggers the handler function you’ve assigned.

You can even have multiple handlers for the same event by using the add='+' argument.

How to Bind Events in Tkinter: Examples

Basic Example

Tkinter event binding Tkinter event binding

Let’s start with a simple example.

Here, we’ll bind the Return key (Enter key) to a function:

import tkinter as tk
from tkinter import ttk

# the methods that you bind automatically get a parameter event
# you need to receive it here with any name for variable.
# this variable will hold all the details about event.
def return_pressed(event):
    print('Return key pressed.')

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

btn.focus() # needed as initially the button won't be in focus
btn.pack(expand=True)

root.mainloop()

In this example, the bind() method links the Return key to the return_pressed function.

When you press Enter, the message gets printed.

Easy-peasy!

Adding Multiple Handlers

You can even attach more than one handler to the same event.

Here’s how:

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

Output:

Return key pressed.
<KeyPress event send_event=True keysym=Return keycode=13 char='\r' x=98 y=244>

By adding add='+', both functions will run when you press the Enter key.

Tkinter event binding Tkinter event binding

Understanding Tkinter Event Patterns

Tkinter uses something called event patterns to connect events with their handlers.

They look like this:

<modifier-type-detail>

Some common event patterns include:

• <Return> – Enter key
• <KeyPress-A> – Pressing the ‘A’ key
• <Button-1> – Left mouse button click

Modifiers in Event Patterns

Modifiers let you do cool things like combining keys. Here are some common ones:

For example, <Control-Shift-A> would detect if you pressed Ctrl + Shift + A together.

Most Common Event Types in Tkinter

Here’s a handy table of some of the most common event types you’ll use:

Binding Events to the Root Window

Did you know you can bind events directly to the root window?

It works the same way:

root.bind('<Return>', handler)

Instance-Level vs. Class-Level Binding

There are two ways to bind events in Tkinter:

1. Instance-Level Binding: Binds an event to a specific widget instance.
2. Class-Level Binding: Binds an event to all instances of a widget class.

Class-Level Binding Example

root.bind_class('Entry', '<Control-V>', paste)

Here, you’re binding the event to all Entry widgets.

Unbinding Events in Tkinter

Want to remove an event binding?

Just use the unbind() method like this:

widget.unbind(event)
# For example:
btn.unbind('<Return>')

Quick Summary

• Use the bind() method to connect events to widgets.
• You can bind events to individual widgets or all instances of a widget class.
• You can unbind events when you no longer need them.
• Tkinter supports lots of events like key presses, mouse clicks, and even mouse wheel scrolling.