Sunday, April 21, 2024

Exploring my Image Viewer Repository: A Python Tkinter Project (Part 2)

Are you interested in exploring the world of Python GUI programming and image manipulation? If so, you're in the right place! In this blog post, we'll dive further into creating a simple yet powerful picture viewer application using Python's Tkinter library. 

A short time ago a first post about this topic was presented on my blog. and i already have planned a next post about this topic with further improvements. 

Introduction to Tkinter and Image Manipulation

Tkinter is a popular Python library for creating graphical user interfaces (GUIs). It provides a simple and intuitive way to build interactive applications with widgets like buttons, labels, and frames.

Combined with the PIL (Python Imaging Library) or its successor, Pillow, Tkinter becomes a versatile tool for handling and displaying images within your applications. With these libraries, you can load, resize, and manipulate images with ease.

Coding and Tkinter libary (create using NightCafe Studio AI)

Building the Picture Viewer App

The goal is to create a picture viewer application that allows users to view different images and toggle the visibility of the picture frame. Here's an overview of the key components of our application:

Tkinter Window Initialization: We start by creating a Tkinter window as the main container for our application.

Picture Frame Creation: Within the main window, we create a frame to display the images. This frame will dynamically update to show the selected image.

Menu Bar Setup: We design a menu bar with options to control the picture frame. Users can show or hide the frame, toggle its visibility, and exit the application.

Image Loading and Display: Using PIL (or Pillow), we load images from file paths and display them within the picture frame. Images are resized to fit the frame's dimensions.

Frame Control Functions: We implement functions to handle frame visibility. Users can show, hide, or toggle the frame's visibility based on their preferences.

Exploring the Code

The Python code is structured into a class named PictureViewerApp, encapsulating the entire application logic. Here's a brief breakdown of the class methods:

  • __init__: Initializes the Tkinter window, creates the picture frame, loads an initial image, and sets up the menu bar.
  • create_menu: Creates the menu bar with options for controlling the picture frame and selecting images.
  • load_image: Loads an image file from the provided path and displays it within the picture frame.
  • display_image: Displays the currently loaded image within the picture frame after resizing it to fit.
  • show_frame and hide_frame: Functions to explicitly show or hide the picture frame.
  • toggle_frame: Toggles the visibility of the picture frame based on its current state.

In the provided code, the lambda function is used within the menu creation to bind commands to menu items dynamically. Let's break down its use and why it's needed in this context.   

The most recent version of the code will be posted as  `` in my GitHub Repository about this topic however i also did put the code below:   

import tkinter as tk

from PIL import ImageTk, Image

class PictureViewerApp:


    A simple picture viewer application using Tkinter.

    This application allows users to view different pictures and toggle the visibility of the picture frame.


        master (tk.Tk): The main Tkinter window.

        plugin_frame (tk.Frame): The frame to display the pictures.

        current_image (Image): The currently displayed image.

        menu_bar (tk.Menu): The main menu bar.

        frame_menu (tk.Menu): Submenu for frame options.

        picture_menu (tk.Menu): Submenu for picture options.


    def __init__(self, master):


        Initialize the PictureViewerApp.


            master (tk.Tk): The main Tkinter window.


        self.master = master

        master.title("Picture Viewer Example")

        # Create a frame inside the main window

        self.plugin_frame = tk.Frame(master, padx=20, pady=20)


        # Load initial image

        self.current_image ="img/picture1.jpg")


        # Create menu


    def create_menu(self):


        Create the main menu bar and its submenus.


        self.menu_bar = tk.Menu(self.master)


        # Frame submenu

        self.frame_menu = tk.Menu(self.menu_bar, tearoff=0)

        self.frame_menu.add_command(label="Show", command=self.show_frame)

        self.frame_menu.add_command(label="Hide", command=self.hide_frame)


        self.frame_menu.add_command(label="Toggle", command=self.toggle_frame)


        self.frame_menu.add_command(label="Exit", command=exit)

        # Pictures submenu

        self.picture_menu = tk.Menu(self.menu_bar, tearoff=0)

        self.picture_menu.add_command(label="Picture 1", command=lambda: self.load_image("img/picture1.jpg"))

        self.picture_menu.add_command(label="Picture 2", command=lambda: self.load_image("img/picture2.jpg"))

        self.picture_menu.add_command(label="Picture 3", command=lambda: self.load_image("img/picture3.jpg"))

        self.picture_menu.add_command(label="Picture 4", command=lambda: self.load_image("img/picture4.jpg"))

        self.picture_menu.add_command(label="Picture 5", command=lambda: self.load_image("img/picture5.jpg"))

        self.menu_bar.add_cascade(label="Frame", menu=self.frame_menu)

        self.menu_bar.add_cascade(label="Pictures", menu=self.picture_menu)

    def load_image(self, filename):


        Load an image file and display it in the frame.


            filename (str): The path to the image file.


        self.current_image =


    def display_image(self):


        Display the current image in the frame.


        # Clear the frame

        for widget in self.plugin_frame.winfo_children():


        # Resize the image to fit the frame

        resized_image = self.current_image.resize((400, 300), Image.BILINEAR)

        photo = ImageTk.PhotoImage(resized_image)

        # Display the image in a label

        image_label = tk.Label(self.plugin_frame, image=photo)

        image_label.image = photo  # Keep a reference to avoid garbage collection


    def show_frame(self):


        Show the picture frame.



    def hide_frame(self):


        Hide the picture frame.



    def toggle_frame(self):


        Toggle the visibility of the picture frame.


        if self.plugin_frame.winfo_ismapped():




# Create the main window and run the application

root = tk.Tk()

app = PictureViewerApp(root)


What is a Lambda Function?

A lambda function in Python is a small anonymous function defined using the lambda keyword. It allows you to create a function without a name. Lambda functions can have any number of arguments but only one expression, which is evaluated and returned. They are often used as a shortcut for simple, one-line functions.

Why is Lambda Needed?

In the context of the provided code, lambda functions are used to create anonymous functions that call the load_image method with different arguments based on the selected menu item. Let's take a closer look at how this is achieved:

self.picture_menu.add_command(label="Picture 1", command=lambda: self.load_image("img/picture1.jpg"))

Here, lambda: self.load_image("img/picture1.jpg") is a lambda function. When the "Picture 1" menu item is selected, this lambda function is executed, which in turn calls the load_image method with the argument "img/picture1.jpg". Similarly, lambda functions are used for other menu items, each calling the load_image method with a different file path.

Why Lambda is Useful:

Dynamic Binding: Lambda functions allow us to bind commands to menu items dynamically. Instead of defining a separate function for each menu item, we can use lambda to create anonymous functions inline.

Conciseness: Lambda functions are concise and can be written in a single line, making the code more readable and reducing the need for additional named functions.

Flexibility: Lambda functions are flexible and can be used in situations where a named function would be cumbersome or unnecessary, such as when defining callbacks for GUI events.


By combining the power of Tkinter for GUI development and PIL/Pillow for image manipulation, we've created a functional picture viewer application in Python. This project serves as a great starting point for exploring more advanced GUI applications and image processing tasks.

The lambda functions are useful in this context because they provide a concise and flexible way to dynamically bind commands to menu items, allowing for cleaner and more readable code. They help streamline the process of defining callbacks for GUI elements like menu items.

In a an upcoming part i will further improve this program. Whether you're building a simple viewer for personal use or integrating image viewing capabilities into a larger application, Tkinter and PIL/Pillow provide the tools you need to succeed.

Happy coding and exploring the world of Python GUI programming!

No comments: