How to Return Multiple Values from a Function in Python

If you want one Python function to give back more than one result, the most common solution is simple: return the values separated by commas.

In practice, Python usually packs those values into a tuple. You can then unpack that tuple into separate variables.

Quick answer

def get_name_and_age():
    return "Alice", 25

name, age = get_name_and_age()

print(name)
print(age)

Output:

Alice
25

In Python, returning multiple values usually means returning a tuple. You can unpack the result into separate variables.

What this page helps you do

This page shows you how to:

  • Return two or more values from one function
  • Store the returned values in separate variables
  • Understand that Python usually returns a tuple
  • Choose between a tuple, list, or dictionary based on clarity

If you are new to functions, see Python functions explained first.

The simplest way: return values separated by commas

The easiest way to return multiple values is to put them after return, separated by commas.

def get_coordinates():
    return 10, 20

result = get_coordinates()
print(result)
print(type(result))

Output:

(10, 20)
<class 'tuple'>

Even though you wrote return 10, 20, Python created one tuple containing both values.

This works well when:

  • You have a small number of returned values
  • The meaning of each value is clear
  • The order is easy to remember

Here is another example:

def get_min_and_max():
    return 3, 9

values = get_min_and_max()
print(values)

Output:

(3, 9)

If you want to understand function return values more clearly, read return values in Python functions.

How to unpack the returned values

Unpacking means storing each returned item in its own variable.

def get_name_and_age():
    return "Alice", 25

name, age = get_name_and_age()

print(name)
print(age)

Output:

Alice
25

This is often easier to read than using a single variable:

def get_name_and_age():
    return "Alice", 25

result = get_name_and_age()

print(result[0])
print(result[1])

Output:

Alice
25

Unpacking is usually better for beginners because the variable names make the result clearer.

Important rule

The number of variables must match the number of returned values.

This works:

def get_dimensions():
    return 1920, 1080

width, height = get_dimensions()
print(width)
print(height)

This does not work:

def get_dimensions():
    return 1920, 1080

width = get_dimensions()

The code above is valid Python, but width will contain the whole tuple, not just the first value.

If you actually want separate values, you must unpack them.

Returning a tuple explicitly

You can also write the tuple with parentheses.

def get_status():
    return ("success", 200)

message, code = get_status()

print(message)
print(code)

Output:

success
200

This behaves the same as:

def get_status():
    return "success", 200

In most cases, parentheses are optional. Many programmers still use them because they make it more obvious that the function returns a tuple.

If tuples are new to you, see what is a tuple in Python.

When to return a list or dictionary instead

A tuple is not always the clearest choice.

Return a list when you have similar items

Use a list when the function returns a collection of values of the same kind.

def get_scores():
    return [85, 90, 78]

scores = get_scores()
print(scores)

Output:

[85, 90, 78]

A list makes sense here because the result is one group of similar items.

Return a dictionary when names matter

Use a dictionary when each returned value needs a label.

def get_user():
    return {
        "name": "Alice",
        "age": 25,
        "country": "Canada"
    }

user = get_user()
print(user["name"])
print(user["age"])
print(user["country"])

Output:

Alice
25
Canada

A dictionary is often easier to read when:

  • You return many values
  • The order is hard to remember
  • The meaning of each value matters more than position

Compare these two styles:

def get_user_tuple():
    return "Alice", 25, "Canada"

name, age, country = get_user_tuple()
print(name, age, country)

def get_user_dict():
    return {"name": "Alice", "age": 25, "country": "Canada"}

user = get_user_dict()
print(user["name"], user["age"], user["country"])

Both work. Choose the one that makes your code easier to understand.

Common errors when returning multiple values

There are a few beginner mistakes to watch for.

Unpacking into too many variables

def get_point():
    return 5, 10

x, y, z = get_point()

This raises a ValueError because the function returned only 2 values, but you tried to store them in 3 variables.

Unpacking into too few variables

def get_point():
    return 5, 10

x = get_point()
print(x)

This does not raise an error, but x becomes the whole tuple:

(5, 10)

The real unpacking error happens when you do this:

def get_point():
    return 5, 10

x, = get_point()

This raises a ValueError because Python expected 1 value but got 2.

For fixes, see:

Returning different numbers of values

Be careful not to return 1 value in one case and 2 values in another.

def get_data(found):
    if found:
        return "Alice", 25
    return "Not found"

This can confuse the code that calls the function:

name, age = get_data(False)

That code will fail because the function did not always return the same kind of result.

A clearer version would be:

def get_data(found):
    if found:
        return "Alice", 25
    return None, None

name, age = get_data(False)
print(name)
print(age)

Output:

None
None

Forgetting the return order

If your function returns values in a fixed order, make sure that order stays consistent.

def get_size():
    return 800, 600  # width, height

width, height = get_size()

If you later change the function to return height first, your code may still run but produce wrong results.

Best practices for beginners

When returning multiple values from a function:

  • Keep the return order consistent
  • Use tuple unpacking for short, simple results
  • Use dictionaries when names matter more than order
  • Use clear variable names
  • Keep the returned structure the same in all code paths

Good example:

def get_product():
    return "Book", 12.99

product_name, price = get_product()
print(product_name)
print(price)

Less clear example:

def get_product():
    return "Book", 12.99

x, y = get_product()
print(x)
print(y)

The second example works, but x and y do not tell the reader what the values mean.

Common mistakes

These problems often cause confusion:

  • Trying to use multiple variables without unpacking the returned result
  • Returning a different number of values in different code paths
  • Confusing tuple return values with separate return statements
  • Using unclear value order such as return x, y without meaningful names

If you want a refresher on what a return value is, read what is a return value in Python.

FAQ

Does Python really return multiple values?

Usually, Python returns one tuple object that contains multiple values.

Do I need parentheses when returning multiple values?

No. Parentheses are optional in most return statements, but they can improve readability.

Can I return a list instead of a tuple?

Yes. A list is useful when you want a collection of similar items that may be changed later.

Why do I get "too many values to unpack"?

Your function returned more items than the number of variables on the left side.

What is the clearest way to return many related values?

For more complex results, a dictionary is often easier to read because each value has a key.

See also