Returning Values in Python

Welcome to Returning Values and Understanding Scope in Python, and congratulations on reaching the first unit of this course! By now, we can define functions with def, call them whenever we need them, and pass data into them through parameters and arguments. That covers one direction of the conversation: information flowing in.

The other direction is still missing. So far, the only way our functions could share their work with us was by calling print inside the body, which puts text on the screen but leaves the rest of the program empty-handed. In this lesson, we will fix that with the return keyword, covering four ideas:

1. return versus print;
2. capturing a returned value in a variable;
3. using a returned value directly inside a larger expression;
4. what happens when a function has no return at all.

Here is the four-line output of the small program we will build together:

Sum: 10
Doubled: 20
Sum: 10
Captured value: None

Let's start with the simplest possible value-producing function. Its entire body is one statement:

# This function hands a value back instead of printing it
def add(a, b):
    return a + b

A few details deserve attention here:

• The return keyword lives inside the function body, so it is indented under the def header, just like any other statement in the body.
• After return comes a value or an expression; Python evaluates a + b first, then hands the result back.
• There is no print anywhere in this function. Running this definition, and even calling add(4, 6) on its own line, would show absolutely nothing on the screen.

That silence is the point. print writes text for a human to read; return sends a value back to the code that made the call. These are different jobs, and mixing them up is the most common confusion for new Python programmers.

If add shows nothing, how do we ever see the sum? We catch the value at the call site and print it ourselves:

# Capture the returned value so the program can keep using it
result = add(4, 6)
print("Sum:", result)

Let's trace the first line carefully because the order matters:

1. Python evaluates the call add(4, 6), so a becomes 4 and b becomes 6.
2. The function computes 10 and hands it back with return.
3. That 10 takes the place of the call in the expression, so the line effectively becomes result = 10.
4. Only then does the assignment happen, storing 10 in result.

The printed line comes from the caller, not from inside add. And since 10 now lives in a variable, we can reuse it as many times as we want without calling add again. Remember the ordering rule from the previous course: the def must appear above the first line that calls it.

Sum: 10

Storing the value first is convenient, but it is not required. A returned value can be used anywhere a plain value could be used:

# The returned value can be used directly in a larger expression
print("Doubled:", add(4, 6) * 2)

Reading this line from the inside out:

• add(4, 6) runs and hands back 10;
• that 10 replaces the call, leaving 10 * 2;
• the multiplication produces 20, which is finally passed to print.

Notice who is in charge here: the caller decides what to do with the value. Changing * 2 to * 3 would print Doubled: 30 without touching a single character inside add. The same idea works with comparisons or with feeding one call's result straight into another call, which is exactly how we will chain functions together later in this course.

Doubled: 20

Now for the contrast. Here is a function that does the opposite of add: it prints but never returns anything.

# No return statement: the function prints, but hands back None
def show_sum(a, b):
    print("Sum:", a + b)


captured = show_sum(4, 6)
print("Captured value:", captured)   # None

Two separate things happen on the captured = show_sum(4, 6) line. The text Sum: 10 appears immediately, produced by the print inside the function body. Then execution reaches the end of the body without meeting a return, so Python automatically hands back the special value None. The function still returns; it simply returns nothing useful, and captured is stuck holding None.

Sum: 10
Captured value: None

That None is more than a cosmetic detail. It is not a number, so writing captured * 2 would immediately crash with TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'.

A far sneakier version of the same problem appears when a function does the math but forgets the final step:

def compute_total(price, quantity):
    total = price * quantity   # computed correctly, but never handed back


total = compute_total(3, 5)
print(total)   # None, not 15

The arithmetic is perfectly right; total inside the function really does hold 15. But computing a value and handing it back are two separate acts, and only the first one happened here. The fix is a final line, return total, and the caller then prints 15.

Keep one companion rule in mind: return immediately ends the function's execution, so any statement written after return total would never run. Before writing a function, it helps to decide deliberately what its job is: to display something, to produce a value, or both. A value-producing function must return on its path.

Putting all the pieces together, here is the finished script:

# This function hands a value back instead of printing it
def add(a, b):
    return a + b


# Capture the returned value so the program can keep using it
result = add(4, 6)
print("Sum:", result)

# The returned value can be used directly in a larger expression
print("Doubled:", add(4, 6) * 2)


# No return statement: the function prints, but hands back None
def show_sum(a, b):
    print("Sum:", a + b)


captured = show_sum(4, 6)
print("Captured value:", captured)   # None

Each output line maps to exactly one statement: line one comes from print("Sum:", result), line two from the inline expression, line three from inside show_sum, and line four from the caller printing captured. Note that show_sum is left without a return on purpose as our counterexample, and that this is a plain top-level script: no wrapper function, no imports. We keep flat top-level execution (no main() or __main__ guard) only to keep these beginner demos visually simple; such guards are common when a file is meant to be imported as a module.

Sum: 10
Doubled: 20
Sum: 10
Captured value: None

The core rule of this lesson fits in four words: print shows, return gives back. Only a returned value can be captured in a variable, reused across several calculations, or dropped straight into a larger expression. A function without a return still hands something back, but that something is None, which cannot be used in arithmetic; and a function that computes a value while forgetting to return it produces the same silent None.

Coming up, we will read the finished program, rebuild it from an empty file, use returned values inline, watch None appear, and repair a function whose missing return quietly breaks its caller. Later in this course, we will look at local scope and see why, for the pure calculation functions we write here, return is the usual way to provide a function's result to its caller.

Time to open the editor and make these functions hand their values back!