Python Return Values – Return Statement and Multiple Returns

Basic Return Statement

return immediately exits the function and sends the specified value back to whoever called the function.

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

result = add(3, 7)
print(result)       # 10
print(add(100, 200))  # 300 - use directly

Functions Without return → None

If a function has no return statement (or just return with no value), it returns None.

def greet(name):
    print(f"Hello, {name}!")  # No return statement

result = greet("Alice")
print(result)   # None
print(type(result))   # <class 'NoneType'>

Returning Multiple Values

Python functions can return multiple values by separating them with commas. Python packs them into a tuple automatically.

def min_max(numbers):
    return min(numbers), max(numbers)  # Returns tuple

low, high = min_max([5, 3, 9, 1, 7])  # Unpack
print(f"Min: {low}, Max: {high}")

# Or capture as a single tuple
result = min_max([5, 3, 9, 1, 7])
print(result)   # (1, 9)

Early Return – Guard Clauses

Returning early when a condition fails is cleaner than deep nesting.

def divide(a, b):
    if b == 0:
        return None  # Early return for invalid input
    return a / b

print(divide(10, 2))   # 5.0
print(divide(10, 0))   # None - early return triggered

Returning Different Types

A function can return different types based on conditions. This is valid Python but can make code harder to use — callers must check the type.

def find_user(user_id):
    users = {1: "Alice", 2: "Bob"}
    if user_id in users:
        return users[user_id]  # Returns str
    return None               # Returns NoneType

user = find_user(1)
if user is not None:
    print(f"Found: {user}")

Return Values: One, Many, or None

return does two things at once: it sends a value back and immediately exits the function. Everything after a return that runs is dead code.

def divide(a, b):
    if b == 0:
        return None          # early exit — guard against divide-by-zero
    return a / b             # normal result

# return MULTIPLE values (actually returns a tuple)
def min_max(nums):
    return min(nums), max(nums)

low, high = min_max([3, 1, 8])   # unpack the tuple → low=1, high=8

Multiple returns are really a tuple: return a, b builds a tuple, and x, y = func() unpacks it — a clean way to hand back several results without a container class. Early return (returning inside a guard at the top) is a readable alternative to nesting the whole function in an if. Consistency matters: if a function sometimes returns a number and sometimes None, callers must check for None — document that. Avoid returning different types from different branches when you can; predictable return types make functions easier to use correctly.

Interview Questions on Return Values

• What does the return statement do?
• What does a function return if it has no return statement?
• How does a function return multiple values?
• What is the difference between return and print?
• What is an early return / guard clause?
• Can a function return different types depending on input? Is that a good idea?
• What happens to code after a return statement?

Related Topics