## Introduction

While functions typically return a single value or no value at all, there are cases in which having **multiple return values in Python functions** is desirable. It is a general programming best-practice to have each function be responsible for doing one thing only, and therefore those multiple returned values **should be closely related** to a single concept.

*Syntax for Returning Multiple Values*

Python offers a convenient syntax for returning multiple values from a function. By simply separating the values with commas after the `return` keyword, you can create a collection of values that are returned as a cohesive entity.

**Example:**

def get_personal_info(): name = "Alice" age = 30 return name, age result = get_personal_info() print(result)

**Output:**

('Alice', 30)

The returned value is actually a Python tuple containing the name and age. In the example, this tuple is assigned to the variable `result`

.

## Unpacking Returned Values

To work with the individual values returned from a function, you can use a technique called unpacking. Unpacking allows you to easily assign the elements of a tuple (or any iterable) to separate variables.

**Example:**

name, age = get_personal_info() print(f"Name: {name}, Age: {age}")

**Output:**

Name: Alice, Age: 30

Here, the values returned by the `get_personal_info()`

function are unpacked into the variables `name`

and `age`

, which are then used to create a formatted message.

## Use Cases for Multiple Return Values

### Use Case 1: Mean, Median, and Mode Statistics

Consider a scenario where you’re working on a data analysis project and frequently need to compute statistics like mean, median, and mode for a given list of numbers. Python’s `statistics`

module provides functions to calculate these statistics.

**Example:**

import statistics as stat data = [2, 3, 3, 5, 5, 7, 7, 7, 8, 9] mean = stat.mean(data) median = stat.median(data) mode = stat.mode(data) print("Mean:", mean) print("Median:", median) print("Mode:", mode)

**Output:**

Mean: 5.6 Median: 6.0 Mode: 7

Instead of repeatedly calling the `mean`

, `median`

, and `mode`

, you can encapsulate all three computations inside a function called `calculate_stats`

:

def calculate_stats(numbers): mean = statistics.mean(numbers) median = statistics.median(numbers) mode = statistics.mode(numbers) return mean, median, mode

This function returns all three statistics using the multiple-return-value syntax. Notice that the function adheres to best-practices by having return values that are all closely related and aligned under the single concept of “stats”.

With the `calculate_stats()`

function in place, the earlier example can be restructured as follows:

import statistics as stat data = [2, 3, 3, 5, 5, 7, 7, 7, 8, 9] mean, median, mode = calculate_stats(data) print("Mean:", mean) print("Median:", median) print("Mode:", mode)

### Use Case 2: Splitting a List

Suppose you’d like to write a function that splits a list into two sub-lists, given a certain ratio of split. The function will return two values, one for each of the sub-lists.

**Example:**

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] split1, split2 = split_list(lst, 0.8) print(split1) print(split2)

**Output:**

[1, 2, 3, 4, 5, 6, 7, 8] [9, 10]

In the example above, the original list, `lst`

, is `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`

. The `split_list()`

function splits the list into two new sub-lists and returns them. The first sub-list is the initial 0.8 (i.e. 80%) of the original list, and the second is the remaining 0.2 (i.e. 20%).

`split_list()`

returns both sub-lists at once. This is convenient because you can assign both sub-lists to separate variables, as the example does with variables `split1`

and `split2`

, using one function call.

The following code is the implementation of `split_list()`

. How it actually does the split is not important to this lesson. (It does it with slicing syntax.) What is important is the last line of the function, which returns both sub-lists.

def split_list(lst, split_ratio): split_loc = round(len(lst) * split_ratio) split1 = lst[:split_loc] split2 = lst[split_loc:] return split1, split2

## Summary & Reference for Multiple Return Values in Python Functions

Returning multiple values from Python functions allows for encapsulating related information in a cohesive manner. While functions are usually designed to return a single value, there are scenarios where multiple values are useful.

Python offers a straightforward syntax for this purpose, where multiple values are separated by commas after the `return`

keyword.

def get_personal_info(): name = "Alice" age = 30 return name, age

The values returned from the function are in the form of a tuple, but they can be unpacked into individual variables using a simple assignment statement.

name, age = get_personal_info()