Return Statement

The return statement is a control flow mechanism used within a function to immediately terminate its execution, pop its local frame from the call stack, and pass an object reference back to the caller’s scope.

return [expression_list]

Execution Mechanics

When the Python interpreter encounters a return statement, it performs the following sequence of operations:

1. Expression Evaluation: It evaluates the expression_list. If no expression is provided, it evaluates to the None singleton.
2. Stack Unwinding: It destroys the local namespace associated with the function’s execution frame.
3. Control Transfer: It passes the evaluated object reference back to the exact point in the call stack where the function was invoked.

Syntactic Behaviors

Implicit vs. Explicit Returns If a function reaches the end of its code block without encountering a return statement, Python implicitly executes return None. A bare return statement without an expression also yields None.

def implicit_none():
    x = 10
    # Implicitly executes: return None

def explicit_none():
    return  # Evaluates to None

Tuple Packing If the expression_list contains multiple comma-separated expressions, Python automatically packs them into a single tuple object. The return statement always returns exactly one object; multiple values are simply a single tuple containing multiple references.

def return_multiple():
    return 1, "string", [3, 4]  # Returns a single tuple: (1, 'string', [3, 4])

Interaction with Exception Handling

The return statement exhibits specific behavior when used in conjunction with try...finally blocks. If a return is triggered inside a try block, the interpreter guarantees that the finally block will execute before the function actually yields control back to the caller.

If the finally block also contains a return statement, the return value from the finally block overrides the return value from the try block.

def exception_override():
    try:
        return "Try Return"
    finally:
        return "Finally Return" # This value overrides "Try Return"

Interaction with Generators

In a generator function (a function containing yield statements), the return statement serves a different internal purpose. Executing return expression inside a generator does not yield a value to the iteration sequence; instead, it raises a StopIteration exception to terminate the generator. The evaluated expression is attached to the StopIteration exception as its value attribute.

def generator_return():
    yield 1
    return "Termination Value" # Raises StopIteration("Termination Value")

Master Python with Deep Grasping Methodology!

Learn More