Game — Hangman Lite, Part 1 (Pick & Reveal)

By the end of this lesson you can:

• Pick a random word from a list with random.choice() (callback from PY-L1-19) inside a function.
• Build a "mask" for the secret word — a string of dashes the same length as the word.
• Update the mask one letter at a time as the player guesses, by walking the secret word with a for loop and an index.

Quick recall — how would you hide a word behind dashes? If the word is banana (six letters), the mask is ------. Six dashes, one per letter. Python lets you build that mask in one line:

word = "banana"
mask = "-" * len(word)
print(mask)
# → ------

The * trick on strings comes from PY-L1-05 — multiply a string and you get it repeated. Combined with len(), you get a mask that's always the right length, however long the word is.

Now the harder predict-the-output. If the player guesses a and the word is banana, what should the mask become?

-a-a-a

Pick a secret word

From PY-L1-19, random.choice(list) picks a random item:

import random

WORDS = ["banana", "mango", "rambutan", "durian", "starfruit"]

def pick_word():
    return random.choice(WORDS)

print(pick_word())   # → durian   (or any of the five, randomly)

One-line function. The WORDS list lives at the top of the file in capitals — that's a convention to say "this is a fixed configuration value, treat it as a constant".

Make the initial mask

def make_mask(word):
    return "-" * len(word)

secret = "banana"
print(make_mask(secret))   # → ------

Six characters of word → six dashes. The function works for words of any length, which matters because we don't know which word pick_word will hand us.

Reveal a guessed letter — the key trick

This is the lesson's real idea. Walk the secret word with a for loop. For each position, look at two things — the letter in the secret, and the letter in the current mask. If the secret letter matches the guess, take it; otherwise, keep what was in the mask.

def reveal(secret, mask, guess):
    new_mask = ""
    for i in range(len(secret)):
        if secret[i] == guess:
            new_mask = new_mask + secret[i]    # show the real letter
        else:
            new_mask = new_mask + mask[i]      # keep whatever was already there
    return new_mask

Read it carefully. We build new_mask from scratch every time, one character at a time. At position i:

• If secret[i] matches the guess, add the real letter.
• Otherwise, copy across whatever was in the existing mask at position i — a dash if it's still hidden, or a letter that was revealed by an earlier guess.

See it in action

secret = "banana"
mask = "------"

mask = reveal(secret, mask, "a")
print(mask)   # → -a-a-a

mask = reveal(secret, mask, "n")
print(mask)   # → -anana

mask = reveal(secret, mask, "b")
print(mask)   # → banana

Three calls, three reveals. Each one builds a fresh mask using the secret + the previous mask + the new guess.

Why we don't mutate the mask in place

mask = "------"
mask[1] = "a"
# TypeError: 'str' object does not support item assignment

Strings can't be changed letter-by-letter (that's what immutable means). The work-around — building a new string char-by-char with new_mask + char — is the Level-1 idiom you'll use any time you need to "edit" a string.

The full file

Save as hangman.py:

Code

# hangman.py — Part 1: pick & reveal

import random

WORDS = ["banana", "mango", "rambutan", "durian", "starfruit",
         "pineapple", "papaya", "lychee", "rojak"]

def pick_word():
    return random.choice(WORDS)

def make_mask(word):
    return "-" * len(word)

def reveal(secret, mask, guess):
    new_mask = ""
    for i in range(len(secret)):
        if secret[i] == guess:
            new_mask = new_mask + secret[i]
        else:
            new_mask = new_mask + mask[i]
    return new_mask

# main program — Part 1 (no lives yet)
secret = pick_word()
mask = make_mask(secret)

print("Welcome to Hangman Lite!")
print("Word:", mask, "  (length", len(secret), ")")
print("Type one letter at a time. Type 'quit' to stop.")
print("(Part 2 adds lives — for now you can guess forever.)")

while True:
    guess = input("Guess: ").strip().lower()
    if guess == "quit":
        break
    if len(guess) != 1:
        print("One letter at a time, please.")
        continue

    mask = reveal(secret, mask, guess)
    print("Word:", mask)

    if mask == secret:
        print("🎉 You revealed it! The word was", secret)
        break

Sample run

Welcome to Hangman Lite!
Word: ------   (length 6)
Type one letter at a time. Type 'quit' to stop.
(Part 2 adds lives — for now you can guess forever.)
Guess: a
Word: -a-a-a
Guess: n
Word: -anana
Guess: z
Word: -anana
Guess: b
Word: banana
🎉 You revealed it! The word was banana

Three things to spot

• continue for invalid input. If the player types more than one letter, we print a polite message and skip the rest of the loop — continue jumps straight back to the top.
• mask == secret is the "all revealed" check. The moment the mask matches the secret exactly, every letter has been revealed — we win and break.
• Wrong guesses still update the mask. reveal doesn't care if the guess matches or not — it just builds a new mask. If no letter matches, the new mask is identical to the old one. That's harmless.

Three tasks. Build each function on its own first, then bolt them into the game.

def make_mask(word):
    return "-" * len(word)

print(make_mask("banana"))   # ------
print(make_mask("rojak"))    # -----
print(make_mask("a"))        # -

reveal("banana", "------", "a")   # should return "-a-a-a"
reveal("banana", "-a-a-a", "n")   # should return "-anana"
reveal("banana", "-anana", "b")   # should return "banana"
reveal("banana", "------", "z")   # should return "------" (no change)

def reveal(secret, mask, guess):
    new_mask = ""
    for i in range(len(secret)):
        if secret[i] == guess:
            new_mask = new_mask + secret[i]
        else:
            new_mask = new_mask + mask[i]
    return new_mask

print(reveal("banana", "------", "a"))   # -a-a-a
print(reveal("banana", "-a-a-a", "n"))   # -anana
print(reveal("banana", "-anana", "b"))   # banana
print(reveal("banana", "------", "z"))   # ------

secret = "banana"
mask = make_mask(secret)

print("Word:", mask)

while True:
    guess = input("Guess one letter: ").strip().lower()
    mask = reveal(secret, mask, guess)
    print("Word:", mask)
    if mask == secret:
        print("Won!")
        break

Hangman Lite is a three-function game. pick_word uses random.choice on a list of words. make_mask turns a word into a string of dashes the same length. reveal takes the secret, the current mask, and the player's guess, and builds a fresh new mask by walking the word one position at a time — copying the real letter where it matches, and the old mask everywhere else. Because Python strings are immutable, we can't edit the mask in place — we always build a new one. The whole game today is just a while loop that asks for a guess, calls reveal, and stops when the mask equals the secret. Next lesson we add lives, a list of already-guessed letters, and the win/lose ending.