Return Values: Sending an Answer Back

By the end of this lesson you can:

• Explain the difference between print inside a function and return.
• Store a returned value in a variable, or use the call directly inside an expression.
• Say what a function returns when it has no return at all.
• Use an early return, and return two values at once.

Two functions that look nearly identical. Write down what you think each print at the bottom shows, before you run it.

def double_a(n):
    print(n * 2)

def double_b(n):
    return n * 2


x = double_a(5)
y = double_b(5)

print("x is", x)
print("y is", y)

10
x is None
y is 10

print puts characters on the screen for a human to read. return hands a value back to the code that made the call. They are not alternatives — they do completely different jobs.

def total_price(price, qty):
    """Give back the cost of qty items."""
    return price * qty


lunch = total_price(4.50, 2)      # lunch is now 9.0
drinks = total_price(2.00, 3)     # drinks is now 6.0
print("Bill: $", lunch + drinks)

Because total_price(...) is a value once it returns, you can put it anywhere a value belongs:

print(total_price(4.50, 2))              # straight into print
grand = total_price(4.50, 2) + 3.00      # into a sum
if total_price(4.50, 2) > 10:            # into a condition
    print("Over budget!")

return stops the function immediately. Nothing after it runs. That is a feature, not a limitation — it lets you deal with the awkward case first and leave:

def grade(mark):
    """Return the letter grade for a mark out of 100."""
    if mark < 0 or mark > 100:
        return "Invalid"      # leave straight away
    if mark >= 80:
        return "A"
    if mark >= 65:
        return "B"
    if mark >= 50:
        return "C"
    return "F"

No else anywhere, and it still cannot fall through: once one return runs, the function is over.

Two answers at once. Separate them with a comma, and unpack them at the call:

def high_and_low(marks):
    """Return the best and worst mark in one go."""
    return max(marks), min(marks)


best, worst = high_and_low([72, 55, 91, 68])
print(best, worst)         # 91 55

Each function answers one question, and the last few lines put the answers together. Type it and run it.

def subtotal(price, qty):
    """Cost before any discount or tax."""
    return price * qty


def discount(amount, is_student):
    """Return the discount in dollar: 10% for students, nothing otherwise."""
    if is_student:
        return amount * 0.10
    return 0


def service_charge(amount):
    """Return the 6% service charge."""
    return amount * 0.06


def final_total(price, qty, is_student):
    """Put the three together and return what the customer pays."""
    base = subtotal(price, qty)
    after_discount = base - discount(base, is_student)
    return after_discount + service_charge(after_discount)


bill = final_total(4.50, 2, True)
print(f"Total to pay: $ {bill:.2f}")

Output

Total to pay: $8.59

Look at what final_total does: it calls three other functions and returns the result of combining them. Not one of the four contains a print — the only printing happens on the last line, where a human is actually being shown something.

Prove it to yourself: add this line at the bottom, with no change to any function above.

print("Ten of them would be $", final_total(4.50, 10, False))

print shows a human; return hands a value back to the code. A call that returns is a value, so it can go into a variable, a sum, or a condition. A function without return gives back None, which is where mysterious TypeErrors come from. return ends the function on the spot, which makes early returns tidy, and a comma lets one function return two answers.