Chapter 8 — Functions — The Basics

The why

Functions are the single most important abstraction in programming. They let you:

• Reuse code — write once, call many times
• Name behavior — calculate_tax(total) is clearer than 10 lines of math
• Hide complexity — callers don't need to know how the function works
• Test in isolation — functions are the unit of testing

Every program you'll write from here on uses functions. Master them now, and everything else gets easier.

Core concepts: Function patterns

Functions are reusable blocks of code. Click each pattern to see how to use it:

# Define a function
def greet(name):
    print(f"Hello, {name}!")
 
# Call it
greet("Alice")  # Hello, Alice!
greet("Bob")    # Hello, Bob!
 
# Default parameters
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")
 
greet("Alice")                # Hello, Alice!
greet("Bob", "Good morning")  # Good morning, Bob!

# WRONG: returns None
def add_bad(a, b):
    print(a + b)
 
result = add_bad(3, 5)
print(result * 2)  # TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'
 
# RIGHT: returns value

# Local variable
def my_func():
    x = 10  # Local
    print(x)
 
my_func()   # 10
print(x)    # NameError: name 'x' is not defined
 
# Global variable
x = 10

def calculate_tax(amount, rate=0.1):
    """
    Calculate tax on a given amount.
    
    Args:
        amount: The pre-tax amount (float or int)
        rate: The tax rate as a decimal (default 0.1 = 10%)
    
    Returns:
        The tax amount (float)
    
    Example:
        >>> calculate_tax(100, 0.1)
        10.0
    """
    return amount * rate
 
# Access docstring

Defining and calling functions

Define a function with def:

def greet():
    print("Hello!")

Call it by name:

greet()  # Hello!
greet()  # Hello! (reusable)

Key facts:

• The function body is indented (4 spaces).
• The function doesn't run until you call it.
• You can call a function multiple times.

Parameters and arguments

Parameters are the names listed in the function definition. Arguments are the values you pass when calling the function.

def greet(name):          # 'name' is a parameter
    print(f"Hello, {name}!")
 
greet("Alice")            # "Alice" is an argument
greet("Bob")              # "Bob" is an argument

Multiple parameters:

def add(a, b):
    print(a + b)
 
add(3, 5)   # 8
add(10, 20) # 30

Positional vs keyword arguments:

def describe_pet(animal, name):
    print(f"My {animal} is named {name}")
 
# Positional (order matters)
describe_pet("cat", "Whiskers")
 
# Keyword (order doesn't matter)
describe_pet(

return vs print — the confusion that stalls every beginner

This is the #1 beginner mistake. Let's be crystal clear:

print() outputs text to the terminal. It's for humans to see.

return sends a value back to the caller. It's for the program to use.

# WRONG: This function doesn't return anything
def add_bad(a, b):
    print(a + b)
 
result = add_bad(3, 5)
print(result)  # None — because add_bad didn't return anything
 
# RIGHT: This function returns a value
def

Mental model:

• print() is like shouting the answer so everyone in the room hears it.
• return is like handing the answer to the person who asked.

When to use which:

• Use return when the function computes a value that other code needs.
• Use print() when the function's purpose is to display something to the user.
• Most functions should return, not print.

None — the silent default return

If a function doesn't explicitly return a value, it returns None:

def do_nothing():
    pass  # 'pass' is a no-op
 
result = do_nothing()
print(result)  # None

This is why the add_bad example above returned None — it had no return statement.

When None is useful:

• Functions that perform side effects (printing, writing files) often return None
• Functions that search for something return None when the item isn't found

def find_user(users, name):
    for user in users:
        if user["name"] == name:
            return user
    return None  # Not found

Docstrings

Docstrings are multi-line comments that document what a function does. They go right after the def line, wrapped in triple quotes:

def calculate_tax(amount, rate=0.1):
    """
    Calculate tax on a given amount.
    
    Args:
        amount: The pre-tax amount (float or int)
        rate: The tax rate as a decimal (default 0.1 = 10%)
    
    Returns:
        The tax amount (float)
    
    Example:
        >>> calculate_tax(100, 0.1)
        10.0
    """
    return amount * rate

Access docstrings with help():

help(calculate_tax)
# Help on function calculate_tax in module __main__:
# 
# calculate_tax(amount, rate=0.1)
#     Calculate tax on a given amount.
#     ...

When to write docstrings:

• Every function you'll reuse or share
• Functions with non-obvious behavior
• Functions with multiple parameters

When NOT to write docstrings:

• Trivial one-liners: def double(x): return x * 2
• Private helper functions (but consider if they should be documented anyway)

Default parameter values

Parameters can have default values, making them optional:

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")
 
greet("Alice")                # Hello, Alice!
greet("Alice", "Good morning

Key facts:

• Default values are evaluated once, when the function is defined.
• Put parameters with defaults after parameters without defaults.

# RIGHT
def func(a, b, c=10):
    pass
 
# WRONG — SyntaxError
def func(a=10, b, c):
    pass

Scope: local vs global

Variables created inside a function are local — they don't exist outside the function:

def my_func():
    x = 10  # Local variable
    print(x)
 
my_func()   # 10
print(x)    # NameError: name 'x' is not defined

Variables created outside functions are global — they're accessible everywhere:

x = 10  # Global variable
 
def my_func():
    print(x)  # Can read global variables
 
my_func()  # 10

Modifying global variables:

You can read global variables, but to modify them, you need the global keyword:

count = 0
 
def increment():
    global count
    count += 1
 
increment()
print(count)  # 1

Best practice: Avoid global. Pass values as parameters and return results instead. Global state makes code hard to test and debug.

Real-world usage

Data processing:

def parse_csv_line(line):
    """Parse a CSV line into a dictionary."""
    parts = line.strip().split(",")
    return {
        "name": parts[0],
        "age": int(parts[1]),
        "email"

Validation:

def is_valid_email(email):
    """Check if an email has a basic valid format."""
    return "@" in email and "." in email.split("@")[-1]
 
print(is_valid_email("alice@example.com"))  # True
print

Transformation:

def celsius_to_fahrenheit(celsius):
    """Convert Celsius to Fahrenheit."""
    return (celsius * 9/5) + 32
 
temps = [0, 20, 30, 100]
fahrenheit = [celsius_to_fahrenheit(t) for t in temps]
print(

Common mistakes

Production notes

Type hints: In production code, annotate parameters and return types:

def calculate_tax(amount: float, rate: float = 0.1) -> float:
    return amount * rate

Type hints are optional and not enforced at runtime, but tools like mypy check them statically. We'll cover type hints in L2.

Pure functions: Prefer functions that don't modify external state (pure functions). They're easier to test, debug, and reason about:

# Pure — no side effects
def add(a, b):
    return a + b
 
# Impure — modifies external state
total = 0
def add_to_total(x):
    global total
    total += x

Function length: Keep functions short — ideally under 20 lines. If a function is longer, break it into smaller functions. Each function should do one thing.

Practice: Prove your Mastery

Interview Questions

Summary

• Define functions with def, call them by name.
• Parameters are in the definition, arguments are in the call.
• return sends a value back to the caller. print() outputs to the terminal.
• Functions without return return None.
• Docstrings document what a function does — access with help().
• Default parameter values make parameters optional.
• Variables inside functions are local. Use global to modify globals (but avoid it).
• Keep functions short, pure, and well-documented.

Quick recall

I want to…
├── Define a function → def name(params):
├── Call a function → name(args)
├── Return a value → return value
├── Make a parameter optional → def f(x=10):
├── Document a function → """Docstring"""
├── Access docs → help(function_name)
└── Avoid side effects → Use return, not print; avoid global

Self-Check Quiz

Warning: Functions without return return None by default.

Best practice: Avoid global. Pass values as parameters and return results.

When to write: Every function you'll reuse or share.

Senior:

1. "What's wrong with def f(items=[])? How do you fix it?"

   The default list is created once when the function is defined, not each time it's called. All calls share the same list, so modifications persist across calls. Fix: use None as the default and create a new list inside the function: def f(items=None): items = items or [].

2. "What's a pure function? Why are they preferred?"

   A pure function has no side effects — it doesn't modify external state, and given the same inputs, it always returns the same output. Pure functions are easier to test (no setup/teardown), debug (no hidden state), and reason about (deterministic). They're the foundation of functional programming.