Chapter 6: Functions

How Functions Work

The anatomy of a function

Every function definition has the same structure:

def say_hello(name):
    message = f"Hello, {name}! Welcome."
    print(message)

say_hello("Priya")

• def — the keyword that tells Python you are defining a function
• say_hello — the function name (you choose this; use snake_case)
• (name) — the parentheses contain any parameters the function needs
• : — the colon marks the start of the function body
• The indented lines underneath are the body — the code that runs when the function is called

Parameters vs arguments

These two words are often mixed up, but there is a simple difference:

Think of the parameter as a label on an empty box. The argument is what you put inside that box when you use the function.

return vs print

This is one of the most important distinctions to understand:

# Compare return vs print
def add_return(a, b):
    return a + b

def add_print(a, b):
    print(a + b)

result1 = add_return(3, 4)
result2 = add_print(3, 4)

print(f"result1 = {result1}")
print(f"result2 = {result2}")

Procedures vs Functions — a GCSE distinction

In your GCSE exam, you need to know the difference between a function and a procedure. This catches many students out, so pay close attention:

In Python, both functions and procedures are created with def. Python does not have a separate keyword for procedures. However, in the exam, if a subroutine does not return a value, you should call it a procedure. If it does return a value, call it a function.

# This is a PROCEDURE - it does something but returns nothing
def display_welcome(name):
    print(f"Welcome, {name}!")
    print("Enjoy your visit.")

# This is a FUNCTION - it returns a value
def calculate_area(length, width):
    return length * width

# Procedure - just displays output
display_welcome("Priya")

# Function - we can store and use the result
area = calculate_area(5, 3)
print(f"The area is {area} square units")

Why functions matter

• Reusability — Write code once, use it as many times as you need
• Readability — A well-named function makes your program easier to understand
• Organisation — Break a big problem into smaller, manageable pieces
• Testing — Smaller blocks of code are easier to check and fix
• Decomposition — This is a key computational thinking skill tested in your GCSE

# This does NOTHING visible - the function is defined but never called
def say_goodbye():
    print("Goodbye!")

# Uncomment the line below to actually run the function:
# say_goodbye()

Scope — where variables live

Variables created inside a function only exist inside that function. This is called local scope. Variables created outside any function are in the global scope and can be seen everywhere.

def my_function():
    secret = "I only exist inside the function"
    print(secret)

my_function()

# This next line will cause an error - try it!
# print(secret)

Here is a more detailed example showing how local and global scope interact:

# Global variable - accessible everywhere
school_name = "Greenfield Academy"

def print_student_info(student):
    # Local variable - only exists inside this function
    message = f"{student} attends {school_name}"
    print(message)

print_student_info("Amara")
print_student_info("James")

# We can access school_name here (it is global)
print(f"School: {school_name}")

# But we CANNOT access 'message' here (it is local)
# Uncomment the next line to see the error:
# print(message)

Common Mistakes

Watch out for these pitfalls. Every one of them trips up beginners (and even experienced programmers sometimes!):

Building a Password Strength Checker

Let us work through a complete example step by step. We will write a function that checks how strong a password is — this is the kind of thing you see on websites every day when you create an account.

The Problem

Write a function called check_password_strength that takes a password string and returns a strength rating: "Weak", "Medium", or "Strong". The rules are:

• The password must be at least 8 characters long
• It should contain at least one uppercase letter
• It should contain at least one lowercase letter
• It should contain at least one digit

Scoring: each rule the password passes earns one point. 0–1 points = “Weak”, 2–3 points = “Medium”, 4 points = “Strong”.

Step 1: Plan the logic

Before writing any code, let us plan:

1. Take the password as a parameter
2. Start a score counter at 0
3. Check each rule — if the rule is met, add 1 to the score
4. Based on the score, decide the rating
5. Return the rating

Step 2: Write the code

For the character checks, we loop through each character and use Python’s built-in string methods: .isupper(), .islower(), and .isdigit().

def check_password_strength(password):
    score = 0

    # Rule 1: At least 8 characters long
    if len(password) >= 8:
        score = score + 1

    # Rule 2: Contains at least one uppercase letter
    has_upper = False
    for char in password:
        if char.isupper():
            has_upper = True
    if has_upper:
        score = score + 1

    # Rule 3: Contains at least one lowercase letter
    has_lower = False
    for char in password:
        if char.islower():
            has_lower = True
    if has_lower:
        score = score + 1

    # Rule 4: Contains at least one digit
    has_digit = False
    for char in password:
        if char.isdigit():
            has_digit = True
    if has_digit:
        score = score + 1

    # Decide the rating based on the score
    if score <= 1:
        return "Weak"
    elif score <= 3:
        return "Medium"
    else:
        return "Strong"


# Test with different passwords
test_passwords = ["cat", "password", "Hello123", "MyP4ssw0rd"]

for pwd in test_passwords:
    result = check_password_strength(pwd)
    print(f"'{pwd}' -> {result}")

Step 3: Trace through an example

Let us trace what happens when we call check_password_strength("Hello123"):

1. score starts at 0
2. Length check: len("Hello123") is 8, which is ≥ 8, so score becomes 1
3. Uppercase check: "H" is uppercase, so has_upper = True, score becomes 2
4. Lowercase check: "e", "l", "l", "o" are lowercase, so has_lower = True, score becomes 3
5. Digit check: "1", "2", "3" are digits, so has_digit = True, score becomes 4
6. Score is 4, so the function returns "Strong"