Game — Hangman Lite, Part 3 (ASCII Polish)

By the end of this lesson you can:

• Store a multi-line string with triple quotes ("""...""") and print it intact.
• Put seven multi-line pictures in a list and index in with GALLOWS[lives] to pick the right one.
• Wrap the picture-printing in a function draw_gallows(lives) so the main loop stays readable.

You already know that "\n" inside a string makes a newline. Python has a nicer way for long strings — triple quotes. Anything between them is preserved exactly, line breaks and all:

art = """  +---+
  |   |
      |
      |
      |
      |
========="""

print(art)

  +---+
  |   |
      |
      |
      |
      |
=========

That's the empty gallows — no stick figure yet. One print(), six lines of output. No string concatenation acrobatics.

Seven pictures, one per state

We have 7 possible "lives" values — 6, 5, 4, 3, 2, 1, 0. So we need 7 pictures: empty gallows, head, head+body, +one arm, +two arms, +one leg, +two legs (dead).

Store them in a list — the index IS the lives count

Clever bit: put them in a list where index 0 is the full hangman (0 lives left = dead) and index 6 is the empty gallows (6 lives = nothing drawn yet). Then GALLOWS[lives] gives the right picture automatically:

GALLOWS = [
    # index 0 — dead (no lives left)
    """  +---+
  |   |
  O   |
 /|\\  |
 / \\  |
      |
=========""",

    # index 1
    """  +---+
  |   |
  O   |
 /|\\  |
 /    |
      |
=========""",

    # index 2
    """  +---+
  |   |
  O   |
 /|\\  |
      |
      |
=========""",

    # index 3
    """  +---+
  |   |
  O   |
 /|   |
      |
      |
=========""",

    # index 4
    """  +---+
  |   |
  O   |
  |   |
      |
      |
=========""",

    # index 5
    """  +---+
  |   |
  O   |
      |
      |
      |
=========""",

    # index 6 — empty gallows (full lives)
    """  +---+
  |   |
      |
      |
      |
      |
=========""",
]

One function does the picking

def draw_gallows(lives):
    print(GALLOWS[lives])

Two lines. GALLOWS[lives] reads "the picture at position lives". When lives is 6, we get the empty gallows. When lives drops to 5, we get the head-only picture. When lives hits 0, we get the full hangman.

Why the index ordering matters

The reason index 0 = full hangman and index 6 = empty gallows is so the index directly equals the lives count. No subtraction, no len(GALLOWS) - 1 - lives arithmetic. The list's shape is doing the work.

Why backslashes need escaping

Look at the arms — written as /|\\ in the strings above. To get a single backslash into a Python string, you type \\\\ (two backslashes). One backslash on its own would start an escape sequence (\\n, \\t, etc.). Two backslashes mean "literal backslash". This is the only fiddly bit about ASCII art in Python.

Bolt the gallows onto Part 2

Update hangman.py. The functions and main loop from Part 2 don't change; we just add GALLOWS + draw_gallows and call the function after each wrong guess and once at the start.

Code

# hangman.py — Part 3: ASCII gallows

import random

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

GALLOWS = [
"""  +---+
  |   |
  O   |
 /|\\  |
 / \\  |
      |
=========""",
"""  +---+
  |   |
  O   |
 /|\\  |
 /    |
      |
=========""",
"""  +---+
  |   |
  O   |
 /|\\  |
      |
      |
=========""",
"""  +---+
  |   |
  O   |
 /|   |
      |
      |
=========""",
"""  +---+
  |   |
  O   |
  |   |
      |
      |
=========""",
"""  +---+
  |   |
  O   |
      |
      |
      |
=========""",
"""  +---+
  |   |
      |
      |
      |
      |
=========""",
]

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

def draw_gallows(lives):
    print(GALLOWS[lives])

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

print("=" * 40)
print("        Hangman Lite v3")
print("=" * 40)
draw_gallows(lives)
print("Word:", mask, " (length", len(secret), ")")

while lives > 0:
    print()
    print("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("Already tried — no penalty.")
        continue
    guessed.append(guess)

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

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

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 slow loss

========================================
        Hangman Lite v3
========================================
  +---+
  |   |
      |
      |
      |
      |
=========
Word: ------  (length 6)

Guessed: [] | Lives: 6
Guess: x
  +---+
  |   |
  O   |
      |
      |
      |
=========
❌ Nope. Lives left: 5

Guessed: ['x'] | Lives: 5
Guess: y
  +---+
  |   |
  O   |
  |   |
      |
      |
=========
❌ Nope. Lives left: 4
... (you get the idea — every wrong guess adds a body part)

Two important details

• Draw the gallows once before the loop too. The first call to draw_gallows(lives) happens up there with lives=6 so the player sees the empty frame before they've guessed anything.
• Only draw after wrong guesses. A right guess doesn't change the picture, so don't print it — fewer screen-fulls of repetitive art.

Three tasks. Start small, then bolt it in.

frame = """  +---+
  |   |
      |
      |
      |
      |
========="""

print(frame)

pics = [
"""  +---+
  |   |
  O   |
 /|\\  |
 / \\  |
      |
=========""",
"""  +---+
  |   |
      |
      |
      |
      |
=========""",
]

def show(n):
    print(pics[n])

show(1)   # empty gallows
print("...one wrong guess later...")
show(0)   # dead

for n in range(6, -1, -1):
    show(n)
    print("---")

Today added no new keywords — only a beautifully tidy use of what you already knew. Triple-quoted strings hold multi-line ASCII art with newlines preserved. A list of seven such strings, ordered so that index equals the number of lives left, lets us pick the right picture with a single GALLOWS[lives] lookup. We wrapped that in a draw_gallows function so the main loop stays clean. The mechanics of the game are identical to Part 2; the experience is transformed because the feedback is now visual. Next lesson — Project: ASCII Banner Generator — we make our own ASCII art from scratch instead of looking it up.