Structural Pattern Matching (Python 3.10+)

Python's main replacement for an ordinary C or C++ switch statement is an if..elif..else chain. Dictionary dispatch is useful when many branches map values to functions or when dynamic dispatch is needed.

Programming

The Missing switch Statement

If you are moving from C or C++ to Python, the absence of a switch statement may seem surprising. Python does not omit switch by accident. It deliberately provides other ways to express the same branching problem, including if..elif..else chains and dictionary dispatch. These alternatives can make control flow clearer and avoid a common switch-related bug: accidental fall-through.

Key point

Tracing C and C++ Fall-Through

A C or C++ switch statement can select a case based on the value of one expression. The important control-flow detail is that a matching case does not automatically stop execution. If the case does not contain a break statement, execution can continue into the next case. This behavior is called fall-through.

What happens to control flow when a case matches and there is no break statement?

Worked example

A missing break changes the path

A C or C++ switch selects a matching case, but that case has no break statement. What should you expect from the control flow?

1
Select
The switch examines the value of its expression and reaches the matching case.
2
Execute
The statements belonging to the matching case execute.
3
Continue
Because break is absent, execution can fall through to the next case instead of leaving the switch.

Result

The matching case may be followed by statements from the next case. Forgetting break can therefore produce unexpected behavior.

Replacing Cases with Conditions

The direct Python translation of a C or C++ switch is an if..elif..else chain. Each elif represents another case, and the final else represents the default path. The branches are mutually exclusive: after one branch executes, the entire if..elif..else block exits. Python therefore needs no break statement to prevent fall-through.

How does control flow change when the same multi-branch decision is rewritten from a C or C++ switch into Python?

Worked example

Translating an operation selector

A C or C++ switch chooses one action for an operation name, with a default action for an unknown name. Translate the branching structure into Python.

1
Identify each case
Treat each operation-specific case as a separate condition.
2
Create the first branch
Represent the first case with if.
3
Create later branches
Represent each additional case with elif.
4
Create the default path
Represent the switch default with else.
5
Remove fall-through control
Do not add break statements. Once a Python branch executes, the if..elif..else block is complete.

Result

The resulting Python structure is an if..elif..else chain with mutually exclusive branches.

Choosing Dictionary Dispatch

An if..elif..else chain is usually the clearest starting point. When there are many branches, or when simple keys should select functions or values, a dictionary can hold the branching table directly. This technique is called dictionary dispatch.

Dictionary dispatch separates the decision from the work. The input operation name or other key is used for a dictionary lookup. The lookup returns the corresponding function, and that function is then called with the appropriate arguments. Adding another branch means adding another key-to-function mapping rather than expanding the control-flow chain.

How does an input value move from the lookup key to the selected function or result?

Approach	Best starting point	Main strength
if..elif..else	Most ordinary multi-branch decisions	Clear and straightforward
Dictionary dispatch	Many branches or key-to-function mappings	Fast, modular branching and dynamic dispatch
Structural pattern matching	Complex patterns	An advanced matching tool available through the match statement in Python 3.10+

The source recommends starting with if..elif..else, considering dictionary dispatch for larger or dynamic mappings, and exploring structural pattern matching for complex patterns.

Understanding Structural Matching

Structural pattern matching is represented by the match statement in Python 3.10 and later. It is a more advanced tool for matching complex patterns. This article focuses on the foundational alternatives to switch statements: if..elif..else chains and dictionary dispatch. Once those approaches are comfortable, structural pattern matching is worth exploring for problems involving complex patterns.

How does the match statement relate to Python's simpler branching alternatives?

Mistakes Beginners Make

Common mistake
Looking for a switch statement in Python
What it looks like
Treating the absence of switch as a limitation or an oversight
Why it fails
Python deliberately uses other branching approaches for this problem.
Do this instead
Start with an if..elif..else chain, then consider dictionary dispatch when the branch mapping becomes large or dynamic.
Common mistake
Expecting Python branches to fall through
What it looks like
Assuming that after one elif branch runs, the next elif branch will also run
Why it fails
Python if..elif..else chains are mutually exclusive and exit after one branch executes.
Do this instead
Write each independent action as its own branch. No break statement is needed.
Common mistake
Translating break statements mechanically
What it looks like
Trying to insert switch-style break statements into an if..elif..else translation
Why it fails
The fall-through problem that break prevents in C or C++ does not occur in a Python if..elif..else chain.
Do this instead
Translate cases into if, elif, and else branches and rely on the chain's mutually exclusive behavior.
Common mistake
Using dictionary dispatch before the mapping is clear
What it looks like
Replacing a short, readable conditional chain with a dictionary even when there are only a few straightforward branches
Why it fails
The source recommends if..elif..else for most cases because it is clear and requires no setup.
Do this instead
Use dictionary dispatch when there are many branches, when keys map simply to functions or values, or when dynamic dispatch is needed.

Practice the Translation

MEDIUM

A C or C++ switch chooses among several operation names and has a default path for an unknown operation. Describe how you would translate that structure into Python using if..elif..else. Then decide whether dictionary dispatch would be a better fit if the number of operation names became large.

Hints

Map the first case to if.
Map additional cases to elif.
Map default to else.
Do not add break statements to the Python chain.
Consider dictionary dispatch when operation names map directly to functions and the number of branches grows.

Your attempt (not saved)

What do you think happens?

You have an if..elif..else chain. After the first matching branch executes, what happens to the remaining branches?

The next branch executes automatically
The entire chain exits
Python requires a break statement before exiting
The branches execute in reverse order

Reveal answer

Answer:

The entire chain exits

Python if..elif..else chains are mutually exclusive. Once one branch executes, the entire block is done, so there is no fall-through and no break statement is needed.

Practical Decision Guide

1
Start with if..elif..else for an ordinary multi-branch decision.
2
Use elif for each additional case and else for the default path.
3
Remember that Python branches are mutually exclusive and do not fall through.
4
Consider dictionary dispatch when many branches map simple keys to functions or values.
5
Use dictionary dispatch when separating the choice of function from the function's work will make the design more modular and easier to test.
6
Explore structural pattern matching through the match statement when the problem involves complex patterns and you are ready for the advanced tool.

A useful rule of thumb from this topic is to prefer the simplest structure that clearly expresses the decision. The source recommends starting with if..elif..else. It suggests considering dictionary dispatch when there are more than five or six elif branches, when simple values map to functions, or when dynamic dispatch is needed. Structural pattern matching belongs later in the learning path for complex patterns.

Key Takeaways

1
Python has no switch statement by deliberate design.
2
An if..elif..else chain is the direct replacement for a C or C++ switch statement.
3
Python if..elif..else chains are mutually exclusive, so they do not have switch-style fall-through.
4
Dictionary dispatch maps keys to functions or values and is useful for many branches or dynamic dispatch.
5
Structural pattern matching, through the match statement in Python 3.10+, is an advanced option for matching complex patterns.

At a glance

Python's lack of a switch statement is a deliberate design choice.
Use if..elif..else as the clearest direct translation from C or C++ switch logic.
Unlike C or C++, Python's conditional chain has no fall-through behavior and needs no break statement.
Use dictionary dispatch when keys should select functions or values, especially with many branches or dynamic dispatch.
Structural pattern matching is a more advanced Python 3.10+ tool for complex patterns.

Related concepts

More concepts starting with S