Return Values

Functions don't just perform actions - they can also compute and send back results. The return statement is how functions communicate their output back to the code that called them. Understanding return values is crucial for writing functions that can be composed, tested, and reused effectively!

Basic Return Statements

The return statement immediately exits the function and sends a value back to the caller. If a function doesn't have a return statement, or has return without a value, it returns None by default.

Click Run to execute your code

Returning Multiple Values

Python makes it easy to return multiple values from a function. You can return a tuple (the most common approach), a dictionary (for named values), a list, or even a named tuple for the best of both worlds.

Click Run to execute your code

Return vs Print

A common beginner confusion: print() displays output to the screen, while return sends data back to the caller. Functions that print can't be composed or tested easily - always prefer return for reusable functions.

Click Run to execute your code

Practical Return Patterns

Professional Python code uses return in many patterns: early returns for validation, guard clauses for cleaner logic, factory functions to create objects, and result patterns for error handling.

Click Run to execute your code

Common Mistakes

# Wrong - can't use the result
def add(a, b):
    print(a + b)

result = add(3, 5)  # result is None!
# result + 10 would cause TypeError

# Correct - return the value
def add(a, b):
    return a + b

result = add(3, 5)  # result is 8
print(result + 10)  # Works: 18

def calculate_tax(amount):
    return amount * 0.1

# Wrong - return value is lost
calculate_tax(100)
# The 10.0 is calculated but never stored

# Correct - capture the result
tax = calculate_tax(100)
print(f"Tax: ${tax}")

# Wrong - cleanup never runs!
def get_data():
    return fetch_from_database()
    close_connection()  # Never executes!

# Correct - use try/finally or context manager
def get_data():
    try:
        return fetch_from_database()
    finally:
        close_connection()  # Always runs

# Confusing - returns different types
def find_user(user_id):
    if user_id in database:
        return database[user_id]  # Returns dict
    return "Not found"  # Returns string!

# Better - consistent return type
def find_user(user_id):
    if user_id in database:
        return database[user_id]
    return None  # Always returns dict or None

# Or return a result tuple
def find_user(user_id):
    if user_id in database:
        return True, database[user_id]
    return False, None

# Wrong - only checks first item
def contains_even(numbers):
    for n in numbers:
        if n % 2 == 0:
            return True
        return False  # Returns on first iteration!

contains_even([1, 2, 3])  # Returns False (wrong!)

# Correct - check all items
def contains_even(numbers):
    for n in numbers:
        if n % 2 == 0:
            return True
    return False  # Only after loop completes

contains_even([1, 2, 3])  # Returns True (correct)

Exercise: Statistics Function

Click Run to execute your code

def get_stats(numbers):
    """Return statistics about a list of numbers."""
    if not numbers:
        return None

    return {
        "min": min(numbers),
        "max": max(numbers),
        "sum": sum(numbers),
        "average": sum(numbers) / len(numbers)
    }

# Test it
stats = get_stats([1, 2, 3, 4, 5])
print(f"Stats: {stats}")
print(f"Average: {stats['average']}")

empty_stats = get_stats([])
print(f"Empty: {empty_stats}")

Summary

What's Next?

Now that you understand how functions communicate through arguments and return values, let's explore Variable Scope - understanding where variables exist and how Python looks them up. This is essential for avoiding bugs and writing cleaner code!