Return values and early exits

Most functions perform some operations and then return a value back to the caller. In Python, this is done using the return statement. When a return statement is executed, the function terminates immediately at that point and the specified value (if any) is given back to the caller. Any code after a return in the function body will not run, since the function has already exited.

If a function has a return <expression>, it will evaluate the expression and send that result back to the caller.

If a return statement has no expression (just return by itself), or if the function reaches the end without encountering any return statement, the function returns the special value None by default. None in Python represents the absence of a value. This is why by default Python functions that don’t explicitly return anything will output None if you try to capture their return value.

Basic Example of Return:

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

sum_val = add(3, 4)
print(sum_val)   # Outputs: 7

Here, return a + b exits the function add and sends the sum of a and b back to where the function was called. We store that in sum_val, which becomes 7.

Early Exit with Return: You can use return to exit a function early under certain conditions. This is often used for input validation or breaking out of a function when a result is known partway through. For example:

def check_positive(x):
    if x < 0:
        print("Number is negative, stopping early.")
        return        # exit the function early, implicitly returns None
    print("Number is positive or zero.")
    return x

Incheck_positive, if x is negative, the function prints a message and executes return with no value, causing an immediate exit (and yielding None). If x is not negative, the function proceeds to print the second message and then returns x. We can see how return allows us to skip the rest of the function when a certain branch of logic is taken. Using early returns can make code cleaner by handling “edge cases” or guard conditions upfront.

Returning Multiple Values: Python has a convenient feature where you can return multiple values from a function by separating them with commas. For example:

def get_user():
    first_name = "Jane"
    last_name = "Doe"
    age = 30
    return first_name, last_name, age

Here, get_user() Returns three values at once. In reality, Python packs these into a tuple and returns the tuple. You could capture the returned tuple and index it, or use tuple unpacking:

fname, lname, age = get_user()

After this call, fname will be "Jane", lname will be"Doe", and age will be 30. This can be convenient for functions that naturally produce multiple related results.

No Explicit Return: If you don’t include any return statement in a function, Python will automatically return None when the function finishes executing the last statement in its block. For instance:

def say_hello(name):
    print("Hello,", name)

result = say_hello("world")
print(result)   # Outputs: None

The function say_hello prints a greeting but does not return anything, so when we call it, result gets the value None. Many functions are used for their side effects (like printing or modifying a global variable) and thus return None.

Key Point: The return keyword is used to terminate a function’s execution and optionally send back a value. Once a return is executed, the function is done. If you need to stop execution early under certain conditions, you can place a condition return inside an if or other control structure. This “early return” pattern is common for input validation: check for an invalid case and return early to avoid doing the normal processing on bad data.

In summary, understanding how to use return allows you to both retrieve results from functions and control the flow of your function’s execution.