Functions Practice — Math Toolbox

By the end of this lesson you can:

• Write small returning functions for square, cube, average and is_even from a blank file.
• Use boolean-returning functions like is_even(n) directly inside an if condition.
• Compose function calls — pass the return of one into another — to answer real questions in one expression.

Without typing, predict what each line prints:

def square(n):
    return n * n

print(square(5))
print(square(square(2)))
print(square(3) + square(4))

25
16
25

Every function we write today fits this shape

def name(parameters):
    # do the maths
    return answer

Three lines if it's really small. No print inside — the function's job is to compute and return. The main program decides what to do with the answer.

Boolean returns · the is_X pattern

Functions whose name starts with is_ almost always return True or False. They're built to drop straight into an if:

def is_even(n):
    return n % 2 == 0

if is_even(10):
    print("even")
else:
    print("odd")

Read the if line out loud — "if is even ten". Almost English. That's why this naming convention exists.

Why n % 2 == 0 works

From PY-L1-04: % gives the remainder after division. Even numbers divided by 2 have remainder 0, odd numbers have remainder 1. So n % 2 == 0 is a boolean expression that's already True or False — and we can return it directly. No need to write:

# verbose — don't do this
def is_even(n):
    if n % 2 == 0:
        return True
    else:
        return False

# concise — do this
def is_even(n):
    return n % 2 == 0

The expression is the boolean. You don't wrap it in an if.

Composing functions · cube as squared-times-itself

Sometimes one function can use another. cube(n) is just square(n) * n:

def square(n):
    return n * n

def cube(n):
    return square(n) * n   # reuses square — no duplicated maths

print(cube(4))   # → 64

If we ever rewrote square (maybe to handle weird inputs), cube would automatically benefit. That's the "build with what you've built" payoff.

Step 1 · Four small tools, one file

Save as math_toolbox.py:

# math_toolbox.py — four tools

def square(n):
    return n * n

def cube(n):
    return n * n * n

def average(a, b):
    return (a + b) / 2

def is_even(n):
    return n % 2 == 0

Four functions, twelve lines including blank lines. None of them prints anything — they all compute and return.

Step 2 · Try each one once

print(square(6))           # 36
print(cube(4))             # 64
print(average(10, 30))     # 20.0
print(is_even(7))          # False

Step 3 · Combine them

Real questions usually need more than one tool. Here are three little puzzles, each solved by combining functions:

# Q1: what's the average of 3 squared and 4 squared?
print(average(square(3), square(4)))     # average(9, 16) = 12.5

# Q2: is the cube of 5 even?
print(is_even(cube(5)))                  # cube(5) = 125 → False

# Q3: what's the average of two numbers, but only if both are even?
a = 10
b = 20
if is_even(a) and is_even(b):
    print("Even pair, avg =", average(a, b))
else:
    print("At least one is odd.")

Notice how each tool slots into the other. The function names tell the story; the bodies are tiny and out of the way.

Step 4 · A mini report driven by the toolbox

Code

# math_toolbox.py — full version with a tiny report

def square(n):
    return n * n

def cube(n):
    return n * n * n

def average(a, b):
    return (a + b) / 2

def is_even(n):
    return n % 2 == 0

# main program — explore numbers 1..6
print("n | square | cube | even?")
print("-" * 30)
for n in range(1, 7):
    print(" ", n, "  ", square(n), "    ", cube(n), "  ", is_even(n))

print()
print("Average of squares 1..6 first and last:", average(square(1), square(6)))

Sample run

n | square | cube | even?
------------------------------
  1    1      1    False
  2    4      8    True
  3    9      27    False
  4    16      64    True
  5    25      125    False
  6    36      216    True

Average of squares 1..6 first and last: 18.5

Three tasks. Every function must return — no print inside the function body.

def triple(n):
    return n * 3

print(triple(4))    # 12
print(triple(11))   # 33
print(triple(100))  # 300

def is_positive(n):
    return n > 0

for n in [5, 0, -3]:
    if is_positive(n):
        print(n, ": positive")
    else:
        print(n, ": not positive")

def average3(a, b, c):
    return (a + b + c) / 3

s1 = float(input("Score 1: "))
s2 = float(input("Score 2: "))
s3 = float(input("Score 3: "))

avg = average3(s1, s2, s3)
print("Average:", round(avg, 1))

Today wasn't about learning new keywords — it was about feeling how the keywords fit together. Four tiny returning functions, then a main program that chains them, slots them into if conditions, and composes them inside one expression. That stack — small tools at the top, a readable script at the bottom — is the shape every real Python program takes. Boolean-returning functions named is_X are especially nice because they drop straight into conditions and make your code read like English. Next lesson we'll mix functions with lists from PY-L1-15..L1-18.