Returning Multiple Values via Tuples

🏷️ Functions / Return Values

📚 All-in-One📖 Theory Only💻 Code Only

🧠 Context Introduction

In Python, functions are not limited to returning just a single value. When you need a function to give back multiple pieces of information at once—like a status code and a message, or coordinates and a timestamp—Python provides a clean and elegant solution using tuples. A tuple is an immutable, ordered collection that can hold multiple values, and Python makes it incredibly simple to return and unpack them.

⚙️ What Is a Tuple?

A tuple is a collection of items enclosed in parentheses ().
Items are separated by commas.
Tuples are immutable, meaning once created, their contents cannot be changed.
They are perfect for grouping related data that should stay together.

Example structure of a tuple: - A tuple with two values: ("success", 200) - A tuple with three values: ("error", 404, "Not Found")

🛠️ How to Return Multiple Values

To return multiple values from a function, simply separate them with commas after the return keyword.
Python automatically packs these values into a single tuple.

Basic example: - Function definition: def get_status(): - Return statement: return "ok", 1 - What is actually returned: A tuple ("ok", 1)

Another example with three values: - Function definition: def get_coordinates(): - Return statement: return 35.6895, 139.6917, "Tokyo" - What is actually returned: A tuple (35.6895, 139.6917, "Tokyo")

📦 Unpacking the Returned Tuple

When you call a function that returns a tuple, you can unpack the values directly into separate variables.
The number of variables on the left side must match the number of values in the tuple.

Unpacking example: - Function call: result = get_status() - Result: result is a tuple ("ok", 1) - Direct unpacking: status, code = get_status() - Now: status holds "ok" and code holds 1

Unpacking three values: - Function call: lat, lon, city = get_coordinates() - Now: lat holds 35.6895, lon holds 139.6917, city holds "Tokyo"

📊 Comparison: Single Return vs. Multiple Return via Tuple

Aspect	Single Return Value	Multiple Return via Tuple
Return statement	`return value`	`return value1, value2`
What is returned	A single object	A single tuple containing multiple objects
Caller receives	One variable	One tuple (or unpacked variables)
Use case	Simple, one-piece output	Grouped, related output (e.g., status + data)
Flexibility	Limited	High; can return any number of values

🕵️ Practical Patterns and Tips

Ignoring some values: Use an underscore _ as a placeholder for values you don't need.
Example: status, _ = get_status() — only the first value is captured.
Returning mixed data types: Tuples can hold different types (string, int, list, etc.).
Example: return "user_found", {"name": "Alice", "age": 30}
Naming matters: Choose clear variable names when unpacking to improve code readability.
Good: error_code, error_message = handle_request()
Avoid: a, b = handle_request()
Tuples are lightweight: They are more memory-efficient than lists for returning fixed groups of data.

✅ Summary

Python functions can return multiple values by separating them with commas after return.
These values are automatically packed into a tuple.
Callers can unpack the tuple directly into separate variables for easy access.
This pattern is ideal when a function needs to communicate several related pieces of information, such as a result code, a message, and a data payload.
Use underscores to ignore unwanted values and always name your unpacked variables descriptively for clarity.

Returning multiple values via tuples keeps your code clean, expressive, and avoids the need for complex data structures when simple grouping is enough.

A tuple is an ordered collection that allows a function to send back multiple values as a single return object.

📦 Example 1: Returning two values as a tuple

This shows the simplest case — a function that returns two separate values packed into a tuple.

def get_coordinates():
    x = 10
    y = 20
    return x, y

result = get_coordinates()
print(result)

📤 Output: (10, 20)

📦 Example 2: Unpacking a tuple into separate variables

This demonstrates how to assign each returned value to its own variable in one line.

def get_min_max(numbers):
    smallest = min(numbers)
    largest = max(numbers)
    return smallest, largest

values = [3, 7, 1, 9, 4]
min_val, max_val = get_min_max(values)
print("Min:", min_val)
print("Max:", max_val)

📤 Output: Min: 1 Max: 9

📦 Example 3: Returning three values with mixed types

This shows that a tuple can hold different data types — integers, strings, and floats.

def get_employee_info(emp_id):
    name = "Alice"
    department = "Engineering"
    salary = 85000.0
    return emp_id, name, department, salary

result = get_employee_info(101)
print(result)

📤 Output: (101, 'Alice', 'Engineering', 85000.0)

📦 Example 4: Using tuple indexing to access individual values

This demonstrates that you can access tuple elements by position, just like a list.

def divide_with_remainder(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder

result = divide_with_remainder(17, 5)
print("Quotient:", result[0])
print("Remainder:", result[1])

📤 Output: Quotient: 3 Remainder: 2

📦 Example 5: Practical use — returning status and data from a validation function

This shows a real-world pattern where a function returns both a success flag and the processed data.

def validate_and_parse(age_input):
    if age_input.isdigit():
        age = int(age_input)
        if 0 <= age <= 120:
            return True, age
    return False, None

success, parsed_age = validate_and_parse("28")
if success:
    print("Valid age:", parsed_age)
else:
    print("Invalid input")

📤 Output: Valid age: 28

Comparison Table: Returning One Value vs. Returning Multiple Values via Tuple

Aspect	Single Return Value	Multiple Values via Tuple
What is returned	One object (int, str, list, etc.)	A tuple containing multiple objects
Number of values	Exactly 1	2 or more
Unpacking needed	No	Yes, or use indexing
Typical use case	Simple result	Combined results (e.g., status + data)
Example	`return x`	`return x, y, z`