How to Exit a Function in Python

To exit a function in Python, use return. It stops the function on that line and hands a value back to the caller; a bare return hands back None. Code after it never runs:

def ship(order):
    if not order:
        return          # leave early, returns None
    print("shipping", order)

In this tutorial, I’ll walk through every way out of a function I actually use, all run on Python 3.12.5 in a Windows Command Prompt.

That covers guard clauses, raising errors, break versus return, nested loops, sys.exit(), finally and generators.

Exit a function early with return and guard clauses

A guard clause checks for a bad case at the top and returns right away, so the main logic doesn’t sit inside nested if blocks. For the full picture of return values, see my Python return statement guide:

def apply_discount(total, coupon):
    if total <= 0:
        return 0.0                  # guard clause: leave right away
    if coupon is None:
        return total
    print(f"  applying {coupon}")
    return round(total * 0.90, 2)

def log_order(order_id):
    print(f"  logged {order_id}")   # no return statement at all

print(apply_discount(0, "SAVE10"))
print(apply_discount(84.50, None))
print(apply_discount(84.50, "SAVE10"))
print(log_order("A-1001"))

Output:

0.0
84.5
  applying SAVE10
76.05
  logged A-1001
None

A function without any return still exits at its last line, and the caller gets None.

Exit a function by raising an exception

When the input is wrong, don’t return a fake value. Raise an exception: the function stops, and the caller decides what to do:

def charge_card(amount):
    if amount <= 0:
        raise ValueError(f"amount must be positive, got {amount}")
    return f"charged ${amount:.2f}"

for amount in (49.99, -5):
    try:
        print(charge_card(amount))
    except ValueError as err:
        print("declined:", err)

Output:

charged $49.99
declined: amount must be positive, got -5

The -5 charge never reaches the return line. If the condition you’re leaving is an if block rather than a function, read how to exit an if statement in Python.

What’s the difference between break and return in a function?

break leaves only the innermost loop, and the function keeps going. return leaves every loop and the function at once, which makes it the clean way out of nested loops. More on loop control in Python break and continue:

orders = [("Austin", [120.00, 89.99]), ("Denver", [45.50, 310.00]), ("Boston", [12.25])]

def scan_with_break(limit):
    for city, totals in orders:
        for total in totals:
            if total > limit:
                print(f"  break at {city} ${total:.2f}")
                break                # leaves the inner loop only
    return "checked every city"

def scan_with_return(limit):
    for city, totals in orders:
        for total in totals:
            if total > limit:
                return city, total   # leaves both loops and the function
    return None

print(scan_with_break(100))
print(scan_with_return(100))
print(scan_with_return(500))

Output:

  break at Austin $120.00
  break at Denver $310.00
checked every city
('Austin', 120.0)
None

Should you use sys.exit() or return inside a function?

sys.exit() doesn’t exit the function; it raises SystemExit and ends the whole program unless something catches it. That’s a separate job, covered in how to exit a Python program:

import sys

def load_config(path):
    if not path.endswith(".toml"):
        sys.exit(f"bad config file: {path}")
    return {"path": path}

try:
    load_config("settings.ini")
except SystemExit as exc:
    print("caught SystemExit, code:", exc.code)

print(load_config("settings.toml"))
load_config("settings.ini")
print("this line never runs")

Output:

caught SystemExit, code: bad config file: settings.ini
{'path': 'settings.toml'}
bad config file: settings.ini

In reusable functions, I return or raise and let the script’s entry point call sys.exit().

Does finally run when a function returns?

Yes. A finally block runs after return but before the caller gets the value, so cleanup always happens:

def close_register(day):
    try:
        print(f"  counting cash for {day}")
        return "closed"
    finally:
        print("  drawer locked")    # runs after return, before the caller resumes

print(close_register("2026-10-20"))

Output:

  counting cash for 2026-10-20
  drawer locked
closed

Note that return only works inside a def; at module level it’s a syntax error, explained in SyntaxError: return outside function.

Use return to stop a generator function

In a generator, return ends the iteration. Any value you return isn’t yielded; it rides along on StopIteration.value:

def read_invoices(rows):
    for row in rows:
        if row == "END":
            return f"stopped at row {rows.index(row)}"   # ends the generator
        yield row

print(list(read_invoices(["INV-1", "INV-2", "END", "INV-3"])))

gen = read_invoices(["INV-7", "END"])
next(gen)
try:
    next(gen)
except StopIteration as stop:
    print("StopIteration value:", stop.value)

Output:

['INV-1', 'INV-2']
StopIteration value: stopped at row 1

If you’re still exploring functions, these come next:

• Return multiple values from a function in Python
• Define a function in Python
• Python while loop

Frequently asked questions