Structural Pattern Matching Python

Structural Pattern Matching, also known as pattern matching or match statement, is a feature introduced in Python 3.10 that allows developers to write more expressive and concise code. This feature is inspired by similar constructs in other programming languages like Rust, F#, and Haskell.

This article will explore the basics of structural pattern matching in Python 3.10, its syntax, and how to use it in real-world scenarios.

What is Structural Pattern Matching?

Structural pattern matching is a syntax construct that allows developers to match data structures against patterns and execute code based on the match. In other words, it is a way to destructure and check data structures like tuples, lists, and dictionaries against a pattern and execute code based on the match.

The primary advantage of structural pattern matching is that it allows developers to write more concise and readable code. For example, consider the following code snippet that uses if-else statements to check if a variable is an integer or a string.

if instance(value, int):
    print("The value is an integer")
elif isinstance(value, str):
    print("The value is a string")
else:
    print("The value is neither an integer nor a string")

With structural pattern matching, we can rewrite the above code as follows:

match value:
    case int:
        print("The value is an integer")
    case str:
        print("The value is a string")
    case _:
        print("The value is neither an integer nor a string")

As you can see, the code is more concise and readable, allowing us to focus on the patterns we want to match rather than the type checking.

Syntax of Structural Pattern Matching

The syntax of structural pattern matching is relatively simple. It consists of the match statement, followed by the value to be matched, and one or more case statements. Each case statement specifies a pattern to be checked against the weight.

Here is the syntax for the match statement:

match value:
    case pattern1:
        # code to execute if the pattern1 matches
    case pattern2:
        # code to execute if the pattern2 matches
    ...
    case _:
        # code to execute if none of the above patterns match

In the above syntax, the value is the value to be matched, and each case statement specifies a matching pattern. The _ is a wildcard pattern that matches anything and is a catch-all for unmatched designs.

Patterns in Structural Pattern Matching

We can use several patterns in structural pattern matching to match against data structures. Here are some of the commonly used designs:

Literal ways: These patterns match against a specific literal value.

match value:
    case "hello":
        print("The value is 'hello'")
    case 42:
        print("The value is 42")

Variable patterns: These patterns match against a variable and bind the value to the variable.

match value:
    case x:
      print(f"The value is {x}")

Type patterns: These patterns match against a specific type.

match value:
    case int:
        print("The value is an integer")
    case str:
        print("The value is a string")

Sequence patterns: These patterns match against a sequence data structure like a tuple, list, or string.

match value:
    case []:
        print("The list is empty")
    case [x, y]:
        print(f"The first two elements of the list are {x} and {y}")
    case [x, *rest]:
        print(f"The first element of the list

is {x} and the rest of the elements are {rest}")

Mapping patterns: These patterns match against a mapping data structure like a dictionary.

match value:
case {}:
print("The dictionary is empty")
case {"name": name, "age": age}:
print(f"The person's name is {name} and age is {age}")

Combining patterns: We can also combine patterns using logical operators like `|` (or), `&` (and), and `not.`

match value:
case int | float:
print("The value is a number")
case [x, y] & isinstance(x, str):
print("The first element is a string")
case not []:
print("The value is not an empty list")

Using Structural Pattern Matching in Real-World Scenarios

Structural pattern matching can be used in various real-world scenarios to simplify code and make it more readable. Let's look at some examples.

1. Parsing JSON

Consider a scenario where we have a JSON object that we want to parse and extract some values. Here is an example:

data = {
"name": "John Doe,"
"age": 30,
"email": "john.doe@example.com"
}

name = data.get("name")
age = data.get("age")
email = data.get("email")

With structural pattern matching, we can simplify the code as follows:

match data:
case {"name": name, "age": age, "email": email}:
print(f"Name: {name}")
print(f"Age: {age}")
print(f"Email: {email}")

As you can see, the code is more concise and easier to read.

2. Handling HTTP Responses

Consider a scenario where we want to handle HTTP responses and extract the status code and response body. Here is an example:

Response = requests.get("https://www.example.com")
if response.status_code == 200:
print("Request successful")
print(response.text)
else:
print("Request failed")

With structural pattern matching, we can simplify the code as follows:

match response:
case HTTPResponse(200, body):
print("Request successful")
print(body)
case _:
print("Request failed")

As you can see, the code is more concise and easier to read. The `HTTPResponse` is a type defined in the `http. Client` module, and we can use it to match against the status code and body.

Handling Errors with Structural Pattern Matching

In addition to matching data structures against patterns, Structural Pattern Matching can also handle errors more concisely and expressively.

Consider a scenario where we have a function that can raise different types of exceptions. Here is an example:

def divide(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        raise ValueError("Cannot divide by zero")
    except TypeError:
        raise ValueError("Unsupported operand types")
    except Exception:
        raise ValueError("An unknown error occurred")
    return result

With Structural Pattern Matching, we can handle these exceptions more concisely and expressively. Here is an example:

def divide(x, y):
    match (x, y):
        case (_, 0):
            raise ValueError("Cannot divide by zero")
        case (int | float, int | float):
            return x / y
        case _:
            raise ValueError("Unsupported operand types")

As you can see, the code is more concise and expressive. The first case matches against the pattern (_, 0), which means any value for the first argument and zero for the second argument. The second case matches against the practice (int | float, int | float), which means any integer or float value for both views. The third case matches against any other pattern.

Benefits of Structural Pattern Matching

Structural Pattern Matching has several benefits over traditional control flow statements, such as if-

Simplified code: Structural Pattern Matching simplifies code by allowing developers to write code that is more concise and easier to read. Instead of using lengthy and complicated conditional statements, developers can use Structural Pattern Matching to match data structures against patterns and execute code based on the match.
Improved readability: Using Structural Pattern Matching, developers can write more readable and easier-to-understand code. The code becomes self-explanatory, and it's easier to follow the flow of execution.
Improved maintainability: Code that uses Structural Pattern Matching is easier to maintain because it is more concise and self-explanatory. This makes it easier to identify and fix bugs and add new features.
Better performance: Structural Pattern Matching can improve code performance by eliminating unnecessary conditional statements and using more efficient data structures and algorithms.
Better error handling: Structural Pattern Matching can provide better error handling by enabling developers to catch specific types of errors and handle them appropriately. This can help to prevent bugs and improve the overall quality of the code.

Examples of Structural Pattern Matching in Python

Let's look at some examples of Structural Pattern Matching in Python.

1. Matching a tuple:

def process_data(data):
    match data:
        case (1, 'apple,' 3.14):
            print("Data is valid")
        case _:
            print("Data is invalid")

process_data((1, 'apple', 3.14)) # Output: Data is valid
process_data((2, 'banana', 4.56)) # Output: Data is invalid

In this example, we define a function called process_data that takes a tuple as an argument. We use Structural Pattern Matching to match the tuple against a specific pattern (1, 'apple,' 3.14) and print a message based on the match.

2. Matching a dictionary:

def process_dict(data):
    match data:
        case {'name': str, 'age': int}:
            print("Data is valid")
        case _:
            print("Data is invalid")

process_dict({'name': 'John,' 'age': 30}) # Output: Data is valid
process_dict({'name': 'Jane,' 'age': '30'}) # Output: Data is invalid

In this example, we define a function called process_dict that takes a dictionary as an argument. We use Structural Pattern Matching to match the dictionary against a specific pattern {'name': str, 'age': int} and print a message based on the match.

Conclusion

Structural pattern matching is a powerful feature introduced in Python 3.10 that allows developers to write more expressive and concise code. With this feature, we can match data structures against patterns and execute code based on the match. This feature can be used in various real-world scenarios to simplify code and make it more readable.

Next TopicPostfix to Infix Conversion in Python

← prev next →