Function Returns — Sending Data Back

By the end of this lesson you can:

• Use return to hand a value back from a function, and capture it into a variable at the call site.
• Explain the difference between print (shows on screen) and return (gives back to the caller).
• Compose functions — pass the return value of one straight into another like print(square(5)).

Quick prediction. Two functions, very similar. What does each line print?

def square_print(n):
    print(n * n)

def square_return(n):
    return n * n

a = square_print(5)
b = square_return(5)

print("a is", a)
print("b is", b)

25
a is None
b is 25

The shape

def square(n):
    return n * n

That's it. return followed by any value (a number, a string, a list, the result of an expression). Whatever follows return is the value the function hands back when it's called.

Catch the value at the call site

The call now evaluates to that value — it's no longer just an action, it's an expression. You can store it in a variable, do maths with it, print it, anything:

result = square(7)       # store it
print(result)            # → 49

total = square(3) + square(4)   # combine returns
print(total)             # → 9 + 16 = 25

Compose: feed one return into another

Because the call evaluates to a value, you can pass it straight into another call. This is where functions become a real building set:

print(square(5))           # → 25
print(square(square(3)))   # square(3)=9, then square(9)=81

return exits the function immediately

The moment Python hits return, the function stops. Anything after it never runs:

def is_positive(n):
    if n > 0:
        return True
    return False
    print("you'll never see this")   # unreachable

This makes return useful for early exits — handle a special case, return, done.

A function without return hands back None

If you don't write a return, Python silently returns the special value None for you. That's why a = square_print(5) in the warm-up left a as None. None is Python's way of saying "there's no value here."

print vs return · the table

# print(value)
#   - shows the value on the screen, for a human
#   - the rest of the program can't use what was printed
#
# return value
#   - hands the value back to whoever called the function
#   - nothing appears on the screen unless someone prints it
#   - the rest of the program CAN store it, combine it, pass it on

The job

A canteen sells nasi lemak at RM 4.50 a plate. You need a function that tells you the total for any number of plates, plus a 6% service charge. You'll then build a tiny "table of totals" that prints the cost for 1, 2, 3, 4, and 5 plates.

Step 1 · Write the function

def total_for(plates):
    subtotal = plates * 4.50
    grand = subtotal * 1.06     # 6% service
    return grand

No print anywhere in the function. Just compute and return.

Step 2 · Use it in a loop

for n in range(1, 6):
    print(n, "plate(s) →", total_for(n))

1 plate(s) → 4.77
2 plate(s) → 9.54
3 plate(s) → 14.31
4 plate(s) → 19.080000000000002
5 plate(s) → 23.85

Ignore the long decimal — that's just how floats work, not your bug. The point: one tiny function, five different totals, all from one call inside a loop.

Step 3 · Compose two functions

Round the total to 2 decimal places with the built-in round() — composed straight onto our return value:

for n in range(1, 6):
    print(n, "plate(s) → RM", round(total_for(n), 2))

1 plate(s) → RM 4.77
2 plate(s) → RM 9.54
3 plate(s) → RM 14.31
4 plate(s) → RM 19.08
5 plate(s) → RM 23.85

Step 4 · The whole file

Save as nasi_lemak_total.py:

Code

# nasi_lemak_total.py — return values in action

def total_for(plates, price=4.50, service=0.06):
    subtotal = plates * price
    grand = subtotal * (1 + service)
    return grand

# main program — a tiny totals table
print("Plates | Total")
print("-" * 18)
for n in range(1, 6):
    rm = round(total_for(n), 2)
    print(" ", n, "    | RM", rm)

# and one custom case — bulk order, special price
bulk = round(total_for(20, price=4.00), 2)
print()
print("Bulk order (20 plates @ RM 4.00):", "RM", bulk)

Sample run

Plates | Total
------------------
  1     | RM 4.77
  2     | RM 9.54
  3     | RM 14.31
  4     | RM 19.08
  5     | RM 23.85

Bulk order (20 plates @ RM 4.00): RM 84.8

Three tasks. Every function should return its answer — no print inside the function.

def double(n):
    return n * 2

result = double(5)
print(result)   # → 10

def c_to_f(c):
    return c * 9 / 5 + 32

for c in [0, 10, 20, 30, 40]:
    print(c, "C →", c_to_f(c), "F")

def add(a, b):
    return a + b

def square(n):
    return n * n

print(square(add(3, 4)))   # → 49

return is how a function sends a value back to whoever called it. The call site can then capture the value into a variable, combine it with other values, or pass it straight into another function call. The moment return runs, the function exits — so anything after it doesn't happen. A function with no return silently returns None. Functions that compute answers should return; functions whose only job is to show things to a human can print. Next lesson we'll practise building a math toolbox where every function returns its answer cleanly.