Python’s Structural Pattern Matching Guide (Does Python Finally Have Switch Case Statements?)

Python’s structural pattern matching, introduced in Python 3.10, is a powerful and expressive tool for writing code that can handle a variety of different data structures and types.

It is similar to a switch statement in other languages, as it provides a way to handle multiple cases or conditions in a structured way. However, unlike a traditional switch statement, Python’s structural pattern matching allows for more powerful and flexible matching, including the ability to match on the structure, values, and/or type of an object.

In this article, we will delve deeper into Python’s structural pattern matching and explore its syntax, capabilities, and best practices. We will also compare it to traditional approaches and discuss when it may be appropriate to use it in your code.

Basic Syntax

The syntax for Python’s structural pattern matching is relatively straightforward. It involves using the match keyword, followed by an expression to be matched, and then a series of “cases” which are indented blocks of code that will be executed if the expression matches the specified pattern.

Here’s a simple example that demonstrates the basic syntax:

def greet(name):
    match name:
        case "Alice":
            print("Hello, Alice!")
        case "Bob":
            print("Hey, Bob!")
        case _:
            print("Hello, stranger!")
Code language: Python (python)

In this example, we are using the match keyword to match on the name argument passed to the greet function:

• If the name is “Alice”, the first case block will be executed, printing “Hello, Alice!”
• If the name is “Bob”, the second case block will be executed, printing “Hey, Bob!”
• If the name is neither of these, the else block will be executed, printing “Hello, stranger!”

Matching on Multiple Patterns

One of the powerful features of Python’s structural pattern matching is that you can match on multiple patterns at once. This allows you to write code that can handle a variety of different data structures without having to use nested if-elif-else statements.

Here’s an example that demonstrates how to match on multiple patterns:

def process_data(data):
    match data:
        case [a, b, c]:
            print(f"Received a list with three elements: {a}, {b}, and {c}")
        case [a, b]:
            print(f"Received a list with two elements: {a} and {b}")
        case [a]:
            print(f"Received a list with one element: {a}")
        case _:
            print("Received something else")
Code language: Python (python)

In this example, we are using the match keyword to match on the data argument passed to the process_data function:

• If the data is a list with three elements, the first case block will be executed, printing the values of the three element
• If the data is a list with two elements, the second case block will be executed, printing the values of the two elements
• If the data is a list with one element, the third case block will be executed, printing the value of the element
• If the data is none of these, the default case will be executed

We can also use wildcards in our patterns to match any value. For example:

def process_data(data):
    match data:
        case [a, _, c]:
            print(f"Received a list with three elements, the second of which was ignored: {a}, {c}")
        case _:
            print("Received something else")
Code language: Python (python)

In this example, we are using a wildcard _ to match any value for the second element in the list. This allows us to handle lists with three elements, but ignore the value of the second element.

Matching on Types

In addition to matching on the structure of an object, Python’s structural pattern matching also allows you to match on the type of an object. This is useful for writing code that can handle different types of data in different ways.

Here’s an example that demonstrates how to match on types:

def process_data(data):
    match data:
        case int:
            print(f"Received an integer: {data}")
        case str:
            print(f"Received a string: {data}")
        case _:
            print("Received something else")
Code language: Python (python)

In this example, we are using the match keyword to match on the data argument passed to the process_data function:

• If the data is an integer, the first case block will be executed, printing the value of the integer
• If the data is a string, the second case block will be executed, printing the value of the string
• If the data is neither of these, the default case will be executed.

We can also match on objects that are instances of a particular class or subclass:

class MyClass:
    pass

def process_data(data):
    match data:
        case MyClass:
            print("Received an instance of MyClass")
        case _:
            print("Received something else")
Code language: Python (python)

In this example, we are using the match keyword to match on the data argument passed to the process_data function:

• If the data is an instance of MyClass, the first case block will be executed, printing "Received an instance of MyClass"
• Otherwise, the default case will be executed

Comparison to Traditional Approaches

So how does Python’s structural pattern matching compare to traditional approaches such as using if-elif-else statements or dictionaries?

One advantage of using structural pattern matching is that it is often more concise and expressive than using if-elif-else statements. For example, consider the following code that uses an if-elif-else statement to determine the type of an object:

def process_data(data):
    if isinstance(data, int):
        print(f"Received an integer: {data}")
    elif isinstance(data, str):
        print(f"Received a string: {data}")
    else:
        print("Received something else")
Code language: Python (python)

While this code is functional, it is not as concise or expressive as the equivalent code using structural pattern matching:

def process_data(data):
    match data:
        case int:
            print(f"Received an integer: {data}")
        case str:
            print(f"Received a string: {data}")

        case _:
            print("Received something else")
Code language: Python (python)

Another option is to use a dictionary to map types to functions:

def process_integer(data):
    print(f"Received an integer: {data}")
    
def process_string(data):
    print(f"Received a string: {data}")
    
def process_other(data):
    print("Received something else")
    
dispatch_table = {
    int: process_integer,
    str: process_string
}

def process_data(data):
    func = dispatch_table.get(type(data), process_other)
    func(data)
Code language: Python (python)

As you can see, this approach is more verbose and less flexible than using structural pattern matching.

Best Practices

When using Python’s structural pattern matching, it is important to follow a few best practices to ensure that your code is readable, maintainable, and efficient.

• Use descriptive and meaningful names for your variables. This will make it easier for other developers to understand what your code is doing.
• Avoid using wildcards unless necessary. While wildcards can be useful for certain situations, they can also make your code harder to read and understand.
• Use the else case sparingly. The else case should only be used when you need to handle a default case, rather than as a catch-all for every possible scenario.
• Test your code thoroughly. Structural pattern matching is still a relatively new feature in Python, and it is important to ensure that your code is working as expected.

Conclusion

In conclusion, Python’s structural pattern matching is a powerful and expressive tool for writing code that can handle a variety of different data structures and types.

It is often more concise and expressive than traditional approaches such as if-elif-else statements or dictionaries, and can help you write more readable and maintainable code. However, it is important to follow best practices and test your code thoroughly to ensure that it is working as expected.

References

• Python 3.10 documentation: Structural Pattern Matching
• PEP 636 – Structural Pattern Matching: Tutorial