Game — High-Score Keeper (File-Backed)

By the end of this lesson you can:

• Pick a simple text-line file format for tabular data — "name,score" per line.
• Parse the file into a list of dicts (or tuples) at game start.
• Update the in-memory list after each game, sort, trim, then write the whole thing back.
• Display a top-N leaderboard with f-string width specifiers.

Before writing any code, decide what scores.txt should look like. The simplest format that works for tabular data is one record per line, with a fixed separator:

Aisyah,95
Wei Jie,87
Priya,92
Iman,70
Aizat,81

One line, one record. A comma between name and score. No header line. Easy to read with for line in f: and .split(","); easy to write back with f.write.

1 · load_scores()

Open the file in default read mode, walk it line by line, split each line, build a list of dicts. Handle "no file yet" with try/except.

def load_scores():
    scores = []
    try:
        with open("scores.txt", encoding="utf-8") as f:
            for line in f:
                line = line.strip()
                if line == "":
                    continue                # skip blank lines
                name, raw = line.split(",")
                scores.append({"name": name.strip(),
                               "score": int(raw.strip())})
    except FileNotFoundError:
        pass                                # no scores yet — empty list
    return scores

The try/except turns "file doesn't exist" from a crash into "empty list". The shape is one dict per record — matches PY-L2-11 perfectly.

2 · save_scores(scores)

Open in "w" mode (we're replacing the whole file). Loop the list, write one line per record. Easy and reliable.

def save_scores(scores):
    with open("scores.txt", "w", encoding="utf-8") as f:
        for s in scores:
            f.write(f"{s['name']},{s['score']}\n")

Use "w" not "a". Replacing the whole file every save means we don't accumulate duplicates as the table changes — no bookkeeping needed.

3 · add_score(scores, name, score)

Append, sort by score descending, trim to top-N, save.

def add_score(scores, name, score, top_n=5):
    scores.append({"name": name, "score": score})
    scores.sort(key=lambda s: s["score"], reverse=True)
    del scores[top_n:]                       # keep only the first N
    save_scores(scores)
    return scores

Four lines do the whole bookkeeping. scores.sort(key=...) sorts in place by the score (PY-L2-04 and -11 lambdas). del scores[top_n:] trims everything past the top N — list slicing on the left side of del.

4 · show_top(scores, n=5)

Print the top-N as a banner using PY-L2-16 width specifiers.

def show_top(scores, n=5):
    print("=== HIGH SCORES ===")
    print(f"{'Rank':<6}{'Name':<14}{'Score':>6}")
    print("-" * 26)
    for rank, s in enumerate(scores[:n], start=1):
        print(f"{rank:<6}{s['name']:<14}{s['score']:>6}")
    print("-" * 26)

The full life-cycle

At start          scores = load_scores()
After each game   scores = add_score(scores, name, score)
On demand         show_top(scores)

That's the whole save system. Three function calls — load, add, show.

Save the whole thing as hi_score.py:

Code

# hi_score.py — file-backed high-score table

FILE = "scores.txt"

def load_scores():
    scores = []
    try:
        with open(FILE, encoding="utf-8") as f:
            for line in f:
                line = line.strip()
                if line == "":
                    continue
                name, raw = line.split(",")
                scores.append({"name": name.strip(),
                               "score": int(raw.strip())})
    except FileNotFoundError:
        pass
    return scores

def save_scores(scores):
    with open(FILE, "w", encoding="utf-8") as f:
        for s in scores:
            f.write(f"{s['name']},{s['score']}\n")

def add_score(scores, name, score, top_n=5):
    scores.append({"name": name, "score": score})
    scores.sort(key=lambda s: s["score"], reverse=True)
    del scores[top_n:]
    save_scores(scores)
    return scores

def show_top(scores, n=5):
    if len(scores) == 0:
        print("(no scores yet — be the first!)")
        return
    print()
    print("=== HIGH SCORES ===")
    print(f"{'Rank':<6}{'Name':<14}{'Score':>6}")
    print("-" * 26)
    for rank, s in enumerate(scores[:n], start=1):
        print(f"{rank:<6}{s['name']:<14}{s['score']:>6}")
    print("-" * 26)

def made_top_5(scores, score):
    if len(scores) < 5:
        return True
    return score > scores[-1]["score"]

# --- demo: pretend we just played 3 games ---

scores = load_scores()
show_top(scores)

import random
for game in range(3):
    name  = input("Player name: ")
    score = random.randint(50, 100)
    print(f"You scored: {score}")
    if made_top_5(scores, score):
        print("🏆  Top-5!")
    scores = add_score(scores, name, score)

show_top(scores)

Sample run (your scores will vary)

(no scores yet — be the first!)
Player name: Aisyah
You scored: 87
🏆  Top-5!
Player name: Wei Jie
You scored: 73
🏆  Top-5!
Player name: Priya
You scored: 95
🏆  Top-5!

=== HIGH SCORES ===
Rank  Name          Score
--------------------------
1     Priya            95
2     Aisyah           87
3     Wei Jie          73
--------------------------

Quit the program now. Run it again. The three scores are still there — and any new ones get sorted into the table:

=== HIGH SCORES ===
Rank  Name          Score
--------------------------
1     Priya            95
2     Aisyah           87
3     Wei Jie          73
--------------------------
Player name: Iman
You scored: 100
🏆  Top-5!
...

A file-backed high-score table is three little functions. load_scores opens the file (or returns an empty list if missing) and parses lines into a list of dicts. save_scores writes the list back in "w" mode — fresh every save. add_score appends, sorts in place by score, trims to top-N, and saves. show_top prints the top-N as a tidy banner with width specifiers. Tomorrow we'll use this same shape for the Wordle word bank — but with a much bigger file.