Python functions exercises — grades, a mini bank and dice with statistics (and the return that gave up on the first roll)

While preparing the dice game for this article, I wanted to add a message at the end: “has any double come up in the game?”. I wrote a has_double function in a minute, tried it with the sample game… and it said False. With a 6 and a 6 on the third roll, right in front of me. I checked the condition, checked the data, added prints… and the bug was a single misplaced word: a return False inside an else, which made the function give up on the first roll that wasn’t a double. You’ll find it exactly as it was in the “What’s wrong here?” section, because it’s one of those errors that never shows a message.

You’ve seen the Python functions theory and the three programs in the practice. Now it’s your turn: four exercises across three levels (a grade converter, a report, a mini bank and a dice game with statistics), three snippets with a hidden bug and, at the end, a cheat sheet to keep everything at hand. The thread that ties them together is the quietest error in the topic: print where return was needed, which leaves you working with None without realising.

How to use this article

1. Read the brief and the expected output. Your program must produce exactly that output (in the two random ones, thanks to a fixed seed).
2. Try to solve it in VS Code or Thonny without looking at anything else. If you’ve been stuck for more than 10 minutes, read the hint.
3. Before looking at the solutions, do the “What’s wrong here?” section: predict what comes out and check.
4. Compare with the commented solution. Working isn’t enough: look at why it’s built that way and which error the obvious alternative would cause.

None of them uses input(): the data is written in the program, as in the practice. That way you can compare your output with the article’s line by line.

Basic level

Exercise 1: grade converter between systems

Write four functions that convert grades between three systems: the Spanish one (0-10), the US one (0-100) and letters (A, B, C, D, F):

• spanish_to_us(grade): multiplies by 10.
• us_to_spanish(grade): divides by 10.
• spanish_to_letter(grade): from 9 to 10, A; from 7 to under 9, B; from 5 to under 7, C; from 3 to under 5, D; below 3, F.
• letter_to_spanish(letter): A = 9.5, B = 7.5, C = 5.5, D = 3.5, F = 1.5 (the middle of each band), in upper or lower case, and None if the letter doesn’t exist.

A fifth function, show_conversions(grade), shows the three versions of a grade. The program checks that the grade is between 0 and 10, shows it and ends with two conversions back. With grade = 7.5, the output must be:

=== GRADE CONVERTER ===
--- Conversions ---
Spanish system: 7.5
US system: 75.0
Letter system: B
Back: 75 → 7.5 · b → 7.5

Exercise 2: grade report generator

Using two functions from the previous exercise, write a program that receives the grades of four subjects as a list of (name, grade) pairs and generates a report: each subject in the three systems, the average with its letter and the highest and lowest grade with their subject.

subjects = [("FP1", 8.5), ("Statistics", 7.0), ("Maths", 6.5), ("Databases", 9.0)]

Expected output:

=== GRADE REPORT ===
--- Full report ---
FP1 → 8.5 | 85.0 | B
Statistics → 7.0 | 70.0 | B
Maths → 6.5 | 65.0 | C
Databases → 9.0 | 90.0 | A
Average: 7.75 → B
Highest: 9.0 (Databases)
Lowest: 6.5 (Maths)

Intermediate level

Exercise 3: mini bank with functions

Simulate a bank account with functions: check_balance(balance), deposit(balance, amount), withdraw(balance, amount) and show_history(history, balance). The account starts at 1000.0 € and, in this order, there’s a deposit of 500, a withdrawal of 200, a withdrawal of 2000 (not enough money) and a deposit of −50 (invalid amount). The history only records the transactions that worked.

Expected output:

=== SERGIO LEARNS BANK ===
Current balance: 1000.0 €
✓ Deposit made: +500 €
✓ Withdrawal made: -200 €
Error: insufficient balance (you have 1300.0 €)
Error: the amount must be positive
--- Transaction history ---
Opening balance: +1000.0 €
Deposit: +500 €
Withdrawal: -200 €
──────────────────────────────
Current balance: 1300.0 €

Final challenge

Exercise 4: dice game with statistics

Simulate six rolls of two dice. Each roll is shown with its sum and a notice if it’s a double. At the end, the statistics: total rolls, total sum, average, highest and lowest (with the roll where they first came up), number of doubles with its percentage and a distribution with █ bars, from the lowest sum to the highest, saying “1 time” or “2 times” as appropriate. Put random.seed(37) at the start so your dice come out like these:

=== DICE GAME ===
Roll 1: 🎲 6 + 🎲 5 = 11
Roll 2: 🎲 1 + 🎲 5 = 6
Roll 3: 🎲 6 + 🎲 6 = 12 ← Double!
Roll 4: 🎲 6 + 🎲 5 = 11
Roll 5: 🎲 1 + 🎲 6 = 7
Roll 6: 🎲 3 + 🎲 4 = 7
--- Statistics ---
Total rolls: 6
Total sum: 54
Average per roll: 9.0
Highest rolled: 12 (roll 3)
Lowest rolled: 6 (roll 2)
Doubles rolled: 1 (16.7 %)
Distribution of results:
   6: █ (1 time)
   7: ██ (2 times)
  11: ██ (2 times)
  12: █ (1 time)

What’s wrong here?

Three snippets that look right. For each one, predict what comes out before reading the explanation.

Snippet 1: the grade you see but don’t have

def spanish_to_us(grade):
    print(grade * 10)                # shows 75.0... and returns None


us_grade = spanish_to_us(7.5)
print("With 5 bonus points:", us_grade + 5)

What do you think comes out?

This:

75.0
Traceback (most recent call last):
  File "print_return.py", line 6, in <module>
    print("With 5 bonus points:", us_grade + 5)
                                  ~~~~~~~~~^~~
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

The 75.0 appears, so the conversion “works”. But spanish_to_us has no return, so it returns None, and None + 5 is impossible: unsupported operand type(s) for +: 'NoneType' and 'int'. When you see NoneType in an error, the first thing to think is “some function has no return“.

Fixed, with return:

def spanish_to_us(grade):
    return grade * 10                # returns the number to the caller


us_grade = spanish_to_us(7.5)
print("With 5 bonus points:", us_grade + 5)

With 5 bonus points: 80.0

7.5 × 10 = 75.0 and 75.0 + 5 = 80.0. Notice that now the 75.0 does not appear on its own: nobody prints it, it’s just used.

Snippet 2: the balance nobody can find

balance = 1000.0


def deposit(amount):
    balance = balance + amount        # the outer one? Python doesn't see it that way
    return balance


print(deposit(500))

What do you think comes out? 1500.0?

This:

Traceback (most recent call last):
  File "global_balance.py", line 9, in <module>
    print(deposit(500))
          ~~~~~~~^^^^^
  File "global_balance.py", line 5, in deposit
    balance = balance + amount        # the outer one? Python doesn't see it that way
              ^^^^^^^
UnboundLocalError: cannot access local variable 'balance' where it is not associated with a value

Since deposit assigns balance = …, Python decides balance is a local variable of the function, in its whole body. When it calculates balance + amount it tries to read that local, which has no value yet: UnboundLocalError. The global 1000.0 exists, but the function no longer looks at it.

The fix isn’t global balance, but making the data go in and out in plain sight:

def deposit(balance, amount):
    return balance + amount           # goes in as a parameter, comes out through return


balance = 1000.0
balance = deposit(balance, 500)       # and it is stored outside, in plain sight
print(balance)

1500.0

Snippet 3: the return that gave up

The one from the story. The game has a double on the third roll:

def has_double(rolls):
    """Has any double come up in the game?"""
    for d1, d2 in rolls:
        if d1 == d2:
            return True
        else:
            return False            # ← watch this return


rolls = [(6, 5), (1, 5), (6, 6)]
print(has_double(rolls))

What do you think comes out?

This:

False

On the first pass, the roll is (6, 5): not a double, so it goes into the else and does return False. And return doesn’t end the pass, it ends the function. The rolls (1, 5) and (6, 6) are never checked. The diagram compares both versions with the same game:

Fixed: the return False leaves the loop and the else:

def has_double(rolls):
    """Has any double come up in the game?"""
    for d1, d2 in rolls:
        if d1 == d2:
            return True             # as soon as one appears, we know the answer
    return False                    # only after checking ALL the rolls


rolls = [(6, 5), (1, 5), (6, 6)]
print(has_double(rolls))

True

Commented solutions

Solution to exercise 1

# Basic level · Exercise 1: grade converter between systems
def spanish_to_us(grade):
    """0-10 → 0-100."""
    return round(grade * 10, 1)


def us_to_spanish(grade):
    """0-100 → 0-10."""
    return round(grade / 10, 1)


def spanish_to_letter(grade):
    """9-10 A · 7-8.9 B · 5-6.9 C · 3-4.9 D · below 3 F."""
    if grade >= 9:
        return "A"
    elif grade >= 7:
        return "B"
    elif grade >= 5:
        return "C"
    elif grade >= 3:
        return "D"
    return "F"


def letter_to_spanish(letter):
    """Each letter is worth the middle of its band; None if the letter doesn't exist."""
    letter = letter.upper()
    if letter == "A":
        return 9.5
    if letter == "B":
        return 7.5
    if letter == "C":
        return 5.5
    if letter == "D":
        return 3.5
    if letter == "F":
        return 1.5
    return None


def show_conversions(grade):
    """The only one that prints: takes the grade and shows the three versions."""
    print("--- Conversions ---")
    print("Spanish system:", grade)
    print("US system:", spanish_to_us(grade))
    print("Letter system:", spanish_to_letter(grade))


print("=== GRADE CONVERTER ===")
grade = 7.5                             # the grade that used to be asked with input()
if grade < 0 or grade > 10:
    print("Error: the grade must be between 0 and 10")
else:
    show_conversions(grade)
print("Back: 75 →", us_to_spanish(75), "· b →", letter_to_spanish("b"))

Output:

=== GRADE CONVERTER ===
--- Conversions ---
Spanish system: 7.5
US system: 75.0
Letter system: B
Back: 75 → 7.5 · b → 7.5

Why it’s built this way:

• Four functions that return and one that prints. The conversions can be reused in exercise 2 precisely because they print nothing.
• The bands with >= in descending order. spanish_to_letter(7.5): 7.5 >= 9 is false, 7.5 >= 7 is true → "B". Since the elifs are checked top to bottom, each one only needs the lower limit. If you wrote them bottom up (grade >= 3 first), a 9.5 would come out as D.
• letter.upper() before comparing, so "b" and "B" are worth the same; if the letter doesn’t exist, it reaches the final return None.
• Plain ASCII names. In the Spanish version of this article the functions are called espanola_… and not española_…: Python 3 accepts the ñ in names, but a classmate may not be able to type it and some tools complain. It’s a healthy habit.
• The range check, outside the conversions. The conversions don’t decide what to do with an impossible grade; the main program does.

Sums: 7.5 × 10 = 75.0; 75 / 10 = 7.5; "b" → "B" → 7.5.

Solution to exercise 2

# Basic level · Exercise 2: grade report (reuses two functions from exercise 1)
def spanish_to_us(grade):
    return round(grade * 10, 1)


def spanish_to_letter(grade):
    if grade >= 9:
        return "A"
    elif grade >= 7:
        return "B"
    elif grade >= 5:
        return "C"
    elif grade >= 3:
        return "D"
    return "F"


def report_line(name, grade):
    """RETURNS the line for one subject (it doesn't print it: that way it can be reused)."""
    return f"{name} → {grade} | {spanish_to_us(grade)} | {spanish_to_letter(grade)}"


def generate_report(subjects):
    print("--- Full report ---")
    total_sum = 0
    how_many = 0
    grade_max, name_max = -1, ""     # we start below any possible grade...
    grade_min, name_min = 11, ""     # ...and above, so the first one already wins
    for name, grade in subjects:
        print(report_line(name, grade))
        total_sum += grade
        how_many += 1
        if grade > grade_max:        # > and not >=: on a tie the first one stays
            grade_max, name_max = grade, name
        if grade < grade_min:
            grade_min, name_min = grade, name
    average = round(total_sum / how_many, 2)
    print("Average:", average, "→", spanish_to_letter(average))
    print(f"Highest: {grade_max} ({name_max})")
    print(f"Lowest: {grade_min} ({name_min})")


print("=== GRADE REPORT ===")
generate_report([("FP1", 8.5), ("Statistics", 7.0), ("Maths", 6.5), ("Databases", 9.0)])

Output:

=== GRADE REPORT ===
--- Full report ---
FP1 → 8.5 | 85.0 | B
Statistics → 7.0 | 70.0 | B
Maths → 6.5 | 65.0 | C
Databases → 9.0 | 90.0 | A
Average: 7.75 → B
Highest: 9.0 (Databases)
Lowest: 6.5 (Maths)

Why it’s built this way:

• report_line returns the text. generate_report prints it, but the same function would work for writing the report to a file.
• The two functions from exercise 1, copied. They’re repeated here because each exercise is a separate file. Copying functions between files is exactly what the next topic solves, Python modules: you’d write from grade_converter import spanish_to_letter and that’s it.
• Impossible values to start with. grade_max = -1 guarantees that the first grade (anything from 0 to 10) is already higher; grade_min = 11, that it’s lower.
• > and not >=. On a tie, the first subject that reached that grade stays.
• for name, grade in subjects unpacks each pair into two variables, just like euros, cents = … in the theory.

Trace of the highest and lowest:

Average: 31.0 / 4 = 7.75, which is between 7 and 9 → B.

Solution to exercise 3

# Intermediate level · Exercise 3: mini bank with functions
def check_balance(balance):
    print(f"Current balance: {balance} €")


def deposit(balance, amount):
    """Returns the NEW balance. If the amount is not valid, returns the same balance."""
    if amount <= 0:
        print("Error: the amount must be positive")
        return balance
    print(f"✓ Deposit made: +{amount} €")
    return round(balance + amount, 2)      # the key return: without it, the balance never changes


def withdraw(balance, amount):
    """Returns the new balance, or the same one if there isn't enough money."""
    if amount <= 0:
        print("Error: the amount must be positive")
        return balance
    if amount > balance:
        print(f"Error: insufficient balance (you have {balance} €)")
        return balance
    print(f"✓ Withdrawal made: -{amount} €")
    return round(balance - amount, 2)


def record(history, text, balance_before, balance_after):
    """Records the transaction only if the balance changed (if there was an error, it doesn't)."""
    if balance_after != balance_before:
        history.append(text)


def show_history(history, balance):
    print("--- Transaction history ---")
    for transaction in history:
        print(transaction)
    print("─" * 30)
    check_balance(balance)


print("=== SERGIO LEARNS BANK ===")
balance = 1000.0
history = [f"Opening balance: +{balance} €"]
check_balance(balance)

before = balance
balance = deposit(balance, 500)                 # we store what the function RETURNS
record(history, "Deposit: +500 €", before, balance)

before = balance
balance = withdraw(balance, 200)
record(history, "Withdrawal: -200 €", before, balance)

before = balance
balance = withdraw(balance, 2000)               # there isn't that much: the balance doesn't change
record(history, "Withdrawal: -2000 €", before, balance)

before = balance
balance = deposit(balance, -50)                 # invalid amount
record(history, "Deposit: -50 €", before, balance)

show_history(history, balance)

Output:

=== SERGIO LEARNS BANK ===
Current balance: 1000.0 €
✓ Deposit made: +500 €
✓ Withdrawal made: -200 €
Error: insufficient balance (you have 1300.0 €)
Error: the amount must be positive
--- Transaction history ---
Opening balance: +1000.0 €
Deposit: +500 €
Withdrawal: -200 €
──────────────────────────────
Current balance: 1300.0 €

Why it’s built this way:

• The balance is never global for the functions. It goes in as a parameter and comes out through return, and the main program reassigns it: balance = deposit(balance, 500). It’s the fix from snippet 2 applied to a whole program.
• If something fails, the same balance comes back. That way the caller doesn’t have to tell cases apart: it always gets a valid balance.
• record compares before and after. If the balance didn’t change, the operation failed and isn’t recorded. With the withdrawal of 2000 and the deposit of −50, the history stays at three lines.
• The history is a list that record changes with append. Lists can be changed “from inside” by a function without returning them; numbers can’t. You’ll see it properly in the mutability topic; for now, notice that the balance (a number) needs the return and the history (a list) doesn’t.
• round(…, 2) in the operations, so a balance like 0.1 + 0.2 doesn’t end up with decimal tails.

The diagram follows the balance from function to function. Each violet pill is what comes out of a return and goes into the next call:

Sums: 1000.0 + 500 = 1500.0; 1500.0 − 200 = 1300.0; 2000 > 1300.0, so the withdrawal fails; −50 ≤ 0, so the deposit fails. Final balance: 1300.0 €.

Solution to exercise 4

# Challenge · Exercise 4: dice game with statistics
import random

random.seed(37)    # fixed seed so the output is always the same (remove it to play)


def roll_die():
    return random.randint(1, 6)          # return: sends the number back, doesn't print it


def roll_two_dice():
    return roll_die(), roll_die()        # two values at once (a tuple)


def is_double(die1, die2):
    return die1 == die2


def highest_and_position(sums):
    """Returns the highest value and the roll it came up on (the first one if repeated)."""
    best, position, i = 0, 0, 0
    for s in sums:
        i += 1
        if s > best:
            best, position = s, i
    return best, position


def lowest_and_position(sums):
    worst, position, i = 13, 0, 0        # 13: more than the highest possible sum (6 + 6)
    for s in sums:
        i += 1
        if s < worst:
            worst, position = s, i
    return worst, position


def times(n):
    """«1 time» or «2 times»: the plural is a decision too."""
    if n == 1:
        return "1 time"
    return f"{n} times"


def show_distribution(sums):
    print("Distribution of results:")
    for value in range(2, 13):           # every possible sum, already in order
        n = sums.count(value)            # how many times that value came up
        if n > 0:
            print(f"  {value:2d}: {'█' * n} ({times(n)})")


def play(rolls):
    print("=== DICE GAME ===")
    sums = []
    doubles = 0
    for i in range(1, rolls + 1):
        d1, d2 = roll_two_dice()         # we unpack the tuple
        total_sum = d1 + d2
        notice = ""
        if is_double(d1, d2):
            notice = " ← Double!"
            doubles += 1
        print(f"Roll {i}: 🎲 {d1} + 🎲 {d2} = {total_sum}{notice}")
        sums.append(total_sum)
    highest, roll_max = highest_and_position(sums)
    lowest, roll_min = lowest_and_position(sums)
    print("--- Statistics ---")
    print("Total rolls:", rolls)
    print("Total sum:", sum(sums))
    print("Average per roll:", round(sum(sums) / rolls, 2))
    print(f"Highest rolled: {highest} (roll {roll_max})")
    print(f"Lowest rolled: {lowest} (roll {roll_min})")
    print(f"Doubles rolled: {doubles} ({round(doubles / rolls * 100, 1)} %)")
    show_distribution(sums)


play(6)

Output:

=== DICE GAME ===
Roll 1: 🎲 6 + 🎲 5 = 11
Roll 2: 🎲 1 + 🎲 5 = 6
Roll 3: 🎲 6 + 🎲 6 = 12 ← Double!
Roll 4: 🎲 6 + 🎲 5 = 11
Roll 5: 🎲 1 + 🎲 6 = 7
Roll 6: 🎲 3 + 🎲 4 = 7
--- Statistics ---
Total rolls: 6
Total sum: 54
Average per roll: 9.0
Highest rolled: 12 (roll 3)
Lowest rolled: 6 (roll 2)
Doubles rolled: 1 (16.7 %)
Distribution of results:
   6: █ (1 time)
   7: ██ (2 times)
  11: ██ (2 times)
  12: █ (1 time)

Why it’s built this way:

• roll_die returns, it doesn’t print. If it printed, d1 + d2 would be None + None.
• roll_two_dice returns a tuple that is unpacked into d1, d2. One function, two values.
• highest_and_position and lowest_and_position return two things: the value and the roll. With > (and <) they keep the first time: 11 comes up on rolls 1 and 4, but the highest is the 12 on roll 3; and the lowest, the 6 on roll 2.
• range(2, 13) for the distribution. It goes through every possible sum already in order, so there’s nothing to sort; sums.count(value) says how many times it came up and the if n > 0 skips the ones that didn’t.
• times(n), a tiny function that avoids the “(2 time)” of the old version of this exercise.
• random.seed(37) so the output is always the same. Delete it to play for real.

Trace of the statistics:

Sum: 11 + 6 + 12 + 11 + 7 + 7 = 54; average 54 / 6 = 9.0; doubles 1 out of 6 = 16.7 %.

Exam-style quiz

Now test yourself as in the exam. The FP1 quizzes look like this: 15 questions in 20 minutes (16 in 30 in the Sequences one), almost all single choice (each wrong answer subtracts a third of what the question is worth) and many «what does this code print?», with the odd fill in the gaps, matching or true or false. Here are 13 original questions on functions. Answer without running anything, press Check and read the explanation for each one. These questions are also the question bank for the FP1 theory mock exam, which will mix them with those from the other topics.

def double_plus(x, y=1):
    return 2 * x + y

print(double_plus(4) + double_plus(3, 5))

def greet(name):
    print("Hello", name)

r = greet("Luis")
print(r)

def f(n):
    if n > 10:
        return "big"
    return "small"
    print("end")

print(f(15))

x = 5

def change():
    x = 99
    return x

change()
print(x)

def minmax(a, b):
    if a < b:
        return a, b
    return b, a

smallest, largest = minmax(8, 3)
print(largest - smallest)

def g(x):
    return x * 2

def h(x):
    return g(x) + 1

print(h(g(3)))

def count(n):
    c = 0
    while n > 0:
        n = n // 10
        c += 1
    return c

print(count(2026))

Visualise it with Python Tutor

Python Tutor is the best way to watch snippet 3’s bug live. Choose Python 3, paste this and step through with Next:

def has_double_wrong(rolls):
    for d1, d2 in rolls:
        if d1 == d2:
            return True
        else:
            return False


def has_double_right(rolls):
    for d1, d2 in rolls:
        if d1 == d2:
            return True
    return False


rolls = [(6, 5), (1, 5), (6, 6)]
print(has_double_wrong(rolls))
print(has_double_right(rolls))

Expected output:

False
True

What to watch step by step:

1. When entering has_double_wrong, the function’s box receives rolls as an arrow pointing to the same list in the Global frame: it isn’t copied.
2. On the first pass, d1 = 6 and d2 = 5. The arrow jumps to the else and, on the next step, Return value: False appears. The box disappears with the loop half done: the other two rolls were never checked.
3. In has_double_right, the first two passes do nothing (the condition is false and there’s no else) and the arrow goes back to the for.
4. On the third pass, d1 = 6 and d2 = 6: Return value: True. The return False line at the end never runs in this game.

Cheat sheet: Python functions

The essentials in 30 seconds: a function is defined with def name(parameters): and runs when you call it with name(arguments). return sends a value back and ends the function; without return, it returns None. print shows, return hands over. Parameters and variables inside are local: they’re born with the call and die when it ends. In through parameters, out through return.

Defining and calling:

Returning:

Exercise templates:

# Conversion: receive, calculate and RETURN (exercise 1)
def spanish_to_us(grade):
    return round(grade * 10, 1)

# The data goes in as a parameter and comes out through return (exercise 3)
balance = deposit(balance, 500)

# Highest with its position, starting from an impossible value (exercises 2 and 4)
def highest_and_position(sums):
    best, position, i = 0, 0, 0
    for s in sums:
        i += 1
        if s > best:
            best, position = s, i
    return best, position

# Search: return inside if found, after the loop if not (snippet 3)
def has_double(rolls):
    for d1, d2 in rolls:
        if d1 == d2:
            return True
    return False

Symptom and probable cause:

Before you hand it in, ask yourself:

1. Does every calculating function have a return, and do only the presentation ones print?
2. Do I store what functions return (balance = deposit(balance, 500)) instead of calling them on their own?
3. Do my searches put the “not there” after the loop and not inside it?
4. Is there a global variable that a function changes? If so, can I pass it in and return it?

If you’ve got this far with the four exercises solved, you have more than enough functions for the next step: keeping them in files of their own and using them from any program with Python modules.

Did this article help you? Here is how you can support SergioLearns →