How to Build a Hangman Game in Python: A Step-by-Step Guide

Hangman is a classic word-guessing game that’s fun and a great project for beginner programmers.

In this article, we’ll learn how to build a simple version of the Hangman game in Python.

By the end, you'll understand how to use Python’s basic control structures, functions, and lists to create this game.

What is Hangman?

The goal of Hangman is to guess a secret word by suggesting letters one at a time.

The player can make only a limited number of incorrect guesses before the game ends.

For each incorrect guess, a part of the "hangman" figure is drawn, and if the full figure is drawn before the word is guessed, the player loses.

Let’s break this down and build the game step by step.

Excited to dive deeper into the world of Python programming? Look no further than my latest ebook, "Python Tricks - A Collection of Tips and Techniques".

Get the eBook

Inside, you'll discover a plethora of Python secrets that will guide you through a journey of learning how to write cleaner, faster, and more Pythonic code. Whether it's mastering data structures, understanding the nuances of object-oriented programming, or uncovering Python's hidden features, this ebook has something for everyone.

Step 1: Plan the Game

Let's plan the game and its key features:

• The game randomly selects a word.
• The player guesses one letter at a time.
• The player has a limited number of incorrect guesses.
• The game displays the word with the correctly guessed letters and blanks for the remaining letters.

The game will have the following components:

• Word selection
• Player input (guess)
• Update the display of the word
• Track the number of incorrect guesses

Step 2: Import Required Libraries

We'll use the random module to randomly select a word from a list.

import random
        

Step 3: Define the Word List

Next, define a list of words that the game will randomly choose from.

You can add more words to make the game more interesting.

word_list = ['python', 'java', 'hangman', 'programming', 'computer']
        

Step 4: Define Functions for the Game

Function 1: Randomly Select a Word

We need a function to randomly pick a word from our word list.

def get_random_word(word_list):
    return random.choice(word_list)
        

Function 2: Display the Current State of the Word

As the player guesses letters, we need to show the correctly guessed letters and placeholders (_) for the unguessed letters.

def display_word(word, guessed_letters):
    display = ''
    for letter in word:
        if letter in guessed_letters:
            display += letter + ' '
        else:
            display += '_ '
    return display.strip()
        

Function 3: Check if the Player Won

This function checks whether all letters of the word have been guessed.

def is_word_guessed(word, guessed_letters):
    for letter in word:
        if letter not in guessed_letters:
            return False
    return True
        

Function 4: Display Hangman

To display a hangman figure in a text-based game, you can use ASCII art to represent the different stages of the hangman.

def display_hangman(wrong_guesses):
    stages = [
        """
           -----
           |   |
           O   |
          /|\\  |
          / \\  |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
          /    |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
           |   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
               |
               |
               |
        --------
        """,
        """
           -----
           |   |
               |
               |
               |
               |
        --------
        """
    ]
    # Reverse the list to display the stages in the correct order
    stages.reverse()
    return stages[wrong_guesses]        

Step 5: The Main Game Loop

Now we can put together the main loop of the game. This loop will:

• Keep track of the guessed letters and incorrect guesses.
• Allow the player to input guesses.
• Update the game state based on the guess.
• End the game when the player wins or loses.

Complete Code Example:

import random


# Function to get a random word from the list
def get_random_word(word_list):
    return random.choice(word_list)


# Function to display the current state of the word
def display_word(word, guessed_letters):
    display = ''
    for letter in word:
        if letter in guessed_letters:
            display += letter + ' '
        else:
            display += '_ '
    return display.strip()


# Function to check if the word has been guessed
def is_word_guessed(word, guessed_letters):
    for letter in word:
        if letter not in guessed_letters:
            return False
    return True


# Function to display the hangman figure
def display_hangman(wrong_guesses):
    stages = [
        """
           -----
           |   |
           O   |
          /|\\  |
          / \\  |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
          /    |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
           |   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
               |
               |
               |
        --------
        """,
        """
           -----
           |   |
               |
               |
               |
               |
        --------
        """
    ]
    # Reverse the list to display the stages in the correct order
    stages.reverse()
    return stages[wrong_guesses]


# Main function to play the game
def play_hangman():
    word_list = ['python', 'java', 'hangman', 'programming', 'computer']
    word = get_random_word(word_list)
    guessed_letters = []
    attempts = 6
    wrong_guesses = 0

    print("Welcome to Hangman!")
    print("Guess the word!")

    # Main game loop
    while wrong_guesses < attempts:
        print(display_hangman(wrong_guesses))
        print(display_word(word, guessed_letters))
        guess = input("Enter a letter: ").lower()

        # Check if the guess is valid
        if len(guess) != 1 or not guess.isalpha():
            print("Please enter a single letter.")
            continue

        # Check if the letter has already been guessed
        if guess in guessed_letters:
            print("You have already guessed that letter.")
            continue

        guessed_letters.append(guess)

        # Check if the guess is in the word
        if guess in word:
            print(f"Good guess! {guess} is in the word.")
        else:
            wrong_guesses += 1
            print(f"Sorry, {guess} is not in the word.")
            print(f"You have {attempts - wrong_guesses} attempts left.")

        # Check if the word is fully guessed
        if is_word_guessed(word, guessed_letters):
            print(f"Congratulations! You've guessed the word: {word}")
            break
    else:
        print(display_hangman(wrong_guesses))
        print(f"Game over! The word was: {word}")


# Run the game
if __name__ == "__main__":
    play_hangman()
        

Explanation

• get_random_word(): Randomly selects a word from the list of words.
• display_word(): Creates a string that represents the current state of the word, showing the correctly guessed letters and placeholders for unguessed ones.
• is_word_guessed(): Checks if the player has guessed all the letters in the word.
• display_hangman(wrong_guesses): This function takes the number of incorrect guesses as an argument and returns the corresponding ASCII art for that stage.
• play_hangman(): The main function that controls the game. It handles user input, keeps track of the player's guesses, and determines if the player has won or lost.

Key Variables:

• guessed_letters: A list to store the letters that the player has guessed.
• wrong_guesses: Tracks how many incorrect guesses the player has made.
• attempts: The maximum number of incorrect guesses allowed.
• stages: This list contains ASCII art representations of the hangman figure at different stages of completion. Each stage corresponds to a different number of incorrect guesses.

Step 6: Running the Game

To run the game, simply execute the Python script, assuming you created a file main.py:

python main.py        

The game will prompt you to enter letters, and it will display the word with correctly guessed letters as you progress.

If you run out of attempts, the game ends, and you lose, like this:

           -----
           |   |
           O   |
          /|\  |
          / \  |
               |
        --------
        
Game over! The word was: programming        

If you guess the word correctly, you win, like this:

           -----
           |   |
               |
               |
               |
               |
        --------
        
j a _ a
Enter a letter: v
Good guess! v is in the word.
Congratulations! You've guessed the word: java        

Conclusion

This simple Hangman game demonstrates the use of control structures, functions, lists, and basic input/output in Python.

As you build this project, you can add more features such as:

• Adding categories of words.
• Giving hints.
• Adding a scoring system.

This is a great project to expand on as you learn more advanced Python concepts.

Article originally published at: https://developer-service.blog/how-to-build-a-hangman-game-in-python-a-step-by-step-guide/