Create Your Resume
Back to Python
Lesson 14 of 31

Functions, Arguments, Returns, and Type Hints

Functions are the structural foundation of Python programs. They define how logic is grouped, reused, tested, and reasoned about. While beginners see functions as “blocks of reusable code,” experienced developers see them as interfaces, contracts, and units of responsibility. Mastery of Python functions requires far more than knowing def and return. It involves understanding how arguments are passed, how defaults are evaluated, how variable-length arguments behave, how multiple return values actually work internally, and how type hints change the way large systems are written and maintained. This guide goes far beyond syntax. It explains why Python functions behave the way they do, how argument passing and return mechanics work internally, where edge cases cause bugs, and when to use different patterns in real production code. This is the level of understanding expected from professional Python developers.

What Is a Function in Python?

A function is a named block of code that performs a specific task. Once defined, a function can be executed multiple times by calling its name. This allows logic to be reused instead of rewritten.

More importantly, functions introduce structure. They divide a program into logical units so that humans can understand, reason about, and modify code more easily. 

def greet():
    print("Hello")

Defining a function does not execute it. The code inside runs only when the function is explicitly called. 

greet()

Why Functions Are Essential

As programs grow, writing everything sequentially becomes difficult to manage. Functions solve this by grouping related logic under a meaningful name.

Functions allow:

  • Reduction of duplicated code
  • Clear separation of responsibilities
  • Easier testing and debugging
  • Improved readability

In well-written Python code, functions read like descriptions of behavior, making programs easier to understand than raw instructions.

How Python Defines a Function

When Python encounters a def statement, it creates a function object and assigns it to a name. No code inside the function runs at this moment. 

def add(a, b):
    return a + b

Functions are objects in Python. This means they can be assigned to variables, stored in data structures, passed as arguments, or returned from other functions.

Function Arguments: How Data Enters a Function

Arguments allow functions to operate on external data. They act as inputs that influence a function’s behavior. 

def greet(name):
    print("Hello", name)

greet("Alice")

The function does not care where the value came from. It simply receives it and uses it.

Positional Arguments

Positional arguments are matched to parameters based solely on their order. 

def subtract(a, b):
    return a - b

subtract(10, 3)

This approach is simple but fragile. If arguments are passed in the wrong order, the function will still run but produce incorrect results.

For this reason, positional arguments work best when their meaning is obvious and order is intuitive.

Keyword Arguments

Keyword arguments associate values with parameter names. This removes ambiguity and improves clarity. 

subtract(b=3, a=10)

Keyword arguments make function calls self-explanatory. They also allow functions to evolve safely by adding new parameters without breaking existing calls.

Default Arguments

Default arguments allow parameters to have predefined values. If no value is provided during the call, the default is used. 

def connect(host, port=3306):
    return f"{host}:{port}"

Default values are evaluated once, at the time the function is defined. This behavior is important and often misunderstood.

Mutable Default Argument Problem

Using mutable objects as default values can cause unexpected behavior. 

def add_item(item, bucket=[]):
    bucket.append(item)
    return bucket

The same list is reused across function calls, leading to shared state.

The correct pattern avoids this issue: 

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

Variable-Length Positional Arguments (*args)

Sometimes a function must accept an unknown number of positional arguments. The *args syntax collects extra arguments into a tuple. 

def average(*values):
    return sum(values) / len(values)

Internally, Python packs all extra positional arguments into a tuple. This makes *args useful for mathematical operations, wrappers, and flexible APIs.

Variable-Length Keyword Arguments (**kwargs)

The **kwargs syntax collects keyword arguments into a dictionary. 

def configure(**settings):
    return settings

This pattern is common in configuration systems and frameworks. However, excessive use can hide required parameters and weaken function clarity.

How Arguments Are Passed in Python

Python uses a call-by-object-reference model. Variables inside a function reference the same objects passed from the caller.

Immutable objects appear unchanged, while mutable objects can be modified inside the function. 

def modify(data):
    data.append(4)

values = [1, 2, 3]
modify(values)

The list is modified because both references point to the same object.

Return Values

Functions return data using the return statement. Once return is executed, the function stops immediately. 

def square(x):
    return x * x

If no return statement is present, Python automatically returns None.

Multiple Return Values

Python does not truly return multiple values. It returns a single tuple. 

def stats(data):
    return min(data), max(data), sum(data)

Tuple unpacking makes this appear like multiple returns. 

low, high, total = stats([1, 2, 3])

This requires consistent return structures to avoid runtime errors.

Function Annotations and Type Hints

Type hints describe expected input and output types. They are not enforced at runtime, but they improve readability and tooling support. 

def add(a: int, b: int) -> int:
    return a + b

In large codebases, type hints act as living documentation. They help catch bugs early, improve IDE assistance, and make code easier to understand.

Real-World Function Design Example

def create_invoice(
    customer_id: int,
    items: list,
    *,
    tax_rate: float = 0.0,
    metadata: dict | None = None
) -> dict:
    if not items:
        raise ValueError("Invoice must contain items")

    subtotal = sum(item["price"] for item in items)
    tax = subtotal * tax_rate

    return {
        "customer_id": customer_id,
        "subtotal": subtotal,
        "tax": tax,
        "total": subtotal + tax,
        "metadata": metadata or {}
    }

This function shows clear responsibility, safe defaults, keyword-only arguments, early validation, and predictable output.

Common Function Design Mistakes

  • Functions doing too many things
  • Hidden behavior through shared mutable state
  • Inconsistent return values
  • Unclear or undocumented parameters

Summary

Functions are the backbone of Python programs. They provide structure, clarity, and reuse. Understanding how arguments are handled, how return values work, and how type hints communicate intent is essential for writing reliable and maintainable code. Mastery of functions comes from understanding their behavior, design principles, and long-term impact on code quality.