Functions: Intermediate

Design functions with smart fallbacks

Default parameters let you specify fallback values for function arguments. When a caller omits an argument, Python uses the default. This makes functions more flexible by allowing optional parameters without requiring the caller to always provide them.

Define defaults using parameter=value in the function signature:

The greeting parameter has a default value of "Hello". When you call greet("Bob"), Python automatically uses "Hello" because you did not provide a second argument. This simple mechanism unlocks tremendous flexibility in function design.

This flexibility is why Python APIs are often more readable than those in languages without keyword arguments. When you see connect_db(timeout=60), the intent is immediately clear. Compare this to connect_db("localhost", 5432, 60, True) where you need to consult documentation to understand what 60 and True mean.

Parameters without defaults are required. Required parameters must come before parameters with defaults:

Never use mutable objects (lists, dicts) as default values. They are created once when the function is defined, not on each call:

This pattern extends to any mutable type: lists, dictionaries, sets, and even custom objects. Safe defaults are immutable values like None, integers, floats, strings, tuples, and booleans. Dangerous defaults are mutable types like lists, dicts, sets, and custom objects. The None sentinel pattern is so common that experienced Python developers recognize it immediately.

Explore what happens when you use a mutable default versus the safe None pattern. Toggle the default value below and run both scenarios.

def add_item(item, items=___None[]):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("a"))
print(add_item("b"))

The None sentinel pattern is the standard Python idiom for any mutable default. Using None signals clearly to readers that the function creates a fresh container each time it is called.

Immutable defaults like integers, strings, booleans, and tuples are always safe. When you need a mutable default, always use None and initialize inside the function body.

Return and unpack multiple results

Separate return values with commas. Python automatically wraps them in a tuple:

The line return total, count, average creates and returns a tuple (150, 5, 30.0). The unpacking total, count, avg = get_stats(data) splits it back into variables.

Use underscore _ to ignore values you do not need:

The underscore is a convention meaning "I do not care about this value." The *_ syntax captures all remaining values into a throwaway list.

Python 3 introduced extended unpacking with * to capture multiple values into a list. This is useful when functions return variable-length results:

Related statistics

Compute total, count, and average in one pass over the data.

Status plus result

Return a success flag alongside the computed data for error handling.

String splitting

Separate text into parts like (before, separator, after) tuples.

Validation results

Return is_valid boolean and a list of error messages together.

Data plus metadata

Return transformed records along with metadata like row counts.

def min_max(nums):
    return ___(nums), ___(nums)

lo, hi = min_max([4, 1, 7, 2])
print(lo)
print(hi)

Control variable visibility in code

The variables x, y, and result only exist inside calculate(). Once the function returns, they are gone. This isolation is a feature: it prevents functions from accidentally interfering with each other.

Local scope is created fresh for each function call. If you call calculate() twice, each call gets its own independent x, y, and result variables. This means recursive functions work correctly, and concurrent calls do not interfere with each other. The isolation makes functions predictable and testable.

The assignment value = "local" creates a new local variable that hides the global one. The global value is never modified. This behavior protects global state from accidental modification.

Shadowing can cause confusion when you expect to read a global but accidentally create a local with the same name. Python determines scope at compile time, not runtime. If a variable is assigned anywhere in a function, Python treats it as local throughout that entire function, even before the assignment.

To modify a global variable from inside a function, declare it with the global keyword:

To modify a variable from an enclosing (non-global) scope, use the nonlocal keyword. This is useful for closures and factories.

def add_to(items, value):
    items.___(value)
    return ___(items)

data = [10, 20]
result = add_to(data, 30)
print(result)
print(len(data))

Accept any number of arguments

The *args syntax lets a function accept any number of positional arguments. The arguments are collected into a tuple. This is invaluable when you do not know in advance how many values will be passed.

Think of a logging function that needs to print any number of messages, or a calculation function that sums any count of numbers, or a path builder that joins any number of directory components. Without *args, you would need to accept a list and require callers to wrap their arguments in brackets. With *args, the function call looks natural and clean.

The asterisk * before a parameter name collects extra positional arguments:

The name args is a convention. You could use *values or *items. The asterisk is what matters.

You can have regular parameters before *args. Regular parameters are filled first, and *args captures the rest:

The * operator also works in reverse. You can unpack a list or tuple when calling a function:

The *numbers unpacks the list [10, 20, 30] into three separate arguments, as if you had written add_three(10, 20, 30).

Many utility functions in data pipelines use *args for flexibility:

The *args pattern is used extensively in Python's standard library. Functions like print() accept any number of arguments to display. The max() and min() functions accept either a single iterable or multiple positional arguments. Understanding *args helps you use these built-in functions more effectively.

Handle named options as dictionaries

The **kwargs syntax captures keyword arguments into a dictionary. This allows functions to accept any named parameters, making them highly configurable without defining every possible option upfront.

Consider a function that connects to a database. Different database systems need different options: PostgreSQL might need an SSL certificate, MySQL might need a character set, and Redis might need a connection pool size. Rather than defining every possible parameter, you accept **kwargs and let callers pass whatever options their database needs.

This pattern is central to Python web frameworks. When you define a Django model or a Flask route, you pass keyword arguments that configure behavior. The framework collects these into a dictionary and processes them. Understanding **kwargs helps you both use and build such APIs.

Double asterisk ** collects keyword arguments into a dictionary:

Like args, the name kwargs is just convention. You could use **options or **config.

You can use all parameter types together. They must appear in this order: regular, *args, keyword-only, **kwargs:

Use ** to unpack a dictionary into keyword arguments when calling a function:

The **kwargs pattern is everywhere in data engineering for configuration and options:

Note how options.get("key", default) provides fallback values for missing keys. This is the standard pattern for handling optional configuration.

A powerful pattern is using *args and **kwargs to forward all arguments to another function:

The ** operator can merge dictionaries in function calls and dictionary literals:

This is the most common intermediate Python pitfall. The list default is created once when Python parses the function definition. Every call that uses the default shares that same list object. The fix is always the same: use None as the default and create a fresh mutable object inside the function.

The UnboundLocalError is confusing because the error message says the variable is referenced before assignment, but you might think you are reading a global. The key insight is that Python determines scope at compile time based on assignments anywhere in the function, not at runtime based on execution order.

Remember the order: required positional, then *args, then keyword-only with defaults, then **kwargs. This order is enforced by Python because it is the only way to unambiguously assign arguments to parameters.

This mistake is especially common when reading configuration from files or environment variables. You load a dictionary of settings and need to pass them to a function. Without the ** unpack operator, Python passes the entire dictionary as a single argument rather than expanding it into keyword arguments.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

def min_max(nums):
  return min(nums), return max(nums)

The *args and **kwargs syntax enables genuinely flexible interfaces. Wrapper functions, decorators, and logging utilities all rely on forwarding arbitrary arguments without knowing their names or count in advance.

When combining *args and **kwargs with regular parameters, the order matters: required positional parameters come first, then *args, then keyword-only parameters with defaults, then **kwargs. Python enforces this order because it is the only unambiguous assignment.

The unpacking operators work in both directions. Just as * collects arguments in a function definition, it also unpacks a list or tuple at a call site. Similarly, ** collects keyword arguments in a definition and unpacks a dictionary at a call site.