Is there a label/goto in Python?

python

functions

recursion

exceptions

byNikita Barsukov·Feb 25, 2025

The short is: Python does not have a built-in goto command. However, it does have alternatives, which you can leverage to mimic goto behavior. Here's a quick example using a third-party module:

from goto import with_goto

@with_goto
def counter():
    label .start
    for x in range(1, 10):
        if x == 5:
            goto .end
        # 5 is grumpy and doesn't like parties
        print(x)
        goto .start
    label .end

counter()

While this works, I'd say always favor Python's structured flow control over goto... it's what Python would want 🐍.

Map of goto-less Python

Journeying into Python, you'll quickly realize it's a land without labels and goto. It's a highly structured and readable language, and it likes to keep things that way! Here we'll delve into alternatives Python offers that can comfortably replace goto.

Using recursion for repeated tasks

One of the most Pythonic ways of returning to a specific point in your code is by recursive function calls:

def recursive_printer(n):
    if n > 0:
        print(n)
        recursive_printer(n-1)  # Here we go again!
    else:
        print("The End, thanks for counting down with me!")

recursive_printer(5)

You get the same goto-like action, just with a function and a call stack. No snakes were harmed in the making of this code 👌.

Exceptions - more than meets the eye

Did you ever think of exceptions as a sneaky goto? Frown not, my friend. Python's exceptions are your magic wand to jump to distant lands in your code kingdom. Use wisely:

try:
    for i in range(10):
        # Oops! Stepped on a Lego!
        if i == 5: raise Exception("Jump to end")
        print(i)
except Exception as e:
    print(e)  # Prints: "Jump to end"

Loop around with break and continue

Loops in Python can feast on break and continue, becoming your informal goto. Here's how:

for i in range(1, 10):
    if i % 2 == 0:
        continue  # Even numbers? Nope, thank you!
    if i == 7:
        break  # 7 ate 9 so we flee!
    print(i)

Function mapping to control execution

Mapping functions to dictionaries allows execution of tasks based on dynamic inputs, which makes flexible execution paths possible without goto:

def cook_pasta():
    return "Pasta cooked 🍝"

def bake_pizza():
    return "Pizza baked 🍕"

recipe = {
    'pasta': cook_pasta,
    'pizza': bake_pizza,
}

result = recipe['pizza']()  # time to bake! 
print(result)

Repurposing decorators for flow control

Decorators can be cleverly used to control the execution flow just like goto:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before execution 🔮")
        result = func(*args, **kwargs)
        print("After execution 🏁")
        return result
    return wrapper

@my_decorator
def greet(name):
    print(f"Hello, {name}!")

The decorator concept gives us a sneak peek into Python's powerful meta programming capabilities.

Philosophy behind Python's structured approach

Python's Zen prefers readability and simplicity over jumbled threads of goto. With functions, loops, and above alternatives, Python provides an arsenal of structured tools to tame the chaos. Save goto for a rainy day!

Treading the path of bytecode

Python's bytecode manipulation tools offer an intriguing, yet risky, approach to control flow. Like a double-edged sword, they should only be used by seasoned professionals. If you are going down this path, take a torch 🔦!

Goto or not to go?

Before reaching for goto, it might be worth reflecting on the design of your application. Is there a more elegant or Pythonic way to solve the problem at hand? If the answer is often "yes", Python's structured flow control might be the better choice. Wise developers know when not to use a tool as well as when to use it!