Function Returns Multiple Values in Python

In Python, functions can return multiple values by separating them with commas. These values are returned as a tuple, but they can be unpacked into individual variables.

Basic Syntax

python

def function_name():
    return value1, value2, value3

# Calling and unpacking
var1, var2, var3 = function_name()

Simple Examples

Example 1: Basic Multiple Return

python

def get_person_info():
    name = "Alice"
    age = 25
    city = "New York"
    return name, age, city

# Calling the function
person_name, person_age, person_city = get_person_info()
print(f"Name: {person_name}")
print(f"Age: {person_age}")
print(f"City: {person_city}")

Example 2: Math Operations Returning Multiple Results

python

def calculate_stats(a, b):
    total = a + b
    difference = a - b
    product = a * b
    return total, difference, product

# Unpacking the results
sum_result, diff_result, prod_result = calculate_stats(10, 5)
print(f"Sum: {sum_result}")
print(f"Difference: {diff_result}")
print(f"Product: {prod_result}")

Example 3: String Processing

python

def process_string(text):
    length = len(text)
    uppercase = text.upper()
    lowercase = text.lower()
    return length, uppercase, lowercase

size, upper_text, lower_text = process_string("Hello Python")
print(f"Length: {size}")
print(f"Uppercase: {upper_text}")
print(f"Lowercase: {lower_text}")

Practical Examples

Example 4: Circle Calculations

python

def circle_calculations(radius):
    area = 3.14159 * radius ** 2
    circumference = 2 * 3.14159 * radius
    diameter = 2 * radius
    return area, circumference, diameter

area, circ, diam = circle_calculations(7)
print(f"Area: {area:.2f}")
print(f"Circumference: {circ:.2f}")
print(f"Diameter: {diam}")

Example 5: Student Grade Calculator

python

def calculate_grades(scores):
    total = sum(scores)
    average = total / len(scores)
    highest = max(scores)
    lowest = min(scores)
    return total, average, highest, lowest

scores = [85, 92, 78, 90, 88]
total_marks, avg_grade, top_score, bottom_score = calculate_grades(scores)
print(f"Total: {total_marks}")
print(f"Average: {avg_grade:.1f}")
print(f"Highest: {top_score}")
print(f"Lowest: {bottom_score}")

Example 6: File Information

python

def get_file_info(filename):
    # Simulating file operations
    name = filename
    size = len(filename) * 100  # Mock file size
    extension = filename.split('.')[-1] if '.' in filename else "txt"
    return name, size, extension

file_name, file_size, file_ext = get_file_info("document.pdf")
print(f"File: {file_name}")
print(f"Size: {file_size} bytes")
print(f"Extension: .{file_ext}")

Working with Tuples Directly

Example 7: Returning as Tuple (Explicit)

python

def get_coordinates():
    return (10, 20, 30)  # Explicit tuple

x, y, z = get_coordinates()
print(f"X: {x}, Y: {y}, Z: {z}")

Example 8: Accessing the Entire Tuple

python

def get_user_data():
    return "John", "john@email.com", 30, "Developer"

# Store the entire tuple
user_data = get_user_data()
print(f"All data: {user_data}")
print(f"Type: {type(user_data)}")  # <class 'tuple'>
print(f"Email: {user_data[1]}")    # Access by index

Advanced Examples

Example 9: Multiple Return with Conditional Logic

python

def analyze_number(number):
    if number > 0:
        status = "Positive"
        absolute = number
    elif number < 0:
        status = "Negative"
        absolute = -number
    else:
        status = "Zero"
        absolute = 0
    
    even_odd = "Even" if number % 2 == 0 else "Odd"
    return status, absolute, even_odd

status, abs_value, parity = analyze_number(-5)
print(f"Status: {status}")
print(f"Absolute: {abs_value}")
print(f"Parity: {parity}")

Example 10: Shopping Cart Total

python

def calculate_cart_total(items):
    total = 0
    item_count = len(items)
    discount = 0
    
    for price in items:
        total += price
    
    if total > 100:
        discount = total * 0.1  # 10% discount
        total -= discount
    
    return total, item_count, discount

prices = [25.99, 15.50, 45.75, 30.00]
final_total, count, savings = calculate_cart_total(prices)
print(f"Items: {count}")
print(f"Total: ${final_total:.2f}")
print(f"Discount: ${savings:.2f}")

Example 11: Password Strength Checker

python

def check_password_strength(password):
    length = len(password)
    has_upper = any(char.isupper() for char in password)
    has_lower = any(char.islower() for char in password)
    has_digit = any(char.isdigit() for char in password)
    
    strength = "Weak"
    if length >= 8 and has_upper and has_lower and has_digit:
        strength = "Strong"
    elif length >= 6 and (has_upper or has_lower) and has_digit:
        strength = "Medium"
    
    return strength, length, has_upper, has_lower, has_digit

strength, length, has_upper, has_lower, has_digit = check_password_strength("Pass123!")
print(f"Strength: {strength}")
print(f"Length: {length}")
print(f"Has uppercase: {has_upper}")
print(f"Has lowercase: {has_lower}")
print(f"Has digit: {has_digit}")

Key Points to Remember

1. Multiple values are returned as a tuple
2. You can unpack them into individual variables
3. The number of variables must match the number of returned values
4. You can also work with the tuple directly without unpacking
5. Useful for returning related data from a function

Benefits of Multiple Return Values

• Cleaner code: Avoid creating classes or dictionaries for simple data
• Convenience: Easy to get multiple related results
• Readability: Clear what values are being returned
• Efficiency: No need for multiple function calls

This feature makes Python functions very powerful and flexible for returning complex data!

Function Returns Multiple Values – Interview Q&A

Basic Concept Questions

1. How does Python handle multiple return values from a function?

Answer:
Python returns multiple values as a tuple. When you write return a, b, c, Python automatically packs them into a tuple (a, b, c). The caller can either unpack them into individual variables or work with the tuple directly.

Example:

python

def get_values():
    return 1, 2, 3

result = get_values()
print(type(result))  # <class 'tuple'>
print(result)        # (1, 2, 3)

# Unpacking
a, b, c = get_values()
print(a, b, c)       # 1 2 3

2. What happens if you try to unpack more/less variables than returned values?

Answer:
Python raises a ValueError if the number of variables doesn’t match the number of returned values.

Example:

python

def get_two():
    return 10, 20

# These will cause ValueError:
# a, b, c = get_two()  # Too many variables
# a = get_two()        # Too few variables (a becomes tuple (10, 20))

3. Can you return different types of values together?

Answer:
Yes, Python allows returning values of different types together in a tuple.

Example:

python

def mixed_types():
    return "Hello", 42, [1, 2, 3], {"key": "value"}

text, number, my_list, my_dict = mixed_types()
print(f"Text: {type(text)}")    # <class 'str'>
print(f"Number: {type(number)}") # <class 'int'>

Usage and Syntax Questions

4. How can you ignore some returned values?

Answer:
Use the underscore _ convention to ignore unwanted values, or simply don’t unpack them.

Example:

python

def get_person():
    return "Alice", 25, "Engineer", "NY"

# Ignore age and job
name, _, _, city = get_person()
print(f"{name} lives in {city}")

# Or work with tuple and access what you need
person = get_person()
print(f"Name: {person[0]}")

5. What’s the difference between these return statements?

python

return a, b, c
return (a, b, c)
return [a, b, c]

Answer:

• return a, b, c returns a tuple (a, b, c) (most common)
• return (a, b, c) explicitly returns a tuple (same as above)
• return [a, b, c] returns a list [a, b, c]

Example:

python

def test1(): return 1, 2, 3
def test2(): return (1, 2, 3)
def test3(): return [1, 2, 3]

print(type(test1()))  # <class 'tuple'>
print(type(test2()))  # <class 'tuple'>
print(type(test3()))  # <class 'list'>

Practical Application Questions

6. How would you swap two variables using multiple return?

Answer:
Create a function that returns values in swapped order.

Example:

python

def swap(a, b):
    return b, a

x, y = 10, 20
print(f"Before: x={x}, y={y}")
x, y = swap(x, y)
print(f"After: x={x}, y={y}")

# Or more Pythonically without function:
x, y = y, x

7. Write a function that returns both min and max from a list

Answer:
Example:

python

def min_max(numbers):
    if not numbers:
        return None, None
    return min(numbers), max(numbers)

numbers = [4, 2, 9, 1, 7]
min_val, max_val = min_max(numbers)
print(f"Min: {min_val}, Max: {max_val}")

8. Create a function that returns success status along with result/error

Answer:
Example:

python

def safe_divide(a, b):
    try:
        result = a / b
        return True, result
    except ZeroDivisionError:
        return False, "Cannot divide by zero"

success, result = safe_divide(10, 2)
if success:
    print(f"Result: {result}")
else:
    print(f"Error: {result}")

Advanced Questions

9. How can multiple return values help with function composition?

Answer:
Multiple returns enable clean function chaining and composition.

Example:

python

def process_text(text):
    words = text.split()
    word_count = len(words)
    char_count = len(text)
    return words, word_count, char_count

def analyze_words(words):
    longest = max(words, key=len)
    shortest = min(words, key=len)
    return longest, shortest

text = "Python is awesome for data analysis"
words, count, chars = process_text(text)
longest, shortest = analyze_words(words)

print(f"Words: {count}, Chars: {chars}")
print(f"Longest: '{longest}', Shortest: '{shortest}'")

10. How would you handle optional return values?

Answer:
Return None for optional values or use different return patterns.

Example:

python

def find_element(lst, target):
    if target in lst:
        index = lst.index(target)
        return True, index
    return False, None

found, position = find_element([1, 2, 3, 4], 3)
if found:
    print(f"Found at position {position}")
else:
    print("Not found")

Real-World Scenario Questions

11. Create a function for user registration that returns multiple status indicators

Answer:
Example:

python

def register_user(username, email, password):
    # Simulate validation
    is_valid_username = len(username) >= 3
    is_valid_email = '@' in email
    is_strong_password = len(password) >= 8
    
    success = is_valid_username and is_valid_email and is_strong_password
    messages = []
    
    if not is_valid_username:
        messages.append("Username too short")
    if not is_valid_email:
        messages.append("Invalid email")
    if not is_strong_password:
        messages.append("Weak password")
    
    return success, messages

success, errors = register_user("al", "invalid", "weak")
if success:
    print("Registration successful!")
else:
    print("Errors:", errors)

12. Write a function that returns multiple statistics from data

Answer:
Example:

python

def calculate_statistics(data):
    if not data:
        return 0, 0, 0, 0
    
    total = sum(data)
    count = len(data)
    average = total / count
    variance = sum((x - average) ** 2 for x in data) / count
    
    return total, count, average, variance

sales = [100, 200, 150, 300, 250]
total_sales, transactions, avg_sale, variance = calculate_statistics(sales)
print(f"Total: ${total_sales}, Transactions: {transactions}")
print(f"Average: ${avg_sale:.2f}, Variance: {variance:.2f}")

Best Practices Questions

13. When should you use multiple return values vs returning a dictionary?

Answer:
Use multiple return values when:

• The number of returned values is small and fixed
• The values have clear, distinct meanings
• You want the convenience of unpacking

Use a dictionary when:

• You have many optional return values
• The values are related configuration options
• You need to add more values later without breaking existing code

14. What are the advantages of multiple return values?

Answer:

• Clean syntax: Easy unpacking into meaningful variable names
• Performance: Tuples are lighter than dictionaries
• Immutability: Returned values can’t be accidentally modified
• Clarity: Function signature shows what’s being returned

15. How can you document multiple return values?

Answer:
Use docstrings to clearly document each returned value.

Example:

python

def process_data(data):
    """
    Process input data and return statistics.
    
    Returns:
        tuple: A tuple containing:
            - total (float): Sum of all values
            - count (int): Number of elements
            - average (float): Mean value
            - max_value (float): Maximum value
    """
    total = sum(data)
    count = len(data)
    average = total / count
    max_value = max(data)
    return total, count, average, max_value

Error Handling Questions

16. How would you handle functions that might return different numbers of values?

Answer:
Return consistent structure, use None for optional values, or use different functions.

Example:

python

def search_items(query, find_all=False):
    results = ["result1", "result2", "result3"]  # Mock results
    
    if find_all:
        return True, results, len(results)
    else:
        return True, results[0] if results else None

found, result, count = search_items("test", find_all=True)
found, first_result = search_items("test")