Monty Hall Problem Simulation Using Tkinter

Introduction

The Monty Hall problem is a famous probability puzzle based on a game show scenario. In the game, a contestant is presented with three doors. Behind one of the doors is a prize (like a car), while the other two doors hide goats. The contestant selects one of the doors. The host, who knows where the prize is, then opens one of the other two doors to reveal a goat. The contestant is then given the option to either stay with their original choice or switch to the other unopened door. The question is: What's the best strategy, to switch or to stay? This project will guide you through building a GUI application to simulate the Monty Hall problem using the Tkinter library in Python.

👀 Preview

🎯 Tasks

In this project, you will learn:

• How to design and develop a graphical user interface (GUI) using Tkinter.
• How to simulate the Monty Hall problem to understand its probabilistic outcomes.
• How to implement game logic in Python to handle user choices and reveal results.
• How to use Python's random library to randomly allocate the prize behind one of the doors.
• How to reset game states to allow multiple rounds of play without restarting the application.

🏆 Achievements

After completing this project, you will be able to:

• Apply GUI design principles and implement them in Python with Tkinter.
• Understand the practical application of probability and statistics in game simulations.
• Implement event-driven programming and handle user interactions in a GUI application.
• Utilize advanced Python programming techniques such as lambda functions and list comprehensions.
• Recognize the importance of user experience (UX) in game design and provide feedback mechanisms using message boxes.

Skills Graph

Create Project Files

First, create a Python file named monty_hall_gui.py in ~/project. Then open it in a text editor or an integrated development environment (IDE).

cd ~/project
touch monty_hall_gui.py

Import Necessary Libraries

To begin, we'll import the required modules.

import tkinter as tk
from tkinter import messagebox
import random
from typing import List, Optional

In the above code, we're importing the required Python libraries. tkinter is for GUI creation, messagebox is for pop-up alerts, and random is for randomized game logic.

Initialize the MontyHallSimulation Class

Now, we will create the main class to manage our simulation.

class MontyHallSimulation:
    def __init__(self, root: tk.Tk) -> None:
        """
        Initialize the Monty Hall Simulation.

        :param root: The main tkinter window
        """
        ## Window Configuration
        self.root = root
        self.root.title("Monty Hall Problem Simulation")
        self.root.geometry("1200x800")

In the above instructions, we begin to define our main class for the simulation.

Set Up Variables and UI Components

Within the class, initialize the necessary variables and UI elements.

        ## Variables to keep track of the user's selected door, the door that's shown, and the winning door
        self.selected_door: Optional[int] = None
        self.show_door: Optional[int] = None
        self.winning_door: int = random.randint(1, 3)

        ## Variables to keep track of win counts based on decision to change or stay
        self.wins_change: int = 0
        self.wins_stay: int = 0

        ## Instructions displayed at the top
        self.label = tk.Label(root, text="Select a door!", font=("Arial", 16))
        self.label.pack(pady=5)

        ## Creating frame for door buttons
        self.doors_frame = tk.Frame(root)
        self.doors_frame.pack(pady=5)

The above instructions guide you through initializing various game variables and setting up the primary UI elements for our simulation.

Set Up Door Images and Buttons

Load the door images and configure door buttons to allow user interaction.

        ## Load door images
        self.door_imgs: List[tk.PhotoImage] = [
            tk.PhotoImage(file="door_closed.png"),
            tk.PhotoImage(file="door_opened_empty.png"),
            tk.PhotoImage(file="door_opened_prize.png")
        ]

        ## Create door buttons with images and attach select door function
        self.door_buttons: List[tk.Button] = [
            tk.Button(self.doors_frame, image=self.door_imgs[0], command=lambda: self.select_door(1)),
            tk.Button(self.doors_frame, image=self.door_imgs[0], command=lambda: self.select_door(2)),
            tk.Button(self.doors_frame, image=self.door_imgs[0], command=lambda: self.select_door(3))
        ]

        for button in self.door_buttons:
            button.pack(side=tk.LEFT, padx=5)

        ## Buttons for choosing whether to switch doors
        self.yes_button = tk.Button(self.root, text="Yes", command=self.switch_door)
        self.yes_button.pack_forget()

        self.no_button = tk.Button(self.root, text="No", command=self.stay_door)
        self.no_button.pack_forget()

        ## Displaying results
        self.results_label = tk.Label(root, text="", font=("Arial", 14))
        self.results_label.pack(pady=5)

In the above code, we're loading the door images that represent different door states. We then create and configure three buttons representing the doors, which allow the user to make their choice.

Implement Door Selection Logic

First, we'll tackle the logic for selecting a door.

    def select_door(self, door: int) -> None:
        """
        Handle the event when a door is selected.

        :param door: The number of the door selected
        """
        ## Ensure no re-selection of doors
        if self.selected_door:
            return

        self.selected_door = door

        ## Determine which doors were not selected
        non_selected_doors = [d for d in [1, 2, 3] if d != self.selected_door]

        ## Decide which door to reveal
        if self.selected_door == self.winning_door:
            show_door = random.choice(non_selected_doors)
        else:
            non_selected_doors.remove(self.winning_door)
            show_door = non_selected_doors[0]

        self.show_door = show_door
        self.door_buttons[show_door - 1].config(image=self.door_imgs[1])

        ## Prompt the user to decide whether to switch
        self.label.config(text="Would you like to switch?")

        ## Display the yes and no buttons
        self.yes_button.pack(side=tk.LEFT, padx=10, pady=20)
        self.no_button.pack(side=tk.RIGHT, padx=10, pady=20)

In the above code, we define the select_door method which will be used when a player chooses a door. The method will remember the player's selection and reveal one of the doors that doesn't contain the prize.

Handle Door Switching Logic

Next, we delve into the logic of swapping door choices.

    def switch_door(self) -> None:
        """Handle the event when the user decides to switch doors."""
        ## Find the door that was not selected and not revealed
        remaining_doors = [d for d in [1, 2, 3] if d != self.selected_door and d != self.show_door]
        new_door = remaining_doors[0]

        ## Check for a win
        if new_door == self.winning_door:
            self.wins_change += 1
            self.show_win(True)
        else:
            self.show_win(False)

Here, the switch_door function manages what transpires when a player opts to switch doors after the host reveals a goat behind one of the non-selected doors.

Address Door Retention Logic

Now, let's address the logic for retaining the initial door choice.

    def stay_door(self) -> None:
        """Handle the event when the user decides to stay with the initial door selection."""
        ## Check for a win
        if self.selected_door == self.winning_door:
            self.wins_stay += 1
            self.show_win(True)
        else:
            self.show_win(False)

In this snippet, the stay_door function supervises the outcome when the player decides to remain with their initial door choice.

Illustrate Win or Loss

Subsequently, illustrate whether the player secured a win or not.

    def show_win(self, did_win: bool) -> None:
        """
        Display the results after revealing all doors.

        :param did_win: Boolean indicating whether the user won or not
        """
        ## Update door images based on the results
        for i, button in enumerate(self.door_buttons):
            if i + 1 == self.winning_door:
                button.config(image=self.door_imgs[2])
            else:
                button.config(image=self.door_imgs[1])

        ## Show win/lose message
        if did_win:
            messagebox.showinfo("Congratulations!", "You won!")
        else:
            messagebox.showinfo("Sorry!", "Better luck next time!")

        ## Update the win statistics
        self.results_label.config(text=f"Wins (Switch): {self.wins_change}   Wins (Stay): {self.wins_stay}")

        ## Prepare for the next round
        self.reset_game()

This show_win method reveals the outcomes. If the player's final door selection conceals the prize, they are announced as a winner; otherwise, better luck is wished for next time.

Reset Game Mechanics

Finally, ensure you can reinitialize the game for another round.

    def reset_game(self) -> None:
        """Reset the game for a new round."""
        self.selected_door = None
        self.winning_door = random.randint(1, 3)
        for button in self.door_buttons:
            button.config(image=self.door_imgs[0])
        self.label.config(text="Select a door!")
        self.yes_button.pack_forget()
        self.no_button.pack_forget()

This function, reset_game, reboots the game state, allowing players to attempt another round.

Run the Application

Finally, let's initialize and run our application.

if __name__ == "__main__":
    root = tk.Tk()
    sim = MontyHallSimulation(root)
    root.mainloop()

Now we've completed all the steps, we can run the code using the following command:

cd ~/project
python monty_hall_gui.py

Summary

Congratulations! You have just created a GUI-based simulation of the Monty Hall problem using Tkinter. To run the simulation, execute the monty_hall_gui.py script and interact with the graphical interface. Remember, the game showcases the counterintuitive nature of probability, and the best strategy is to always switch doors!