Introduction

Modern Python does have a switch-like construct: match and case, introduced in Python 3.10. But even now, Python developers still often choose other patterns such as if and elif, dictionary dispatch, or polymorphism, depending on what the code is actually doing.

Use match and case in Modern Python

If you want the closest thing to a switch statement, use structural pattern matching.

1def http_error(status):
2    match status:
3        case 400:
4            return "Bad request"
5        case 404:
6            return "Not found"
7        case 418:
8            return "I'm a teapot"
9        case _:
10            return "Something else"
11
12print(http_error(404))

This is the most direct replacement when you are matching one value against several known cases.

match is more powerful than a classic C-style switch because it can match shapes and patterns, not just literals. That makes it especially useful for tuples, dictionaries, and custom objects. It is the best modern answer when pattern matching is the real need. It is also the most direct one.

if and elif Are Still Fine

If the logic is simple and there are only a few branches, if and elif are often clearer than any fancy dispatch mechanism.

1def describe(value):
2    if value == "a":
3        return "alpha"
4    elif value == "b":
5        return "beta"
6    else:
7        return "unknown"

This is boring, but boring code is often good code. Do not replace a perfectly readable if chain just because it feels less clever than a dispatch table.

Use Dictionary Dispatch for Function Selection

When the case values map cleanly to functions, a dictionary is often a very Pythonic solution.

1def zero():
2    return "zero"
3
4def one():
5    return "one"
6
7dispatch = {
8    0: zero,
9    1: one,
10}
11
12def number_to_text(value):
13    return dispatch.get(value, lambda: "unknown")()
14
15print(number_to_text(1))

This works well when the cases are just command lookups or function routing.

It is especially handy when the values already behave like keys in a configuration or command table.

Use Classes When Behavior Belongs to Types

If your so-called switch statement is really a big block of behavior that depends on object type or strategy, use polymorphism instead of a central branch table.

1class JsonFormatter:
2    def format(self, value):
3        return f'{{"value": "{value}"}}'
4
5class PlainFormatter:
6    def format(self, value):
7        return value

That approach scales better than one growing conditional chain when behavior becomes more complex.

How to Choose Between Them

Use match when you want explicit pattern matching. Use if and elif when the conditions are simple. Use dictionary dispatch when keys map directly to operations. Use classes when the branching is really a design problem rather than a syntax problem.

The best replacement is not always the most switch-like one. It is the one that makes the intent obvious to the next reader.

Common Pitfalls

• Older advice often says Python has no switch statement, but modern Python has match and case.
• Dictionary dispatch works well for key-to-function lookup, but it is not always clearer than if and elif.
• 'match is powerful, but it can be overkill for trivial branches.'
• If behavior belongs to object types, a class-based design is usually cleaner than one giant conditional block.

Summary

• In Python 3.10 and later, match and case are the closest replacement for a switch statement.
• 'if and elif are still the simplest answer for small branch sets.'
• Dictionary dispatch is useful when values map directly to functions.
• Polymorphism is often the right replacement when the branching is really about behavior design.