Game — Hangman Lite, Part 2 (Lives & Win)

By the end of this lesson you can:

• Initialise a lives counter and decrement it only on wrong guesses — not on repeats and not on invalid input.
• End the loop with two different breaks: one for winning (mask revealed), one for losing (lives hit zero).
• Print a different ending message for win vs lose, using the state of the loop when it exited.

Two questions to think about before we write code:

1. Last lesson, was a wrong guess punished? (Answer: no — the player could guess forever.) What changes today is that wrong guesses cost a life.
2. When the player types a letter they've already guessed, should they lose a life? Most Hangman implementations say no. Repeats are just bounced back with a polite message.

So we need to tell three cases apart: right guess (mask changes, no life lost), wrong guess (mask doesn't change, lose one life), repeat guess (skip everything, lose no life).

The lives counter pattern

Same shape as the score counter from PY-L1-33 — but counting down, not up:

lives = 6

while lives > 0:
    # ... ask, judge ...
    if wrong:
        lives = lives - 1
        print("Lives left:", lives)

The while lives > 0: in the loop header is half the win/lose logic — the moment lives hits 0, the condition becomes False and the loop exits on its own. No break needed for losing.

The before/after comparison

How do we know if the guess was right or wrong? Save the mask before calling reveal, then compare:

old_mask = mask
mask = reveal(secret, mask, guess)

if mask == old_mask:
    # nothing changed → wrong guess
    print("❌ Nope.")
    lives = lives - 1
else:
    # something revealed → right guess
    print("✅ Good guess!")

The reveal function from Part 1 doesn't need to know whether the guess was right. The main program figures it out by comparing.

Two ways out of the loop

The loop ends in one of two ways:

• Win. Inside the loop, after a successful reveal, check if is_revealed(mask) and break.
• Lose. The while lives > 0: condition becomes false, the loop exits naturally — no break.

To tell them apart after the loop, just check what state the variables are in:

# after the loop
if is_revealed(mask):
    print("🎉 You won!")
else:
    print("💀 Game over. The word was", secret)

If we exited because we won, the mask is fully revealed. If we exited because we ran out of lives, it isn't. One little if tells the two endings apart.

Why 6 lives?

Six is the classic Hangman number — head, body, two arms, two legs. Any number works. 3 for very hard, 10 for very forgiving.

Don't cost a life on repeats

The continue idiom from Part 1 helps. Before we touch reveal, check if the letter is in the guessed list — if it is, scold and continue. Lives don't change.

if guess in guessed:
    print("Already tried that.")
    continue   # ← jumps back to top, no life lost

guessed.append(guess)
# only NOW do we call reveal and possibly lose a life

The full file

Save (or update) hangman.py:

Code

# hangman.py — Part 2: lives & win/lose

import random

WORDS = [
    "banana", "mango", "rambutan", "durian", "starfruit",
    "pineapple", "papaya", "lychee", "rojak", "guava",
    "longan", "mangosteen", "soursop", "jambu", "pomelo",
]

LIVES = 6

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

def is_revealed(mask):
    return "-" not in mask

# main program
secret = pick_word()
mask = make_mask(secret)
guessed = []
lives = LIVES

print("=" * 40)
print("        Hangman Lite — Hub Edition")
print("=" * 40)
print("Word:", mask, " (length", len(secret), ")")
print("You have", lives, "lives.")
print()

while lives > 0:
    print("Already guessed:", guessed, "| Lives:", lives)
    guess = input("Guess: ").strip().lower()

    if len(guess) != 1 or not guess.isalpha():
        print("One letter at a time, please.")
        continue
    if guess in guessed:
        print("You already tried that one.")
        continue

    guessed.append(guess)

    old_mask = mask
    mask = reveal(secret, mask, guess)

    if mask == old_mask:
        lives = lives - 1
        print("❌ Nope. Lives left:", lives)
    else:
        print("✅ Good guess!  Word:", mask)
        if is_revealed(mask):
            break

# the loop has ended — decide why
print()
print("=" * 40)
if is_revealed(mask):
    print("🎉 You won! The word was", secret)
else:
    print("💀 Game over. The word was", secret)
print("=" * 40)

Sample run · a clean win

========================================
        Hangman Lite — Hub Edition
========================================
Word: ------  (length 6)
You have 6 lives.

Already guessed: [] | Lives: 6
Guess: a
✅ Good guess!  Word: -a-a-a
Already guessed: ['a'] | Lives: 6
Guess: n
✅ Good guess!  Word: -anana
Already guessed: ['a', 'n'] | Lives: 6
Guess: b
✅ Good guess!  Word: banana

========================================
🎉 You won! The word was banana
========================================

Sample run · a sad loss

Guess: x
❌ Nope. Lives left: 5
Guess: q
❌ Nope. Lives left: 4
Guess: z
❌ Nope. Lives left: 3
Guess: y
❌ Nope. Lives left: 2
Guess: w
❌ Nope. Lives left: 1
Guess: v
❌ Nope. Lives left: 0

========================================
💀 Game over. The word was banana
========================================

Things worth pausing on

• not guess.isalpha() is a new tiny method — it returns False if the string contains anything other than letters. Numbers and punctuation get politely rejected with the "one letter at a time" message and no life lost. (You can drop it if you find it tricky.)
• LIVES at the top as a constant means changing the difficulty is a one-line edit. Set LIVES = 3 for hard mode.
• Same ending check inside and after the loop. if is_revealed(mask) is used twice — once to break on a win, once to decide which ending message to print. The function from yesterday earned its keep.

Three tasks. Build the lives counter first, then handle the win/lose ending, then add a polish touch.

lives = 6

while lives > 0:
    guess = input("Guess: ").strip().lower()
    # ...validation...

    old_mask = mask
    mask = reveal(secret, mask, guess)

    if mask == old_mask:
        lives = lives - 1
        print("Wrong! Lives left:", lives)
    else:
        print("Right!")

# after the loop
if is_revealed(mask):
    print("🎉 You won!")
else:
    print("💀 Game over. The word was", secret)

# inside the loop, near the top
if guess in guessed:
    print("Already tried that — no penalty.")
    continue

guessed.append(guess)
# the rest of the iteration runs only for new guesses

Hangman Lite is complete. A lives counter starts at 6 and ticks down only on wrong guesses — we detect "wrong" by comparing the mask before and after reveal. The while lives > 0 loop condition does the "ran out of lives" case automatically, and a break handles the "won" case. After the loop, one if is_revealed(mask) tells the two endings apart. Repeats are handled with continue so they cost nothing. The functions from Part 1 — pick_word, make_mask, reveal, is_revealed — didn't change a line. That's the function payoff at its purest: yesterday's reliable code, plugged into today's richer game. Next lesson we polish the look — ASCII gallows that draw step by step.