Python's Pattern Matching A Powerful Tool for Simplifying Complex Logic

Introduction to Pattern Matching in Python

Pattern matching in Python, introduced in version 3.10, is a powerful feature that enhances code readability and simplifies complex conditional logic. It allows developers to match variable values against specific patterns, making it easier to handle different data structures and types.

# Basic pattern matching example
def greet(person):
    match person:
        case {"name": name, "age": age}:
            return f"Hello, {name}! You are {age} years old."
        case {"name": name}:
            return f"Hello, {name}!"
        case _:
            return "Hello, stranger!"

print(greet({"name": "Alice", "age": 30}))  # Output: Hello, Alice! You are 30 years old.
print(greet({"name": "Bob"}))  # Output: Hello, Bob!
print(greet({}))  # Output: Hello, stranger!

Syntax and Structure

Pattern matching uses the match statement followed by one or more case clauses. Each case clause specifies a pattern to match against and the corresponding code to execute if the match is successful.

def analyze_data(data):
    match data:
        case []:
            return "Empty list"
        case [single_item]:
            return f"List with one item: {single_item}"
        case [first, second, *rest]:
            return f"List with at least two items: {first}, {second}, and {len(rest)} more"
        case _:
            return "Not a list"

print(analyze_data([]))  # Output: Empty list
print(analyze_data([42]))  # Output: List with one item: 42
print(analyze_data([1, 2, 3, 4]))  # Output: List with at least two items: 1, 2, and 2 more
print(analyze_data("not a list"))  # Output: Not a list

Matching Literal Values

Pattern matching can be used to match against literal values, making it a concise alternative to multiple if-elif statements.

def weekday(day):
    match day:
        case "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday":
            return "Weekday"
        case "Saturday" | "Sunday":
            return "Weekend"
        case _:
            return "Invalid day"

print(weekday("Monday"))  # Output: Weekday
print(weekday("Saturday"))  # Output: Weekend
print(weekday("Funday"))  # Output: Invalid day

Matching Sequences

Pattern matching is particularly useful when working with sequences like lists or tuples. It allows you to match against specific sequence structures and extract values.

def process_coordinates(point):
    match point:
        case (0, 0):
            return "Origin"
        case (0, y):
            return f"Y-axis at y={y}"
        case (x, 0):
            return f"X-axis at x={x}"
        case (x, y) if x == y:
            return f"On the diagonal at ({x}, {y})"
        case (x, y):
            return f"Point at ({x}, {y})"

print(process_coordinates((0, 0)))  # Output: Origin
print(process_coordinates((0, 5)))  # Output: Y-axis at y=5
print(process_coordinates((3, 3)))  # Output: On the diagonal at (3, 3)
print(process_coordinates((2, 4)))  # Output: Point at (2, 4)

Matching with Guards

Guards allow you to add additional conditions to pattern matching cases. This provides more flexibility in defining complex matching criteria.

def categorize_number(num):
    match num:
        case n if n < 0:
            return "Negative"
        case n if n == 0:
            return "Zero"
        case n if n % 2 == 0:
            return "Positive Even"
        case n if n % 2 != 0:
            return "Positive Odd"

print(categorize_number(-5))  # Output: Negative
print(categorize_number(0))   # Output: Zero
print(categorize_number(4))   # Output: Positive Even
print(categorize_number(7))   # Output: Positive Odd

Matching with Class Patterns

Pattern matching works well with custom classes, allowing you to match against specific attributes of objects.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def analyze_point(point):
    match point:
        case Point(x=0, y=0):
            return "Origin"
        case Point(x=0, y=y):
            return f"On Y-axis at y={y}"
        case Point(x=x, y=0):
            return f"On X-axis at x={x}"
        case Point(x=x, y=y) if x == y:
            return f"On the diagonal at ({x}, {y})"
        case Point():
            return f"Point at ({point.x}, {point.y})"
        case _:
            return "Not a point"

print(analyze_point(Point(0, 0)))  # Output: Origin
print(analyze_point(Point(0, 5)))  # Output: On Y-axis at y=5
print(analyze_point(Point(3, 3)))  # Output: On the diagonal at (3, 3)
print(analyze_point(Point(2, 4)))  # Output: Point at (2, 4)
print(analyze_point("not a point"))  # Output: Not a point

Capturing Matched Values

Pattern matching allows you to capture matched values for later use in the code block associated with a case.

def process_data(data):
    match data:
        case {"type": "user", "name": name, "age": age}:
            return f"User {name} is {age} years old"
        case {"type": "product", "name": name, "price": price}:
            return f"Product {name} costs ${price:.2f}"
        case {"type": type_name, **rest}:
            return f"Unknown type '{type_name}' with data: {rest}"
        case _:
            return "Invalid data format"

print(process_data({"type": "user", "name": "Alice", "age": 30}))
# Output: User Alice is 30 years old

print(process_data({"type": "product", "name": "Widget", "price": 9.99}))
# Output: Product Widget costs $9.99

print(process_data({"type": "location", "city": "New York", "country": "USA"}))
# Output: Unknown type 'location' with data: {'city': 'New York', 'country': 'USA'}

print(process_data("invalid"))
# Output: Invalid data format

Matching with Wildcard Patterns

Wildcard patterns allow you to match any value or part of a structure, providing flexibility in handling various data formats.

def analyze_tuple(data):
    match data:
        case (x, *middle, y):
            return f"First: {x}, Last: {y}, Middle: {middle}"
        case [x, y, *rest]:
            return f"First two: {x}, {y}, Rest: {rest}"
        case *all:
            return f"Caught all: {all}"

print(analyze_tuple((1, 2, 3, 4, 5)))  # Output: First: 1, Last: 5, Middle: [2, 3, 4]
print(analyze_tuple([1, 2, 3, 4]))     # Output: First two: 1, 2, Rest: [3, 4]
print(analyze_tuple("python"))         # Output: Caught all: ('p', 'y', 't', 'h', 'o', 'n')

Nested Pattern Matching

Pattern matching supports nested structures, allowing you to match complex data hierarchies in a single statement.

def process_nested_data(data):
    match data:
        case {"user": {"name": name, "address": {"city": city, "country": country}}}:
            return f"{name} lives in {city}, {country}"
        case {"product": {"name": name, "details": [category, price]}}:
            return f"{name} is a {category} product costing ${price:.2f}"
        case _:
            return "Unrecognized data structure"

print(process_nested_data({
    "user": {
        "name": "Alice",
        "address": {"city": "London", "country": "UK"}
    }
}))
# Output: Alice lives in London, UK

print(process_nested_data({
    "product": {
        "name": "Laptop",
        "details": ["Electronics", 999.99]
    }
}))
# Output: Laptop is a Electronics product costing $999.99

print(process_nested_data({"random": "data"}))
# Output: Unrecognized data structure

Pattern Matching with Custom Classes (Advanced)

Pattern matching can be customized for user-defined classes by implementing the __match_args__ class attribute, allowing for more intuitive matching patterns.

class Book:
    __match_args__ = ("title", "author", "year")

    def __init__(self, title, author, year):
        self.title = title
        self.author = author
        self.year = year

def categorize_book(book):
    match book:
        case Book(title, "George Orwell", year) if year < 1950:
            return f"Classic Orwell: {title}"
        case Book(_, _, year) if year >= 2020:
            return f"Recent publication: {book.title} by {book.author}"
        case Book(title, author, _):
            return f"Other book: {title} by {author}"
        case _:
            return "Not a book object"

print(categorize_book(Book("1984", "George Orwell", 1949)))
# Output: Classic Orwell: 1984

print(categorize_book(Book("The Midnight Library", "Matt Haig", 2020)))
# Output: Recent publication: The Midnight Library by Matt Haig

print(categorize_book(Book("To Kill a Mockingbird", "Harper Lee", 1960)))
# Output: Other book: To Kill a Mockingbird by Harper Lee

print(categorize_book("Not a book"))
# Output: Not a book object

Real-Life Example: Parsing Log Entries

Pattern matching can significantly simplify log parsing tasks, making it easier to extract and process information from various log formats.

import re
from datetime import datetime

def parse_log_entry(entry):
    match entry.split():
        case [date, time, "ERROR", *message]:
            return {
                "level": "ERROR",
                "timestamp": datetime.strptime(f"{date} {time}", "%Y-%m-%d %H:%M:%S"),
                "message": " ".join(message)
            }
        case [date, time, "WARNING", *message]:
            return {
                "level": "WARNING",
                "timestamp": datetime.strptime(f"{date} {time}", "%Y-%m-%d %H:%M:%S"),
                "message": " ".join(message)
            }
        case [date, time, "INFO", *message]:
            return {
                "level": "INFO",
                "timestamp": datetime.strptime(f"{date} {time}", "%Y-%m-%d %H:%M:%S"),
                "message": " ".join(message)
            }
        case _:
            return {"level": "UNKNOWN", "message": entry}

# Example usage
logs = [
    "2023-03-15 10:30:45 ERROR Database connection failed",
    "2023-03-15 10:31:00 INFO User logged in successfully",
    "2023-03-15 10:32:15 WARNING High CPU usage detected",
    "Invalid log entry format"
]

for log in logs:
    parsed = parse_log_entry(log)
    print(f"Level: {parsed['level']}")
    if 'timestamp' in parsed:
        print(f"Timestamp: {parsed['timestamp']}")
    print(f"Message: {parsed['message']}\n")

# Output:
# Level: ERROR
# Timestamp: 2023-03-15 10:30:45
# Message: Database connection failed

# Level: INFO
# Timestamp: 2023-03-15 10:31:00
# Message: User logged in successfully

# Level: WARNING
# Timestamp: 2023-03-15 10:32:15
# Message: High CPU usage detected

# Level: UNKNOWN
# Message: Invalid log entry format

Real-Life Example: Command-Line Argument Parsing

Pattern matching can be used to create a simple yet powerful command-line argument parser, handling various input formats and options.

import sys

def parse_arguments(args):
    match args:
        case [program_name, "run", filename]:
            return {"action": "run", "file": filename}
        case [program_name, "test", *test_files] if test_files:
            return {"action": "test", "files": test_files}
        case [program_name, "config", key, value]:
            return {"action": "config", "key": key, "value": value}
        case [program_name, "help"]:
            return {"action": "help"}
        case _:
            return {"action": "unknown"}

def main():
    args = parse_arguments(sys.argv)
    match args:
        case {"action": "run", "file": file}:
            print(f"Running file: {file}")
        case {"action": "test", "files": files}:
            print(f"Running tests on files: {', '.join(files)}")
        case {"action": "config", "key": key, "value": value}:
            print(f"Setting config {key} to {value}")
        case {"action": "help"}:
            print("Usage: program [run|test|config|help] [arguments]")
        case _:
            print("Invalid command. Use 'help' for usage information.")

# Example usage (comment out the line below and run this script with different arguments)
# sys.argv = ["program", "run", "script.py"]
main()

# Possible outputs based on different arguments:
# Running file: script.py
# Running tests on files: test1.py, test2.py
# Setting config debug to true
# Usage: program [run|test|config|help] [arguments]
# Invalid command. Use 'help' for usage information.

Performance Considerations

While pattern matching offers improved readability and expressiveness, it's important to consider its performance implications, especially in performance-critical code sections.

import timeit

def if_else_approach(value):
    if isinstance(value, int):
        return "Integer"
    elif isinstance(value, str):
        return "String"
    elif isinstance(value, list):
        return "List"
    else:
        return "Unknown"

def pattern_match_approach(value):
    match value:
        case int():
            return "Integer"
        case str():
            return "String"
        case list():
            return "List"
        case _:
            return "Unknown"

# Performance comparison
if_else_time = timeit.timeit(lambda: if_else_approach(42), number=1000000)
pattern_match_time = timeit.timeit(lambda: pattern_match_approach(42), number=1000000)

print(f"If-else approach time: {if_else_time:.6f} seconds")
print(f"Pattern matching approach time: {pattern_match_time:.6f} seconds")
print(f"Pattern matching is {pattern_match_time / if_else_time:.2f}x slower in this case")

# Output (may vary based on the system):
# If-else approach time: 0.184532 seconds
# Pattern matching approach time: 0.308765 seconds
# Pattern matching is 1.67x slower in this case

Best Practices and Tips

When using pattern matching in Python, consider these best practices to write more efficient and maintainable code:

1. Use specific patterns before general ones to avoid unintended matches.
2. Leverage guard clauses for complex conditions.
3. Keep patterns simple and readable.
4. Use wildcard patterns judiciously to avoid overly broad matches.

def process_data(data):
    match data:
        case {"type": "user", "id": int(id_), "name": str(name)} if id_ > 0:
            return f"Valid user: {name} (ID: {id_})"
        case {"type": "user", **rest}:
            return f"Invalid user data: {rest}"
        case {"type": str(type_), **rest}:
            return f"Unknown type: {type_}"
        case _:
            return "Invalid data format"

# Example usage
print(process_data({"type": "user", "id": 42, "name": "Alice"}))
print(process_data({"type": "user", "id": -1, "name": "Bob"}))
print(process_data({"type": "product", "id": 100}))
print(process_data(["not", "a", "dict"]))

# Output:
# Valid user: Alice (ID: 42)
# Invalid user data: {'id': -1, 'name': 'Bob'}
# Unknown type: product
# Invalid data format

Pattern Matching in Recursive Functions

Pattern matching can greatly simplify recursive functions, making them more readable and easier to understand. Here's an example of a recursive function to calculate the sum of a nested list structure:

def sum_nested(data):
    match data:
        case int(x) | float(x):
            return x
        case [*items]:
            return sum(sum_nested(item) for item in items)
        case _:
            raise ValueError(f"Unsupported data type: {type(data)}")

# Example usage
nested_list = [1, [2, 3, [4, 5]], 6, [7, 8]]
result = sum_nested(nested_list)
print(f"Sum of nested list: {result}")

# Output:
# Sum of nested list: 36

Additional Resources

For those interested in diving deeper into Python's pattern matching feature, here are some recommended resources:

1. PEP 634 - Structural Pattern Matching: Specification https://peps.python.org/pep-0634/
2. PEP 636 - Structural Pattern Matching: Tutorial https://peps.python.org/pep-0636/
3. "Pattern Matching in Python" by Guido van Rossum ArXiv: https://arxiv.org/abs/2104.06081
4. Python Documentation - The match Statement https://docs.python.org/3/reference/compound_stmts.html#the-match-statement

These resources provide in-depth explanations, tutorials, and the formal specification of pattern matching in Python. They are excellent starting points for mastering this powerful feature.