Building a Wordle Game in Python

“I am not building a game. I am building a new country.” Philip Rosedale.
Here is the classic wordle from New York Times.
Play Wordle on The New York Times

Overview

I recently put together a Wordle-like game in Python, and I’d like to share my journey with you. In this post, I’ll walk you through the code step by step, discuss the obstacles I ran into, and point out some areas for improvement.

The game follows a straightforward approach:

  1. Loading a Word List: We start by reading a file that contains a list of valid five-letter words.

  2. Choosing a Secret Word: A random word from the list is selected as the secret word.

  3. User Input: The player is prompted to guess the word.

  4. Feedback with Colors: The game compares the guess with the secret word and provides color-coded feedback:

    • Green: The letter is correct and in the correct position.
    • Yellow: The letter exists in the word but is in the wrong position.
    • Red: The letter does not appear in the word.
      Six Attempts: The player gets six tries to guess the word correctly.
      The code uses the “colorama” library to print colored text to the terminal, which adds a fun visual element to the game.

Code Walkthrough

1. Importing Libraries and Setting Up Colorama

1
2
3
4
from colorama import Back, init
import random

init(autoreset=True)
  • colorama: This library allows us to print colored text (in our case, colored backgrounds) to the terminal.
  • random: Used to randomly select the secret word.
  • init(autoreset=True): This line ensures that every print statement resets the terminal color, so you don’t have to worry about colors bleeding over into subsequent output.

2. Reading the Word List

1
2
3
4
5
def read_word_list():
    f = open('wordle/input-words.txt', 'r')
    text = f.read()
    word_list = text.strip().split('\n')
    return word_list
  • Purpose: Opens and reads a text file (wordle/input-words.txt) containing valid five-letter words.
  • Process:
    • The file is read in its entirety.
    • Extra whitespace is removed, and the content is split into a list of words based on newlines.

3. Selecting the Secret Word.

1
2
3
4
5
def get_secret_word():
    word_list = read_word_list()
    rand_num = random.randint(0, len(word_list) - 1)
    secret_word = word_list[rand_num]
    return secret_word
  • Purpose: Chooses a random word from the word list to serve as the secret word.
  • Process:
    • Retrieves the list of words.
    • Uses random.randint to pick an index, then returns the word at that index.

4. Getting and Validating User Input

1
2
3
4
5
def get_user_input():
    user_input = input("Enter a five letter English word: ").strip().upper()
    while len(user_input) != 5 or not user_input.isalpha():
        user_input = input("Ah?Enter a five letter English word: ").strip().upper()
    return user_input
  • Purpose: Receives user’s guess and validates that the input is exactly five alphabetic characters.
  • Details:
    • The input is trimmed and converted to uppercase.
    • The loop continues until a valid word is entered.

5. Processing the Guess and Providing Feedback

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def get_user_result():
    guess = user_input

    # Initialize word frequency dict
    word_freq_dict = {}
    for i in range(len(secret_word)):
        word_freq_dict[secret_word[i]] = word_freq_dict.get(secret_word[i], 0) + 1

    # Initialize to 5 Red
    guess_colors = ["R"] * len(user_input)

    # Deal with GREEN (correct letter and position)
    for i in range(len(secret_word)):
        if guess[i] == secret_word[i]:
            guess_colors[i] = 'G'
            word_freq_dict[guess[i]] -= 1

    # Deal with YELLOW (correct letter, wrong position)
    for i in range(len(secret_word)):
        if guess[i] in secret_word and guess[i] != secret_word[i] and word_freq_dict[guess[i]] > 0:
            guess_colors[i] = 'Y'
            word_freq_dict[guess[i]] -= 1

    return guess_colors
  • Purpose: Compares the user’s guess to the secret word and generates a list of color codes for each letter.
  • Process:
    1. Frequency Dictionary: Counts how many times each letter appears in the secret word.
    2. Initial Setup: Every letter in the guess is assumed to be incorrect (Red).
    3. Green Check: If a letter is in the correct position, it’s marked Green and its frequency is reduced.
    4. Yellow Check: If a letter is in the secret word but in the wrong position and still has a remaining count, it’s marked Yellow.

6. The Main Game Loop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
secret_word = get_secret_word()
user_input = get_user_input()

# Give the user 6 times to guess
for i in range(6):
    guess_colors = get_user_result()
    for j in range(len(secret_word)):
        if guess_colors[j] == 'G':
            print(Back.GREEN + user_input[j], end="")
        elif guess_colors[j] == 'Y':
            print(Back.YELLOW + user_input[j], end="")
        else:
            print(Back.RED + user_input[j], end="")

    print()
    if user_input == secret_word:
        print(f"Congrats! You got the word {secret_word} right in {i} trials. ")
        break
    elif i == 5:
        print(f"I am sorry. The correct answer is {secret_word}. Try again next time.")
    else:
        user_input = get_user_input()
  • Purpose: This loop allows the user up to 6 attempts to guess the secret word.
  • Flow:
    • The secret word is selected, and the user is prompted for their guess.
    • For each guess, the game processes the input and prints each letter with a colored background.
    • If the guess matches the secret word, the player is congratulated.
    • If the guess is incorrect and there are still attempts remaining, the player is asked for another guess.
    • After 6 attempts, if the user still hasn’t guessed the word, the correct answer is revealed.

Complete Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
from colorama import Back, init
import random

init(autoreset=True)


# Read word list
def read_word_list():
    f = open('wordle/input-words.txt', 'r')
    text = f.read()
    word_list = text.strip().split('\n')
    return word_list


def get_secret_word():
    word_list = read_word_list()
    rand_num = random.randint(0, len(word_list) - 1)
    secret_word = word_list[rand_num]
    return secret_word


def get_user_input():
    user_input = input("Enter a five letter English word: ").strip().upper()
    while len(user_input) != 5 or not user_input.isalpha():
        user_input = input("Ah?Enter a five letter English word: ").strip().upper()
    return user_input


def get_user_result():
    guess = user_input

    # Initialize word frequency dict
    word_freq_dict = {}
    for i in range(len(secret_word)):
        word_freq_dict[secret_word[i]] = word_freq_dict.get(secret_word[i], 0) + 1

    # Initialize to 5 Red
    guess_colors = ["R"] * len(user_input)

    # Deal with GREEN
    for i in range(len(secret_word)):
        if guess[i] == secret_word[i]:
            guess_colors[i] = 'G'
            word_freq_dict[guess[i]] -= 1

    # Deal with YELLOW
    for i in range(len(secret_word)):
        if guess[i] in secret_word and guess[i] != secret_word[i] and word_freq_dict[guess[i]] > 0:
            guess_colors[i] = 'Y'
            word_freq_dict[guess[i]] -= 1

    return guess_colors


secret_word = get_secret_word()
user_input = get_user_input()

# Give the user 6 times to guess
for i in range(6):
    guess_colors = get_user_result()
    for j in range(len(secret_word)):
        if guess_colors[j] == 'G':
            print(Back.GREEN + user_input[j], end="")
        elif guess_colors[j] == 'Y':
            print(Back.YELLOW + user_input[j], end="")
        else:
            print(Back.RED + user_input[j], end="")

    print()
    if user_input == secret_word:
        print(f"Congrats! You got the word {secret_word} right in {i} trials. ")
        break
    elif i == 5:
        print(f"I am sorry. The correct answer is {secret_word}. Try again next time.")
    else:
        user_input = get_user_input()

Obstacles and Problems

  1. Error Handling:
    The code currently assumes the word list file exists and is correctly formatted. In future versions, I plan to add error handling for file I/O operations and user input errors.

  2. User Input Repetition:
    The game structure uses global variables (user_input and secret_word) across functions. Refactoring to pass these values explicitly would improve readability and maintainability.

  3. Feedback Logic:
    Although the current color-coding logic works well, edge cases (such as repeated letters) could be handled more elegantly. I’m considering ways to refine this logic for a more robust solution.

  4. UI/UX Enhancements:
    Right now, the game runs in the terminal. A graphical interface or a web-based version could provide a more engaging user experience.