Multiple return values in Python - Step-by-Step Execution

Concept Flow - Multiple return values

Function called

↓

Execute function body

↓

Prepare multiple values

↓

Return values as tuple

↓

Caller receives tuple

↓

Unpack or use returned values

When a function returns multiple values, it actually returns them as a tuple. The caller can then unpack or use these values separately.

Execution Sample

Python

def get_stats(numbers):
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    return total, count, average

result = get_stats([10, 20, 30])

This function calculates total, count, and average of a list and returns all three values together.

Execution Table

Step	Action	Variables	Returned Value	Notes
1	Function get_stats called with [10, 20, 30]	numbers=[10,20,30]		Start function execution
2	Calculate total = sum(numbers)	total=60		Sum of list elements
3	Calculate count = len(numbers)	count=3		Number of elements
4	Calculate average = total / count	average=20.0		Average value
5	Return total, count, average	total=60, count=3, average=20.0	(60, 3, 20.0)	Multiple values returned as tuple
6	Assign returned tuple to result	result=(60, 3, 20.0)		Caller receives tuple

💡 Function completes after returning the tuple of three values

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
numbers	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]
total	undefined	60	60	60	60
count	undefined	undefined	3	3	3
average	undefined	undefined	undefined	20.0	20.0
result	undefined	undefined	undefined	undefined	(60, 3, 20.0)

Key Moments - 2 Insights

Why does the function return a single tuple instead of separate values?

The function returns multiple values separated by commas, which Python automatically packs into a tuple (see execution_table step 5). This tuple is a single object containing all values.

How can the caller use the multiple returned values?

The caller receives a tuple (execution_table step 6). They can unpack it into separate variables or use it as a tuple directly.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what is the returned value?

A (60, 3, 20.0)

B 60, 3, 20.0

C [60, 3, 20.0]

D None

💡 Hint

Check the 'Returned Value' column at step 5 in execution_table

At which step is the variable 'average' first assigned a value?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Variables' column in execution_table for when 'average' appears

If the function returned only 'total' instead of multiple values, how would the 'result' variable change?

A result would be a tuple with one element

B result would be a list

C result would be a single number, not a tuple

D result would be undefined

💡 Hint

Refer to how multiple values are packed into a tuple in execution_table step 5 and 6

Concept Snapshot

def func():
    return val1, val2, val3

# Returns multiple values as a tuple
# Caller can unpack: a, b, c = func()
# Or use as tuple: result = func()

Full Transcript

This example shows a Python function returning multiple values. The function get_stats calculates total, count, and average of a list. It returns these three values separated by commas. Python packs them into a tuple automatically. The caller receives this tuple and can unpack or use it. The execution table traces each step: calling the function, calculating variables, returning the tuple, and assigning it to result. Variables change as the function runs, and the final result is a tuple with three values. Beginners often wonder why multiple values are returned as one tuple and how to use them. The quiz questions help check understanding of these points.