Functions

A function is a named block of code that performs a task. The code does not run when it is defined — it runs only when something calls the function by name. You can call the same function many times, each time with different inputs, and the same logic runs each time.

Three reasons to write functions, all of which Cambridge expects you to give:

• Reuse. Write the code once, use it many times. No copy-and-paste.
• Readability. A line like total = Sum(marks) is easier to read than 30 lines of looping and adding.
• Debugging and testing. A function is a small, self-contained unit — test it with a few inputs, prove it works, then trust it everywhere.

Paper 4 questions usually start with "Write a function…" or "Write a procedure…". If your function header is wrong, you lose marks before the examiner even reads the body.

# def + name + () + colon, body indented
def greet():
    print("Hello!")

greet()  # this is the CALL — only now does "Hello!" appear

PROCEDURE Greet()
    OUTPUT "Hello!"
ENDPROCEDURE

CALL Greet()

A function with no inputs is rarely useful — it always does exactly the same thing. The point of a function is that you can give it different inputs and get different behaviour out. The words parameter and argument are not interchangeable.

# One parameter
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # arg "Alice" -> param name
greet("Bob")    # same function, different arg

# Two parameters
def add_numbers(a, b):
    print(f"The sum is: {a + b}")

add_numbers(3, 5)  # a=3, b=5 -> The sum is: 8

PROCEDURE Greet(name : STRING)
    OUTPUT "Hello, ", name, "!"
ENDPROCEDURE

CALL Greet("Alice")
CALL Greet("Bob")

// Default is pass-by-value: the
// function receives a COPY of the
// argument.

Printing a result inside a function is a dead-end — once it is printed, you cannot use it again. Returning a result hands it back to the caller, who can store it in a variable, add it to other values, or pass it to another function. Cambridge mark schemes for "Write a function…" questions almost always require a RETURN — printing instead is a guaranteed mark loss.

def square(num):
    return num * num

result = square(4)       # result is 16
print(result)            # 16
print(square(5) + 1)     # 26 — used in an expression

FUNCTION Square(num : INTEGER) RETURNS INTEGER
    RETURN num * num
ENDFUNCTION

DECLARE result : INTEGER
result <- Square(4)
OUTPUT result  // 16

Worked example — pseudocode Max function

Task: Write a Cambridge pseudocode function Max that takes two integer parameters and returns the larger of the two. [4 marks]

FUNCTION Max(Number1 : INTEGER, Number2 : INTEGER) RETURNS INTEGER
    IF Number1 > Number2 THEN
        RETURN Number1
    ELSE
        RETURN Number2
    ENDIF
ENDFUNCTION

OUTPUT "Penalty Fine = ", Max(10, Distance * 2)

Python does not distinguish — every named block is just a function, and a function with no return simply returns None. Cambridge pseudocode does distinguish, and the question wording will tell you which one to write.

Worked example — choose procedure or function

Decide whether each task is better solved with a procedure or a function:

• Print a banner → Procedure. An action (output) with nothing to send back.
• Take a number and return its square → Function. Computes a single value the caller will use.
• Swap two variables → Procedure (with BYREF parameters). A swap changes two values; a function can only return one.
• Validate an email and return true/false → Function. Returns a single Boolean the caller uses in a condition.

This is the standard Paper 4 "extend the existing program" question type — you are given a small system and must add functions. A bank account simulator with a balance and three operations:

• deposit(amount) — add amount to balance and print the new balance
• withdraw(amount) — subtract if enough funds; otherwise print an error
• checkBalance() — print the current balance

Python version (uses global — covered on the next page)

balance = 1000  # global

def deposit(amount):
    global balance
    balance = balance + amount
    print(f"Deposited {amount}. New balance: {balance}")

def withdraw(amount):
    global balance
    if amount <= balance:
        balance = balance - amount
        print(f"Withdrew {amount}. New balance: {balance}")
    else:
        print("Insufficient funds.")

def checkBalance():
    print(f"Current balance: {balance}")

# Test
deposit(500)      # Deposited 500. New balance: 1500
withdraw(200)     # Withdrew 200. New balance: 1300
checkBalance()    # Current balance: 1300
withdraw(5000)    # Insufficient funds.

Fifteen exam-style function-writing tasks. Each shows only the question — click Hint for the thought process, or Help for the worked solution. Try each one yourself before revealing.