Introduction

Python functions do not literally return two separate objects; they return one object that can contain multiple pieces of data. In everyday code, that usually means returning a tuple and unpacking it at the call site. The real question is not whether Python can return two values, but which container makes the result easiest to read and maintain.

Return a Tuple for Simple Results

The most common solution is to return two values separated by commas. Python packs them into a tuple automatically.

1def divide_and_remainder(a, b):
2    return a // b, a % b
3
4quotient, remainder = divide_and_remainder(17, 5)
5print(quotient, remainder)

Output:

3 2

This is concise and idiomatic. It works well when the meaning of the two results is obvious from the function name or from variable names used during unpacking.

Use Named Results When Meaning Matters

A bare tuple can become unclear when the values are similar or easy to swap accidentally. In those cases, use a namedtuple or dataclass so the caller can access fields by name.

1from dataclasses import dataclass
2
3@dataclass
4class ParseResult:
5    ok: bool
6    value: int
7
8def parse_int(text):
9    try:
10        return ParseResult(True, int(text))
11    except ValueError:
12        return ParseResult(False, 0)
13
14result = parse_int("42")
15print(result.ok, result.value)

This is slightly longer than a tuple, but it scales better once the return type becomes part of a public API.

Return a Dictionary When the Shape Is Flexible

If the result fields are optional or vary based on the operation, a dictionary can be a reasonable choice.

1def lookup_user(user_id):
2    if user_id == 1:
3        return {"found": True, "name": "Ada"}
4    return {"found": False, "name": None}
5
6response = lookup_user(1)
7print(response["found"], response["name"])

A dictionary is useful for loosely structured data, but it is easier to mistype keys and harder to refactor than a tuple or data class. Use it when flexibility matters more than strict structure.

Unpacking Is Part of the Design

Returning multiple values is only half of the pattern. The call site should unpack them clearly. Python lets you ignore values you do not need.

1def min_max(numbers):
2    return min(numbers), max(numbers)
3
4smallest, largest = min_max([4, 9, 1, 7])
5print(smallest, largest)
6
7_, max_only = min_max([4, 9, 1, 7])
8print(max_only)

This makes function calls concise, but it also means order matters. If the function returns (status, data), the caller must know which position means what. Named return objects reduce that risk.

When to Raise Instead of Returning Two Values

Sometimes developers return a pair such as (result, error) because they want to report success and failure in one object. In Python, exceptions are often the cleaner choice for real error cases.

1def reciprocal(value):
2    if value == 0:
3        raise ValueError("value must not be zero")
4    return 1 / value
5
6try:
7    print(reciprocal(4))
8except ValueError as exc:
9    print(exc)

Return two values when both are normal outputs. If one of them represents an exceptional failure path, the code is usually clearer when the function raises.

Pick the Lightest Useful Structure

A practical rule is:

1. Use a tuple for short, obvious return values.
2. Use a dataclass or namedtuple when names improve clarity.
3. Use a dictionary only when the result is intentionally flexible.
4. Use exceptions instead of (value, error) for actual failures.

That rule keeps Python code idiomatic without sacrificing readability.

Common Pitfalls

• Returning a plain tuple when the meaning of each position is easy to confuse later.
• Using a dictionary for fixed structured data that would be clearer as a tuple or dataclass.
• Forgetting the return order and unpacking the values into the wrong variables.
• Returning (result, error) patterns from code that would be simpler with exceptions.
• Changing a function from one return shape to another without updating all callers.

Summary

• Python commonly returns two values by packing them into a tuple.
• Tuple unpacking makes the call site concise and readable for simple cases.
• 'dataclass and namedtuple are better when the result benefits from named fields.'
• Dictionaries are useful for flexible response shapes but weaker for fixed APIs.
• Choose the return type based on how clearly callers can understand and use the result.