A function communicates results back to its caller through the return keyword, which simultaneously signals the termination of the function’s execution. Any code written below return inside the function body will not run unless an exception-handling mechanism intervenes.

def demo():
    print("Starting")
    return "finished"
    print("This line never executes")


def demo_with_finally():
    try:
        print("Entering try")
        return "result"
    finally:
        print("Cleanup in finally")

print(demo())
print('-----------------')
print(demo_with_finally())

Running this code produces:

Starting
finished
-----------------
Entering try
Cleanup in finally
result

The finally block is always executed before the function actually returns, even though the return statemant appears inside try.

Every function without an explicit return implicitly produces None. Whether a function needs return depends entirely on its responsibilities; utility functions that produce side effects (such as printing) can omit it.

def draw_separator():
    print('-' * 12)


def repeat_separator(times):
    counter = 0
    while counter < times:
        draw_separator()
        counter += 1

output = repeat_separator(3)
print(output)

The console shows three dashed lines followed by None because repeat_separator does not return anythign explicitly.

Integer return values often encode status rather than computation results. While return 0 conventionally signals successful completion, return 1 or return -1 typically indicate failure modes. In boolean contexts, 1 maps to True and 0 to False, but using a non-zero return to convey error is independent of truthiness.

def divide(dividend, divisor):
    if divisor == 0:
        return -1   # failure indicator
    return dividend / divisor

outcome = divide(10, 0)
if outcome == -1:
    print("Cannot divide by zero")
else:
    print(f"Result: {outcome}")

A function can return objects of any type. When multiple values are separated by commas, Python automatical packs them into a tuple.

def single_value():
    return {"status": "ok"}

def multiple_values():
    return 1, 2, 3

first = single_value()
second = multiple_values()
print(type(first), first)
print(type(second), second)

Output:

<class 'dict'> {'status': 'ok'}
<class 'tuple'> (1, 2, 3)

Because functions are first-class objects, a function’s return value can be passed directly to another function.

def fetch(value):
    return value + 10

def display(content):
    print(content)

temp = fetch(5)
display(temp)

print writes to standard output without affecting program flow, whereas return hands a value back to the caller and ends the function. They serve distinct roles, though they can appear together.

def get_greeting(name):
    print(f"Generating greeting for {name}")
    return f"Hello, {name}!"

message = get_greeting("Alice")
print(message)

Inside the __str__ method of a class, return must provide a string. Returning None or any non‑string type causes a TypeError at runtime.

class User:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"User: {self.name}"

user = User("Bob")
print(user)