Functions

Functions package code so it can be reused, named, and tested. Every program is a tree of function calls. The keyword is def, the body is indented, and a function ends as soon as its indentation does.

Where are functions used?

Functions are the fundamental building block of modern programs:

• Every API — whether it's a REST endpoint, a library method, or a CLI command — is ultimately a function call with inputs and outputs.
• Testing — Unit tests verify one function at a time. Your test suite is only as good as your functions are isolated.
• Functional programming — Pure functions (same input → same output, no side effects) make code easier to reason about, parallelize, and debug.
• The call stack — Your entire program is a tree of function calls. When you see a traceback, each line is a function that called the next.

Think of every import requests; requests.get(url) or df.groupby("category").mean() — each is a function doing one job well, composed with others.

Etymology: functions vs mathematical functions

The term function comes from mathematics: f(x) = y means "given input x, produce output y."

In math, functions are pure:

• f(3) always returns the same value.
• f doesn't modify anything; it just computes.

Python functions can behave this way (and should, when possible):

def square(x):
    return x * x

But Python functions can also have side effects (printing, writing files, mutating arguments, maintaining state). This makes them more powerful but also harder to test:

def log_and_square(x):
    print(f"computing square of {x}")  # side effect: I/O
    return x * x

When you hear "functional programming," it means prefer pure functions: no side effects, same input → same output, every time.

Anatomy of a function call

A function is defined once with def, then called many times. Each call creates a new local scope, binds arguments to parameters, executes the body, and returns a value (or None if no return is hit).

Defining a function

A function that does not explicitly return returns None.

Parameters and arguments

Python distinguishes between positional and keyword arguments.

Default values

Defaults are evaluated once, when the function is defined (not when it's called). A mutable default value is the most famous Python footgun:

*args and **kwargs

*args captures any extra positional arguments as a tuple; **kwargs captures any extra keyword arguments as a dict.

When calling a function, * and ** unpack iterables/dicts back into arguments:

Positional-only and keyword-only parameters

Modern Python lets you control exactly how callers may pass each argument:

def func(pos_only, /, pos_or_kw, *, kw_only):
    ...

• Parameters before / are positional-only.
• Parameters after * are keyword-only.
• Parameters between / and * can be passed either way.

Return values

A return statement exits the function immediately and sends a value back to the caller.

You can return multiple values by separating them with commas. Python packs them into a tuple:

Use early return to avoid deep nesting:

Lambdas

A lambda is an anonymous, single-expression function. They are useful as key= arguments to sorted, min, max, and similar higher-order functions.

Type hints

Type hints (PEP 484+) are optional annotations. Python itself does not enforce them at runtime; tools like mypy, pyright, and editors use them to catch bugs and power autocompletion.

You can put them on plain variables too:

count: int = 0
names: list[str] = []
cache: dict[str, int] = {}

First-class functions

In Python, functions are first-class objects: you can pass them as arguments, store them in data structures, and return them from other functions.

This is the foundation of decorators, callbacks, and many design patterns.

Higher-order functions: map, filter, sorted

These built-ins take a function and an iterable.

Real-world patterns

Pure functions (no side effects) are easier to test and parallelize:

# pure: always returns same output for same input
def tax(amount, rate):
    return amount * rate

# impure: prints (side effect)
def log_tax(amount, rate):
    result = amount * rate
    print(f"tax on {amount} at {rate}: {result}")
    return result

Higher-order functions (functions that take or return functions) are everywhere in Python:

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

Here, lru_cache is a decorator — a function that takes a function and returns a wrapped version with caching.

Challenges

greet_all("Ada", "Grace", greeting="Hi")
# -> "Hi, Ada!\nHi, Grace!"

Multiple choice questions

def f(x, items=[]):
  items.append(x)
  return items

print(f(1))
print(f(2))

Next: where Python looks for names when you use them.