Return values in Python - Deep Dive

Overview - Return values

What is it?

Return values are the results that a function sends back after it finishes running. When you call a function, it can do some work and then give you back a value to use later. This lets you reuse code and get answers from functions instead of just making them do things silently.

Why it matters

Without return values, functions would only perform actions without giving any feedback or results. This would make programs less flexible and harder to build because you couldn't get information out of functions to use elsewhere. Return values let you build programs that solve problems step-by-step and share results between parts.

Where it fits

Before learning return values, you should understand what functions are and how to define and call them. After mastering return values, you can learn about multiple return values, how to handle them, and advanced topics like generators or async functions that also produce results.

Mental Model

Core Idea

A return value is the answer a function gives back after doing its job, like handing you a finished product.

Think of it like...

Imagine you ask a friend to bake a cake. The cake they give you back is like the return value — the result of their work you can enjoy or use.

Function call
   │
   ▼
[Function does work]
   │
   ▼
[Return value sent back]
   │
   ▼
Caller receives value

Build-Up - 6 Steps

1

Foundation

What is a return value?

Concept: Introduce the idea that functions can send back a result after running.

In Python, a function can use the 'return' keyword to send a value back to where it was called. For example: def add(a, b): return a + b result = add(2, 3) print(result) # This will print 5

Result

The program prints 5 because the function returned the sum of 2 and 3.

Understanding that functions can give back results lets you write code that produces useful answers, not just actions.

2

Foundation

Return vs print difference

Concept: Explain the difference between returning a value and printing it inside a function.

Printing shows output on the screen but does not send a value back to the caller. Returning sends a value back to be used later. Example: def greet(): print('Hello') # prints but returns None message = greet() print('Returned:', message) # prints 'Returned: None'

Result

The function prints 'Hello' but returns None, so 'Returned: None' is printed next.

Knowing the difference prevents confusion between showing output and passing data between parts of your program.

3

Intermediate

Returning multiple values

🤔Before reading on: do you think a function can return more than one value at once? Commit to your answer.

Concept: Functions can return multiple values packed as a tuple, which can be unpacked by the caller.

Example: def get_name_and_age(): return 'Alice', 30 name, age = get_name_and_age() print(name) # Alice print(age) # 30

Result

The program prints 'Alice' and '30' because the function returned two values together.

Understanding multiple return values lets you send complex results from functions cleanly and use them easily.

4

Intermediate

Return without a value

🤔Before reading on: what do you think happens if a function has a return statement with no value? Commit to your answer.

Concept: A return statement without a value makes the function return None, which means 'no value'.

Example: def do_nothing(): return result = do_nothing() print(result) # prints None

Result

The program prints None because the function returned no value explicitly.

Knowing that return without value means None helps avoid bugs when functions seem to return nothing.

5

Advanced

Return stops function execution

🤔Before reading on: does code after a return statement inside a function run? Commit to your answer.

Concept: When a function hits a return statement, it immediately stops running and sends back the value.

Example: def check_number(x): if x > 0: return 'Positive' print('This line runs only if x <= 0') print(check_number(5)) # prints 'Positive' print(check_number(-1)) # prints the message and None

Result

For 5, the function returns 'Positive' and stops. For -1, it prints the message and returns None.

Understanding that return ends function execution helps control flow and avoid unexpected behavior.

6

Expert

Return values and function call stack

🤔Before reading on: do you think return values affect how functions are stacked and unstacked in memory? Commit to your answer.

Concept: Return values are passed back through the call stack, allowing nested functions to communicate results up the chain.

Example: def inner(): return 10 def outer(): value = inner() return value * 2 print(outer()) # prints 20

Result

The program prints 20 because the inner function returns 10, which outer doubles and returns.

Knowing how return values flow through nested calls clarifies how complex programs pass data between layers.

Under the Hood

When a function is called, Python creates a new frame in the call stack to run it. The 'return' statement sends a value back to the caller and removes the function's frame from the stack. This value can then be used or stored by the caller. If no return is given, Python returns None by default.

Why designed this way?

This design allows functions to be modular and reusable, producing results that can be combined or processed further. Returning values instead of just printing or changing global state makes programs easier to test, debug, and maintain.

Caller calls function
   │
   ▼
┌───────────────┐
│ Function Frame │
│  Executes code │
│  return value │
└───────────────┘
   │
   ▼
Caller receives value

Myth Busters - 4 Common Misconceptions

Quick: Does a function always return the last value it computed automatically? Commit to yes or no.

Common Belief: A function automatically returns the last expression's value even without a return statement.

Reality: If a function has no return statement, it returns None, regardless of any calculations inside.

Why it matters: Assuming a function returns a value when it doesn't can cause bugs where variables unexpectedly become None.

Quick: Can a function return multiple separate values without packing them? Commit to yes or no.

Common Belief: Functions can return multiple separate values independently without grouping them.

Reality: Functions return multiple values as a single tuple, which can be unpacked by the caller.

Why it matters: Misunderstanding this leads to errors when trying to assign multiple return values incorrectly.

Quick: Does code after a return statement inside a function always run? Commit to yes or no.

Common Belief: All code in a function runs even after a return statement.

Reality: Code after a return statement does not run because return immediately exits the function.

Why it matters: Expecting code after return to run can cause logic errors and confusion about program flow.

Quick: Is printing inside a function the same as returning a value? Commit to yes or no.

Common Belief: Printing a value inside a function is the same as returning it.

Reality: Printing only shows output on screen; it does not send a value back to the caller.

Why it matters: Confusing print and return leads to programs that appear to work but fail when trying to use function results.

Expert Zone

1

Return values can be any Python object, including functions, classes, or generators, enabling powerful patterns like closures and coroutines.

2

Using return statements strategically can optimize performance by exiting early and avoiding unnecessary computation.

3

In recursive functions, return values are essential to propagate results back through multiple layers of calls.

When NOT to use

Avoid relying on return values when side effects or state changes are the main goal; in such cases, use procedures that modify objects or global state. Also, for asynchronous operations, use async/await patterns instead of simple return values.

Production Patterns

In real-world code, return values are used to pass data between layers, handle errors by returning status codes or exceptions, and build pipelines where each function transforms data and returns it for the next step.

Connections

Functions

Return values are a core feature of functions, enabling them to produce outputs.

Understanding return values deepens your grasp of how functions work as building blocks in programming.

Error handling

Return values often carry success or error information, connecting to how programs manage failures.

Knowing how return values signal errors helps design robust and clear error handling strategies.

Mathematics - Functions

Programming functions with return values mirror mathematical functions that map inputs to outputs.

Seeing this connection clarifies why return values are fundamental: they represent the output of a process given inputs.

Common Pitfalls

#1 Expecting a function to return a value when it only prints.

Wrong approach:

def say_hello():
print('Hello')

result = say_hello()
print(result) # prints None

Correct approach:

def say_hello():
return 'Hello'

result = say_hello()
print(result) # prints 'Hello'

Root cause:

Confusing printing output with returning a value causes unexpected None results.

#2 Writing code after return expecting it to run.

Wrong approach:

def check(x):
return x > 0
print('This will never run')

Correct approach:

def check(x):
if x > 0:
return True
print('This runs only if x <= 0')
return False

Root cause:

Not realizing return exits the function immediately leads to unreachable code.

#3 Trying to assign multiple return values without unpacking.

Wrong approach:

def get_coords():
return 10, 20

coords = get_coords()
print(coords[0]) # works

x, y = coords # correct unpacking

x, y = get_coords() # also correct

x = get_coords() # x is a tuple, not a single value

Correct approach:

x, y = get_coords() # unpack tuple into variables

Root cause:

Misunderstanding that multiple returns are packed as a tuple causes confusion in variable assignment.

Key Takeaways

Return values let functions send results back to the place where they were called, enabling data flow in programs.

A function without a return statement returns None by default, which means 'no value'.

The return statement immediately stops function execution and sends the value back.

Functions can return multiple values packed as a tuple, which can be unpacked by the caller.

Distinguishing between printing and returning is crucial to avoid bugs and write reusable code.