What’s the cleanest way to exit a function?

General Discussions
,
#1

What is the best way to exit a function in Python (which has no return value) before the function completes, such as when a check fails?

Let’s assume I have a function that is called within an iteration, and the function does not return any value. The desired behavior is explained in the following pseudocode:

for element in some_list: foo(element)

def foo(element): do something if check is true: do more (because check was successful) else: return None do much much more…

In this case, when the check fails, I return None, which bothers me since I don’t need to return anything. Is there a better way to exit a function early in Python when a check fails, without returning None? I am looking for a cleaner solution to “exit function” when the check fails in the body of the function.

#2

Hey @isha.tantia

Using return without a value can be a clean way to exit a function early, especially when you don’t need to return any specific value. It keeps things simple and focused. For example:

for element in some_list:
    foo(element)

def foo(element):
    do_something()
    if not check:
        return  # Exit function early without returning any value
    do_more()  # Continue if check passes
    do_much_more()

It’s straightforward and easy to read, particularly when there’s no need to indicate success or failure explicitly.

#3

Absolutely, @panchal_archanaa. But if you want more control over how the calling context handles such situations, raising an exception can be a powerful alternative. It allows the caller to decide what to do when something goes wrong. For instance:

for element in some_list:
    try:
        foo(element)
    except SomeConditionError:
        handle_error()

def foo(element):
    do_something()
    if not check:
        raise SomeConditionError("Check failed, exiting function")
    do_more()
    do_much_more()

class SomeConditionError(Exception):
    pass

This way, you’re not just exiting the function; you’re signaling that something specific went wrong, giving the caller flexibility to handle it appropriately."

#4

Hey All!

Both approaches are great, @panchal_archanaa and @tim-khorev! Here’s another perspective: if you want a middle ground between silently exiting and raising an exception, you can return a sentinel value. This makes it explicit whether the function succeeded or failed, without relying on exceptions. For example:

for element in some_list:
    if not foo(element):
        continue  # Skip further processing for this element

def foo(element):
    do_something()
    if not check:
        return False  # Indicate failure and exit early
    do_more()
    do_much_more()
    return True  # Indicate success

This way, the caller can decide how to proceed based on the returned value, and the code flow remains explicit and understandable. It’s especially handy when failure isn’t an “exceptional” condition but part of normal processing.