Saving High Scores to a File

By the end of this lesson you can:

• Read a scores file with open() / with and handle a missing file using try/except FileNotFoundError.
• Write a sorted top-5 list of integers back to the same file so scores survive between game sessions.
• Call load_scores() and save_scores() inside a Pygame Zero game loop to persist the leaderboard.

In Level 2 you used open() and with to read files. Let's dust that off. What does this snippet print — and what happens on the second call to int()?

lines = ["42\n", "hello\n", "7\n"]
for line in lines:
    print(int(line.strip()))

Think of a high-score file like a sticky note on the fridge. The game writes new scores onto it when it closes, and reads them back when it opens. Without the sticky note, the scores disappear the moment the light goes off.

Reading a score file safely

The file does not exist on the very first run. Wrap the read in a try/except so the game starts cleanly instead of crashing:

def load_scores(filename):
    try:
        with open(filename, "r") as f:
            scores = [int(line.strip()) for line in f if line.strip()]
    except FileNotFoundError:
        scores = []
    return scores

Writing scores back — top 5 only

Sort the combined list in descending order and keep the first five entries:

def save_scores(filename, scores):
    top5 = sorted(scores, reverse=True)[:5]
    with open(filename, "w") as f:
        for score in top5:
            f.write(str(score) + "\n")

Why it matters

Every real game — from Candy Crush to Minecraft — saves progress to a file (or a server). Learning this pattern now means you can add persistence to any project: leaderboards, save states, settings, player names.

Priya wants to track her top-5 scores in a game she built in PZ-30. The file scores.txt lives in the same folder as the game. Each run loads the old scores, adds the new one, and saves the updated top-5. Save this as leaderboard.py:

# leaderboard.py — persistent top-5 leaderboard

import pgzrun

WIDTH = 480
HEIGHT = 400
TITLE = "Leaderboard Demo"
SCORES_FILE = "scores.txt"

score = 0
high_scores = []

def load_scores(filename):
    try:
        with open(filename, "r") as f:
            result = [int(line.strip()) for line in f if line.strip()]
    except FileNotFoundError:
        result = []
    return result

def save_scores(filename, scores):
    top5 = sorted(scores, reverse=True)[:5]
    with open(filename, "w") as f:
        for s in top5:
            f.write(str(s) + "\n")

def draw():
    screen.fill("black")
    screen.draw.text("Top 5 Scores", topleft=(20, 20), fontsize=32, color="gold")
    for i, s in enumerate(high_scores):
        screen.draw.text(
            f"{i + 1}.  {s}",
            topleft=(20, 70 + i * 40),
            fontsize=28,
            color="white",
        )
    screen.draw.text(
        f"Current: {score}  (SPACE = +10, S = save)",
        topleft=(20, 340),
        fontsize=20,
        color="cyan",
    )

def on_key_down(key):
    global score, high_scores
    if key == keys.SPACE:
        score += 10
    if key == keys.S:
        high_scores = load_scores(SCORES_FILE)
        high_scores.append(score)
        save_scores(SCORES_FILE, high_scores)
        high_scores = load_scores(SCORES_FILE)
        score = 0

high_scores = load_scores(SCORES_FILE)
pgzrun.go()

Press SPACE several times to build up a score, then S to save it. Close and reopen the game — your score is still there.

You now save scores between game sessions with two small helper functions. load_scores wraps the read in try/except FileNotFoundError so the first run never crashes. save_scores sorts the combined list, slices the top 5, and overwrites the file with open("w"). Call them at game-over and at start-up, and the leaderboard is persistent.