Previous | Tutorial index | Next

Tutorial 3: Tkinter Basics – Creating Your First GUI Window

Learning Objectives

• Discuss the widgets, functions, other classes, and methods provided in the Tkinter module (Introductory).
• Understand the lifecycle of a Tkinter application (creation, configuration, display, event loop, destruction).
• Create, configure, and display a main application window.
• Add simple widgets and control their placement.

1. Introduction – Your First Step into GUI Programming

Writing your first GUI program is a milestone. Unlike a terminal program that simply prints text and exits, a GUI program creates a living window that stays on your screen, responds to your mouse, and updates itself dynamically.

In this tutorial, we will dissect the minimal Tkinter application line by line. By the end, you will understand not just how to create a window, but what each line does behind the scenes, and how to customise the window for your own applications.

2. Importing Tkinter – The Right Way

2.1 Standard Import

import tkinter as tk

• This imports the entire Tkinter module and gives it the shorter alias tk.
• Why as tk? Tkinter has many classes (Tk, Label, Button, etc.). Using the alias prevents polluting your global namespace and makes it clear which objects come from Tkinter.
• Alternative (not recommended for beginners): from tkinter import * – this dumps all names into your namespace, which can cause accidental overwrites and makes code less readable.

2.2 What Is Actually Imported?

The tkinter module contains dozens of classes, constants, and utility functions. The most important ones we will use early on are:

• tk.Tk – the root window class.
• tk.Label – a text/image display widget.
• tk.Button – a clickable button.
• tk.Frame – a container for other widgets.
• tk.Toplevel – a secondary window.
• Geometry managers: pack(), grid(), place().

3. The Tk Class – Your Application's Root

3.1 Creating the Root Window

root = tk.Tk()

• tk.Tk() creates an instance of the root window. This is the main window of your application.
• There should typically be only one Tk instance in a program. If you need additional windows, use tk.Toplevel instead.
• The Tk object is a singleton in practice – creating a second one will create a second independent main loop, which is rarely needed and can cause issues.

3.2 The Root Window's Hidden Role

The root object is not just a window – it is also the application controller. It holds:

• The event loop (mainloop).
• The clipboard.
• The system tray (on some platforms).
• Default fonts, colours, and styles for all child widgets.
• The geometry manager registry.

4. Configuring the Window – Title, Size, and More

4.1 Setting the Title

root.title("My First Application")

• This sets the text displayed in the window's title bar (top border).
• On macOS, the title may appear in the application menu bar as well.

4.2 Setting the Geometry (Size and Position)

root.geometry("400x300")          # width x height in pixels
root.geometry("400x300+100+50")   # width x height + x_offset + y_offset

• The geometry string follows the pattern "{width}x{height}+{x}+{y}".
• width and height are in pixels (screen pixels).
• x and y are the screen coordinates of the top‑left corner of the window (relative to your display's top‑left corner). If you omit them, the window manager chooses a default position.
• Note: Some window managers on Linux may ignore the position part; it is a hint, not a strict command.

4.3 Other Useful Window Methods

4.4 Example: A Configured Window

import tkinter as tk

root = tk.Tk()
root.title("Advanced Config")
root.geometry("500x300+200+100")
root.resizable(False, False)   # User cannot resize
root.minsize(400, 250)         # Minimum size (if resizable is True)
root.maxsize(800, 600)

root.mainloop()

5. Adding a Simple Widget – The Label

5.1 Creating the Label

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

• tk.Label is a widget class that displays text or an image.
• First argument (root) – this is the parent container. Every widget must be placed inside a parent (usually the root window or a frame). This creates a parent‑child hierarchy.
• text option – sets the string to be displayed.
• You can also set many other options at creation: font, fg (foreground colour), bg (background colour), relief, justify, etc.

5.2 The Important Distinction – Creation vs. Display

• Creating a widget does NOT make it visible. It only instantiates a Python object.
• To make a widget appear, you must call a geometry manager on it (e.g., pack(), grid(), or place()). Without this step, the widget exists in memory but is invisible.

5.3 Packing the Label – The Simplest Layout

label.pack()

• pack() is the simplest geometry manager. It tells Tkinter to "pack" the widget into its parent container, positioning it in a block (like stacking boxes). By default, it places widgets vertically from top to bottom, centred.
• Parameters you can pass to pack():
  • side=tk.LEFT / tk.RIGHT / tk.TOP / tk.BOTTOM – changes the packing direction.
  • padx=10, pady=10 – adds external padding around the widget.
  • ipadx=5, ipady=5 – adds internal padding inside the widget border.
  • fill=tk.X / tk.Y / tk.BOTH – makes the widget stretch to fill available space.
  • expand=True – allows the widget to expand into any extra space.

6. The Event Loop – mainloop()

6.1 What Does mainloop() Do?

root.mainloop()

• This is the heartbeat of any Tkinter application.
• When you call mainloop(), Tkinter enters an infinite loop that:
  1. Waits for events (mouse clicks, key presses, window resizing, redraw requests).
  2. Dispatches those events to the appropriate callback functions (if any are bound).
  3. Updates the screen (redraws widgets that have changed).
  4. Checks for system messages (e.g., "close window" request).

6.2 What Happens If You Forget mainloop()?

• The script will execute all your window‑creation and configuration lines instantly, then exit because it has no more lines to run.
• The window may flash briefly on the screen and then disappear immediately.
• Rule of thumb: Always ensure your script ends with root.mainloop() (or another mainloop() call).

6.3 Code After mainloop()

• Code placed after mainloop() will only run after the user closes the window.

• This is useful for cleanup tasks (e.g., saving settings, writing logs).

• Example:

  root.mainloop()
  print("Window closed. Goodbye!")  # This prints only when the window is closed.
  

7. Other Essential Methods – destroy() and quit()

7.1 destroy()

root.destroy()

• Destroys the window and all its child widgets, freeing up system resources.
• This is the clean way to close a window programmatically (e.g., from a "Quit" button).
• If you call destroy() on the root window, the mainloop() will exit automatically.

7.2 quit()

root.quit()

• Stops the mainloop() but does not destroy the window or its widgets.
• The window may remain frozen on the screen until you close it manually.
• Usually, you use destroy() to close the application properly. quit() is rarely used in simple applications.

7.3 The protocol Handler – Intercepting the Close Button

When a user clicks the "X" (close) button on the window title bar, Tkinter's default behaviour is to destroy the window and exit mainloop(). You can override this to ask for confirmation before closing:

def on_closing():
    if tk.messagebox.askokcancel("Quit", "Do you want to quit?"):
        root.destroy()

root.protocol("WM_DELETE_WINDOW", on_closing)

This is an excellent way to prevent accidental data loss.

8. Complete Walkthrough – From Zero to Window

Let's annotate the complete minimal example with every concept we have covered:

import tkinter as tk                    # 1. Import

root = tk.Tk()                          # 2. Create root window
root.title("First Window")              # 3. Set title
root.geometry("300x200")                # 4. Set size

label = tk.Label(root, text="Hello, Tkinter!")  # 5. Create label widget
label.pack()                            # 6. Display the label (pack it)

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

Execution flow:

• Lines 1–6 run immediately (in a few milliseconds).
• Line 7 (mainloop()) starts the loop – the program freezes here until the window is closed.
• During the loop, the window remains responsive.
• When the user clicks the "X", the loop exits, and the program terminates.

9. Check Your Understanding (Quizzes)

Quiz 1: Multiple Choice

1. What is the correct way to import Tkinter to avoid namespace pollution?
   • A) import tkinter
   • B) import tkinter as tk
   • C) from tkinter import *
   • D) include tkinter

1. Which method is used to set the title of the main window?
   • A) root.set_title("My App")
   • B) root.title("My App")
   • C) root.name("My App")
   • D) root.caption("My App")

1. Which method starts the event loop and keeps the window open?
   • A) root.run()
   • B) root.start()
   • C) root.mainloop()
   • D) root.loop()

1. What does the geometry("400x300") method do?
   • A) Sets the window's position on the screen.
   • B) Sets the window's width to 400 pixels and height to 300 pixels.
   • C) Sets the window's font size to 400 and background to 300.
   • D) Sets the number of widgets to 400 and 300.

1. If you create a widget (e.g., tk.Label()) but do not call any geometry manager on it (like pack()), what happens?
   • A) The label appears but is invisible.
   • B) The label does not appear at all.
   • C) The label appears with a default layout.
   • D) The program throws an error.

Quiz 2: True or False

1. True / False: You can create multiple Tk() instances in a single program to create multiple independent windows.

1. True / False: The mainloop() function only runs for a fixed number of seconds and then stops automatically.

1. True / False: The root.destroy() method closes the window but does not stop the event loop.

1. True / False: On macOS, the title() method sets the window title correctly.

1. True / False: If you resize the window using your mouse, the geometry() method automatically updates to reflect the new size.

Quiz 3: Fill in the Blanks

1. The root = tk.Tk() line creates the ______________ window of the application.

1. To prevent a window from being resized by the user, you can call root.resizable(_______, _______).

1. The method that checks for system messages and dispatches events is called ______________.

1. A widget must be placed inside a ______________ (usually the root or a frame) using a layout manager.

1. The string "300x200+50+50" passed to geometry() means width _____, height _____, and the window's top‑left corner is positioned 50 pixels from the ______________ and 50 pixels from the ______________.

Quiz 4: Debugging

1. The following code has two errors. Identify and fix them.

import tkinter as tk
root = tk.Tk
root.title("Hello)
label = tk.Label(root, text="Hi")
root.mainloop()

10. Hands‑On Lab (In‑Class Exercises)

Exercise 1: Window Configuration Playground

Task: Write a script that creates a window with the following properties:

• Title: "My Playground"
• Size: 600x400
• Position: centred on the screen (hint: you can calculate screen width/height using root.winfo_screenwidth() and root.winfo_screenheight())
• Non‑resizable in both directions
• Minimum size: 400x300
• Add a label that says "Welcome to the Playground" with a large font (font=("Arial", 20)).

Bonus: Make the label text colour blue.

Exercise 2: Observe the Lifecycle

Task: Write a script that prints "Creating window..." before root = tk.Tk(), prints "Starting mainloop..." just before root.mainloop(), and prints "Window was closed." after root.mainloop(). Run the script and observe the order of print statements. Close the window to see the final print.

Exercise 3: Pack Parameters Experiment

Task: Create a window with three labels: "Top", "Middle", "Bottom". Use pack() with different side values for each label (e.g., side=tk.TOP, side=tk.LEFT, side=tk.RIGHT). Also try adding padx=20 and pady=20 to see how spacing changes. Write down your observations about the layout.

Exercise 4: Custom Close Handler

Task: Modify the basic window so that when the user clicks the "X" button, a pop‑up message (use tk.messagebox.askyesno) asks "Are you sure you want to exit?" If the user answers "Yes", close the window; if "No", keep the window open. (Note: you will need to import tk.messagebox or from tkinter import messagebox.)

11. Homework Assignment

Objective

Demonstrate your deep understanding of the Tkinter root window lifecycle, widget creation, and geometry management. You will also practice reading documentation to discover new methods.

Part A: Window Customisation (10 points)

Write a complete Python script that creates a window with the following specifications:

• Title: "My Custom Window"
• Initial size: 800x500
• Window is initially placed in the bottom‑right corner of the screen (use winfo_screenwidth() and winfo_screenheight() to calculate).
• The window is resizable in both directions, but the minimum allowed size is 500x400 and the maximum is 1200x900.
• The window has an icon (you can use any .ico file, or skip this if you do not have one – but explain what you would do).
• Inside the window, add a Label that displays your full name and student ID, with a font size of 18 and a background colour of lightyellow.
• The label should be centered in the window (hint: use pack(expand=True) or place(relx=0.5, rely=0.5, anchor=tk.CENTER)).

Submit the full code, clearly commented.

</details>

### Part B: Code Interpretation and Explanation (10 points)
Given the following code, answer the questions below:
```python
import tkinter as tk

root = tk.Tk()
root.title("Test")
root.geometry("300x300")

lbl1 = tk.Label(root, text="Label 1")
lbl2 = tk.Label(root, text="Label 2")
lbl3 = tk.Label(root, text="Label 3")

lbl1.pack(side=tk.LEFT, padx=10)
lbl2.pack(side=tk.LEFT, padx=10)
lbl3.pack(side=tk.LEFT, padx=10)

print("All labels packed.")
root.mainloop()
print("Mainloop ended.")

import tkinter as tk
root = tk.Tk()
root.title("Error")
label = tk.Label(text="I am invisible")
root.mainloop()