Simplify Python Conditionals with the Dictionary Dispatch Pattern

Conditional statements are ubiquitous in Python code. We use them to check conditions, make decisions, and control program flow.

If you want to reduce verbose if‑else structures in your code while making logic clearer and more readable, you'll love this Python trick.

That is the dictionary dispatch pattern . It can replace half of your if‑else statements and make code more concise, efficient, and Pythonic.

Next, let's see how it works.

Problem: Too many conditional statements

Example code:

def handle_action(action):
    if action == 'start':
        start()
    elif action == 'stop':
        stop()
    elif action == 'pause':
        pause()
    elif action == 'resume':
        resume()
    else:
        raise ValueError("Unknown action")

This pattern is common, but as the number of conditions grows, the code becomes increasingly tangled, harder to read, slower to execute, and more error‑prone and difficult to maintain.

At this point, dictionary‑based dispatch comes to the rescue.

Using a dictionary for function dispatch

The same logic rewritten with a dictionary looks like this:

def handle_action(action):
    actions = {
        'start': start,
        'stop': stop,
        'pause': pause,
        'resume': resume
    }
    try:
        actions[action]()
    except KeyError:
        raise ValueError("Unknown action")

In Python, functions are first‑class objects , meaning they can be stored in variables, passed as arguments, and used like any other object.

In this example, the actions dictionary maps strings to functions. When an action arrives, we look it up and invoke the corresponding function—simple as that.

No conditional statements, no elif chain—just clean, efficient dispatch.

Calculator application

Let's look at a slightly more practical example—a basic calculator:

Traditional conditional style

def calculate(a, b, operation):
    if operation == 'add':
        return a + b
    elif operation == 'subtract':
        return a - b
    elif operation == 'multiply':
        return a * b
    elif operation == 'divide':
        return a / b
    else:
        raise ValueError("Invalid operation")

Dictionary dispatch style

def calculate(a, b, operation):
    operations = {
        'add': lambda: a + b,
        'subtract': lambda: a - b,
        'multiply': lambda: a * b,
        'divide': lambda: a / b
    }
    try:
        return operations[operation]()
    except KeyError:
        raise ValueError("Invalid operation")

More concise, more readable, and easier to extend (just add a new key to the dictionary).

Using dict.get to set default behavior

Don't want to use try‑except? You can use dict.get() and provide a default fallback function:

def handle_action(action):
    actions = {
        'start': start,
        'stop': stop,
        'pause': pause,
        'resume': resume
    }
    default = lambda: print("Unknown action")
    actions.get(action, default)()

Simple and efficient.

When not to use it

This pattern is not universal. Avoid it in the following situations:

The logic in each condition differs greatly, making it hard to refactor into separate functions.

Complex condition evaluation is needed (e.g., ranges, comparisons, multiple variables).

But for command handling, routing, dispatch, or simple control flow , it is perfect.

Final words

If you find yourself writing long if‑elif‑else chains to map strings or enums to actions, give this pattern a try.