How to create an impressive GUI in Python using Tkinter?

Python is one of the most popular programming languages in the world, and for good reason. It is easy to learn, versatile, and powerful. One of the many things you can do with Python is to create graphical user interfaces (GUIs) using the Tkinter library. With Tkinter, you can create windows, buttons, menus, and many other user interface elements. In this article, we will go over the basics of creating an impressive GUI in Python using Tkinter.

What is Tkinter?

Tkinter is a Python library for creating GUIs. It is a cross-platform library, which means it works on different operating systems like Windows, macOS, and Linux. Tkinter is included in the standard Python distribution, so you don’t have to install anything extra to use it.

Tkinter is built on top of the Tk toolkit, which is a toolkit for creating GUIs in the Tcl programming language. Tkinter provides Python bindings for the Tk toolkit, so you can create GUIs in Python using Tk widgets.

How to create a basic GUI using Tkinter

Let’s start by creating a basic GUI with a window and a button using Tkinter:

import tkinter as tk

root = tk.Tk()
root.title("My GUI")

button = tk.Button(root, text="Click Me!")
button.pack()

root.mainloop()

Let’s go over the code line by line.

The first line imports the tk module, which is the Tkinter module. The second line creates a new instance of the Tk class, which represents the main window of the GUI. The title() method sets the title of the window to “My GUI”.

The next line creates a button widget using the Button() constructor. The widget is created inside the root window, and its text is set to “Click Me!”. Finally, the pack() method is called to display the widget inside the window.

The last line is a special call to the mainloop() method of the root window. This method enters the Tkinter event loop, which is an infinite loop that waits for events to happen, like button clicks or window resizes. The event loop is what makes the GUI interactive and responsive.

GUI geometry management

The pack() method we used earlier is one of the Tkinter geometry managers. A geometry manager is a means of laying out widgets in a container widget, usually a window, frame or other layout widget. There are three geometry managers in Tkinter:

• Pack geometry manager
• Grid geometry manager
• Place geometry manager

The pack() geometry manager we used earlier is the easiest one to use. It places the widgets in a horizontal or vertical stack. It also has options to control the spacing between widgets.

The grid() geometry manager places the widgets in a grid pattern, like a spreadsheet. You can specify the number of rows and columns, as well as the size and position of each widget.

The place() geometry manager lets you specify the exact position and size of each widget using absolute coordinates. This is the most flexible, but also the most complex geometry manager.

Let’s see an example of using the grid() geometry manager:

import tkinter as tk

root = tk.Tk()
root.title("My Grid")

button1 = tk.Button(root, text="Button 1")
button1.grid(row=0, column=0)

button2 = tk.Button(root, text="Button 2")
button2.grid(row=0, column=1)

button3 = tk.Button(root, text="Button 3")
button3.grid(row=1, column=0, columnspan=2)

root.mainloop()

In this example, we create three buttons and place them in a 2×2 grid. The first button is in the first row and first column, the second button is in the first row and second column, and the third button spans across both columns in the second row.

Widgets in Tkinter

Tkinter provides a wide variety of widgets that you can use to create your GUI. Here are some of the most commonly used widgets:

• Label: A simple text label.
• Button: A button that the user can click to perform an action.
• Entry: A single-line text input field.
• Text: A multi-line text input field.
• Frame: A container widget that can hold other widgets.
• Checkbutton: A checkbox that the user can check or uncheck.
• Radiobutton: A set of options where the user can select one option.
• Listbox: A list of items that the user can select one or more from.
• Menu: A pull-down or pop-up menu.
• Scrollbar: A scrollbar that can be used to scroll through a widget, like a Text or Listbox widget.

Let’s see an example of using some of these widgets together:

import tkinter as tk

root = tk.Tk()
root.title("My Widgets")

# Label widget
label = tk.Label(root, text="Hello, World!")
label.pack()

# Entry widget
entry = tk.Entry(root)
entry.pack()

# Text widget
text = tk.Text(root)
text.pack()

# Frame widget
frame = tk.Frame(root)
frame.pack()

# Checkbutton widget
checkbutton = tk.Checkbutton(frame, text="Check me!")
checkbutton.pack()

# Radiobutton widgets
var = tk.StringVar()
radiobutton1 = tk.Radiobutton(frame, text="Option 1", variable=var, value="1")
radiobutton2 = tk.Radiobutton(frame, text="Option 2", variable=var, value="2")
radiobutton1.pack()
radiobutton2.pack()

# Listbox widget
listbox = tk.Listbox(frame)
listbox.insert(1, "Item 1")
listbox.insert(2, "Item 2")
listbox.insert(3, "Item 3")
listbox.pack()

# Menu widget
menu = tk.Menu(root)
root.config(menu=menu)

file_menu = tk.Menu(menu)
menu.add_cascade(label="File", menu=file_menu)

file_menu.add_command(label="New")
file_menu.add_command(label="Open")
file_menu.add_separator()
file_menu.add_command(label="Exit", command=root.quit)

# Scrollbar widget
scrollbar = tk.Scrollbar(text)
scrollbar.pack(side="right", fill="y")

text.config(yscrollcommand=scrollbar.set)
scrollbar.config(command=text.yview)

root.mainloop()

In this example, we create various widgets like Label, Entry, Text, Frame, Checkbutton, Radiobutton, Listbox, Menu, and Scrollbar, and pack them using the pack() method. We also create a Menu widget and add it to the root window using the config() method.

The Scrollbar widget is used to create a scrollbar for the Text widget, which allows the user to scroll through the text if it doesn’t fit in the window.

Styling widgets with Tkinter

Tkinter provides a way to style widgets using widget options. Widget options allow you to change the appearance and behavior of a widget. For example, you can change the font, color, or size of a widget, and also bind events to it, like mouse clicks or keyboard presses.

Here’s an example of changing the font and background color of a Label widget:

import tkinter as tk

root = tk.Tk()
root.title("My Label")

label = tk.Label(root, text="Hello, World!", fg="white", bg="blue", font=("Arial", 26))
label.pack()

root.mainloop()

In this example, we create a Label widget with a blue background color, white text color, and a large Arial font.

Events and event handling in Tkinter

Events are things that happen in the GUI, like a button click or a keypress. Tkinter provides a way to handle events using event binding.

Event binding is a way to associate a function with an event. When the event occurs, the associated function is called. The syntax for event binding is:

widget.bind(event, function)

The widget is the widget that we want to bind the event to, the event is the event we want to handle, and the function is the function that will be called when the event occurs.

Here’s an example of handling a button click event using the bind() method:

import tkinter as tk

root = tk.Tk()
root.title("My Button")

def button_click(event):
    print("Button clicked")

button = tk.Button(root, text="Click Me!")
button.pack()

button.bind("<Button-1>", button_click)

root.mainloop()

In this example, we create a button widget and bind the “” event to the button_click() function. When the button is clicked, the function is called and prints out “Button clicked” to the console.

Conclusion

In this article, we explored the basics of creating an impressive GUI in Python using Tkinter. We learned about Tkinter, GUI geometry management, widgets in Tkinter, styling widgets, and events and event handling in Tkinter.

Tkinter is a powerful library that allows you to create sophisticated GUIs with relatively little code. With the knowledge you’ve gained from this article, you should be well on your way to creating your own impressive Python GUIs using Tkinter.