Programming with Python | Chapter 24: Introduction to GUI Programming with Tkinter

Event Handling (Button Commands)

Buttons trigger actions using the command option, which is set to the name of a function (without parentheses).

import tkinter as tk

def on_button_click():
    print("Button was clicked!")

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

# Pass the function NAME to the command option
button = tk.Button(root, text="Click Me", command=on_button_click)
button.pack(pady=20) # Add padding

root.mainloop()

graph TD
    Ev1(User Clicks Button) --> Ev2{"Tkinter Event Loop Detects Click"};
    Ev2 --> Ev3{"Identify Button & Associated <i>command</i>"};
    Ev3 -- "Found <i>command=my_function</i>" --> Ev4("Call <i>my_function()</i>");
    Ev4 --> Ev5["Function Executes (e.g., <i>entry.get()</i>, <i>label.config()</i>)"];
    Ev5 --> Ev6(GUI Potentially Updates);
    Ev6 --> Ev7(Return Control to Event Loop);
    Ev7 --> Ev2; 

    style Ev1 fill:#fec,stroke:#b45309,stroke-width:1px
    style Ev4 fill:#ccf,stroke:#333,stroke-width:1px
    style Ev5 fill:#cfc,stroke:#333,stroke-width:1px

Getting Input from Entry Widgets

The Entry widget has a .get() method to retrieve the text currently inside it.

# Inside a function triggered by a button, for example:
user_input = entry_widget.get()
print(f"User entered: {user_input}")

Alternative: Command-Line Interfaces with argparse

While Tkinter builds graphical interfaces, sometimes a command-line interface (CLI) is more appropriate, especially for developer tools or automation scripts. Python’s argparse module (part of the standard library) makes it easy to parse arguments provided on the command line.

# simple_cli.py
import argparse

parser = argparse.ArgumentParser(description="A simple example CLI tool.")
parser.add_argument("input_file", help="Path to the input file.")
parser.add_argument("-o", "--output", help="Path to the output file (optional).")
parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output.")

args = parser.parse_args() # Parses arguments like: python simple_cli.py data.txt -o results.txt -v

print(f"Input file: {args.input_file}")
if args.output:
    print(f"Output file: {args.output}")
if args.verbose:
    print("Verbose mode enabled.")

# ... rest of script logic using args ...

argparse automatically handles generating help messages (-h or --help). It’s a powerful tool for creating scripts that accept configurable options and inputs directly from the terminal.

Code Examples

Example 1: Simple “Hello World” GUI

# hello_gui.py
import tkinter as tk

# 1. Create the root window
root = tk.Tk()
root.title("Hello Tkinter") # Set window title
root.geometry("300x100") # Set window size (width x height)

# 2. Create a widget
hello_label = tk.Label(root, text="Hello, GUI World!")

# 3. Place the widget
hello_label.pack(pady=20) # Pack with vertical padding

# 4. Start the event loop
root.mainloop()

Explanation:

• Imports tkinter as tk.
• Creates the main window (root).
• Sets the window title and initial size.  
• Creates a Label widget associated with root, containing the text.
• Uses .pack() to place the label in the window, adding some padding (pady).
• root.mainloop() starts the application, making the window visible and interactive.

Example 2: Simple Name Greeter

# name_greeter_gui.py
import tkinter as tk
from tkinter import messagebox # For showing pop-up messages

def greet_user():
    """Gets name from entry and displays a greeting."""
    name = name_entry.get()
    if name:
        greeting_message = f"Hello, {name}!"
        # Display in a label or a pop-up
        result_label.config(text=greeting_message)
        # Or show a pop-up:
        # messagebox.showinfo("Greeting", greeting_message)
    else:
        result_label.config(text="Please enter a name.")
        # messagebox.showwarning("Input Error", "Please enter a name.")

# --- GUI Setup ---
root = tk.Tk()
root.title("Greeter")
root.geometry("350x150")

# Input Frame
input_frame = tk.Frame(root)
input_frame.pack(pady=10)

# Name Label and Entry
name_label = tk.Label(input_frame, text="Enter your name:")
name_label.pack(side=tk.LEFT, padx=5)

name_entry = tk.Entry(input_frame, width=20) # Entry widget
name_entry.pack(side=tk.LEFT)

# Button Frame
button_frame = tk.Frame(root)
button_frame.pack(pady=5)

# Greet Button
greet_button = tk.Button(button_frame, text="Greet Me!", command=greet_user)
greet_button.pack()

# Result Label Frame
result_frame = tk.Frame(root)
result_frame.pack(pady=10)

# Label to display the result
result_label = tk.Label(result_frame, text="")
result_label.pack()

root.mainloop()

Explanation:

• Includes a function greet_user that will be called by the button.
• greet_user uses name_entry.get() to retrieve the text from the Entry widget.  
• It updates the text of the result_label using result_label.config(text=...).
• Alternatively, tkinter.messagebox could be used for pop-ups.
• Widgets are organized using Frame containers and placed using pack (with side=tk.LEFT used within input_frame for horizontal arrangement).

Common Mistakes or Pitfalls

• Forgetting root.mainloop(): The GUI window won’t appear or won’t be interactive without this line.
• Calling Command Function Directly: Assigning command=my_function() (with parentheses) instead of command=my_function to a button. This calls the function immediately when the button is created, not when it’s clicked.
• Mixing Geometry Managers: Using both .pack() and .grid() on widgets that share the same parent container (root window or a Frame) can cause the layout to freeze or behave unpredictably.
• Blocking the Event Loop: Performing very long-running tasks directly within an event handler function (like greet_user) will freeze the GUI. For long tasks, techniques like threading or asynchronous programming (more advanced topics) are needed.
• Widget Variable Scope: Ensuring that variables holding widget references (like name_entry, result_label) are accessible within the functions that need to interact with them (e.g., defined globally or passed appropriately).

Chapter Summary

• GUIs provide visual interaction using windows and widgets.  
• Tkinter is Python’s standard GUI library, part of the standard distribution.  
• A basic Tkinter app involves: importing tkinter, creating the Tk() root window, adding widgets (Label, Button, Entry, etc.), placing widgets (pack, grid), and starting the event loop (mainloop()).
• The command option in Button links clicks to functions.
• Entry widgets have a .get() method to retrieve input text.
• argparse is a standard library alternative for building command-line interfaces.

Exercises & Mini Projects

Exercises

1. Window Title and Size: Create a simple Tkinter window, set its title to “My First GUI”, and give it a fixed size of 400×200 pixels. Add a label inside saying “Window Basics”.
2. Button Counter: Create a window with a label showing “Count: 0” and a button labeled “Increment”. Clicking the button should increase the count displayed on the label by 1. (Hint: You’ll need a variable to store the count, accessible by the button’s command function).
3. Simple Calculator UI: Design a basic UI for a calculator using Tkinter. Include:
   • An Entry widget at the top to display numbers/results.
   • Buttons for digits (0-9).
   • Buttons for basic operations (+, -, *, /).
   • A “Clear” button and an “Equals” button.
   • (You don’t need to implement the calculator logic yet, just create and arrange the widgets using grid).
4. Pack vs. Grid: Create a window with three labels (“Red”, “Green”, “Blue”). Try arranging them vertically using pack(). Then, clear the window (or create a new one) and arrange them horizontally using grid().

Mini Project: Simple Text Editor

Goal: Create a very basic text editor GUI using Tkinter.

Steps:

1. Import: Import tkinter as tk and potentially tkinter.scrolledtext and tkinter.filedialog.
2. Setup: Create the root window (tk.Tk()) and set its title.
3. Text Area: Create a Text widget (or scrolledtext.ScrolledText for built-in scrollbars) to occupy most of the window. Use pack(expand=True, fill='both') to make it resize with the window. Python# Example using scrolledtext (often better) # from tkinter import scrolledtext # txt_edit = scrolledtext.ScrolledText(root, wrap=tk.WORD) # txt_edit.pack(padx=5, pady=5, expand=True, fill='both') # Example using basic Text with separate Scrollbar (more manual) # text_frame = tk.Frame(root) # text_frame.pack(padx=5, pady=5, expand=True, fill='both') # txt_scrollbar = tk.Scrollbar(text_frame) # txt_scrollbar.pack(side=tk.RIGHT, fill=tk.Y) # txt_edit = tk.Text(text_frame, wrap=tk.WORD, yscrollcommand=txt_scrollbar.set) # txt_edit.pack(expand=True, fill='both') # txt_scrollbar.config(command=txt_edit.yview)
4. Menu Bar: Create a menu bar (tk.Menu).
   • Add a “File” menu to the menu bar.
   • Add “Open”, “Save As…”, and “Exit” commands to the “File” menu. Associate them with placeholder functions for now (or implement them using filedialog).
5. (Optional) File Operations:
   • Implement an open_file function: Use filedialog.askopenfilename() to get a filename. If a file is selected, open it, read its content, clear the Text widget (txt_edit.delete('1.0', tk.END)), and insert the file content (txt_edit.insert(tk.END, file_content)).
   • Implement a save_file_as function: Use filedialog.asksaveasfilename() to get a filename. If a filename is provided, get the content from the Text widget (txt_edit.get('1.0', tk.END)) and write it to the selected file.
   • Implement an exit_app function: Use root.quit() or root.destroy().
6. Run: Start the main event loop (root.mainloop()).

Additional Sources:

• codypiersall/cligui: Turn an argparse command line program into a tkinter GUI. – GitHub