Python Match Statement: A Versatile Switch-Case in Python

The Python match statement allows you to compare values against patterns. Its structure is similar to the switch-case statement in other programming languages.

Quick Answer: How to Use the match Statement (Python's Switch-Case)

The match statement, introduced in Python 3.10, acts like a switch-case statement from other languages. It takes a value and compares it against a series of case patterns. The code block for the first matching case is executed.

Syntax:

match subject:
    case pattern_1:
        # Action for pattern 1
    case pattern_2:
        # Action for pattern 2
    case _:
        # Default action if no other case matches

Example:

http_status = 404

match http_status:
    case 200:
        print("OK")
    case 404:
        print("Not Found")
    case 500:
        print("Server Error")
    case _:  # The wildcard `_` acts as the default case
        print("Unknown status")

# Outputs: Not Found

The match statement is a powerful tool for structural pattern matching, which is more advanced than a simple if/elif chain.

How to Use the Python Match Statement

The Python syntax starts with the match keyword, followed by an expression. Inside the code block, case statements define the patterns to compare against.

match expression:
    case pattern1:
        # Execute if pattern1 fits
    case pattern2:
        # Execute if pattern2 fits
    case _:
        # Execute if no pattern fits (default case)

• match: The keyword to initiate a switch-case statement in Python.
• expression: The value you want to test against the patterns.
• case: The keyword to start a case block with a pattern to test against. If the pattern fits, the corresponding block of code executes.
• _: The wildcard character defines the default case when no other cases fit the specified patterns.

Basic Usage

def match_value(x):
    match x:
        case 1:
            return "One"
        case 2:
            return "Two"
        case _:
            return "Other"

When to Use match in Python

Simplifying Multiple Conditions

You can use the equivalent of the switch-case statement in Python to simplify complex conditionals. Instead of using multiple if-elif statements, you can use cases to check against.

def http_status_code(status):
    match status:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Server Error"
        case _:
            return "Unknown Status"

Validating User Input

The statement is also helpful for checking sequence patterns in user input. For example, you can match string patterns to ensure the input meets certain conditions.

def validate_input(user_input):
    match user_input:
        case "yes":
            return "You agreed!"
        case "no":
            return "You disagreed!"
        case _:
            return "Invalid response"

Handling Multiple Data Types

Using cases to test against is also useful when handling different data types. This allows you to process different kinds of inputs efficiently.

def handle_input(data):
    match data:
        case int():
            return f"Integer: {data}"
        case str():
            return f"String: {data}"
        case _:
            return "Unknown data type"

Managing Complex Data Structures

You can also Python-switch through cases for more complex data structures like lists, tuples, or dictionaries.

def process_coordinates(coordinates):
    match coordinates:
        case (x, y):
            return f"Coordinates: x={x}, y={y}"
        case _:
            return "Unknown format"

Examples of Using Switch-Case in Python

Command-Line Tools

Command-line tools or chatbots often use the match statement to identify and respond to specific commands. This makes it easy to route commands to the appropriate handlers.

def handle_command(command):
    match command:
        case "start":
            return "Starting the process..."
        case "stop":
            return "Stopping the process..."
        case "help":
            return "Showing help documentation..."
        case _:
            return "Unknown command"

Web Application Routing

In web development, frameworks often need to route URLs to specific handlers. You can streamline the routing process by using a match statement to define cases for each web page.

def route(path):
    match path:
        case "/home":
            return "Home Page"
        case "/about":
            return "About Page"
        case "/contact":
            return "Contact Page"
        case _:
            return "404 Not Found"

File Type Detection in File Processing

A file processing application might need to detect file types and perform different actions based on the file extension. This is where match can help you easily sort and handle files.

def handle_file_extension(extension):
    match extension:
        case ".txt":
            return "Text file"
        case ".jpg" | ".png":
            return "Image file"
        case ".pdf":
            return "PDF file"
        case _:
            return "Unknown file type"

Data Analytics Applications

In data analytics, you can use the statement to categorize data points based on their value range or category.

def categorize_data_point(value):
    match value:
        case value if value < 0:
            return "Negative"
        case value if value >= 0 and value <= 10:
            return "Low"
        case value if value > 10:
            return "High"

Learn More About the Python Match Statement

Switch-Case Statements in Python and Other Programming Languages

Other programming languages use so-called switch-case statements for similar purposes. However, traditional switch statements often only work with primitive data types like integers and strings.

Python allows more complex cases with data structures like lists, tuples, and dictionaries. Therefore, Python's implementation of the switch-case statement is more versatile than other such mechanisms.

Matching Objects in Python

Python's match statement works well with data classes, allowing you to look for overlaps of object properties.

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

def describe_point(point):
    match point:
        case Point(x=0, y=0):
            return "Origin"
        case Point(x, y):
            return f"Point at ({x}, {y})"

Wildcard Patterns in Python

The wildcard pattern (_) acts as a catch-all case. It works like a default case in a traditional switch statement. For example, you can use a wildcard pattern to handle any unexpected input in your program.

def match_numbers(num):
    match num:
        case 1:
            return "One"
        case 2:
            return "Two"
        case _:
            return "Other"

Regular Expressions with Python Match

You can combine Python’s re.match() function with the match statement to compare strings based on regular expressions. This is especially useful if you have a string pattern to match or test against, such as validating email formats.

import re

def check_email(email):
    match email:
        case re.match(r"\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b", email):
            return "Valid email"
        case _:
            return "Invalid email"

Combining Match with Loops

You can combine match statements with loops to handle complex data or repetitive tasks. This is especially useful when processing multiple values at once or dealing with collections.

data = [1, 'hello', 3.5, 'Python']

for item in data:
    match item:
        case int():
            print(f"Integer: {item}")
        case str():
            print(f"String: {item}")
        case _:
            print(f"Other type: {item}")

Match with Guards

You can use guards within your cases to further control when a case executes. A guard is an additional condition you can attach to a case that needs to evaluate to True for the case to trigger.

def grade_student(score):
    match score:
        case score if score >= 90:
            return "A"
        case score if score >= 80:
            return "B"
        case score if score >= 70:
            return "C"
        case _:
            return "F"

Adding guards to cases can help simplify control flow in scenarios where you need to check additional conditions.

Key Takeaways for the Python match Statement

• Requires Python 3.10+: The match...case syntax was introduced in Python 3.10. It will not work in older versions.
• It's for Pattern Matching: Unlike a simple if statement, match is designed for structural pattern matching. It can check not just values, but also the shape of data, like the number of elements in a list or the keys in a dictionary.
• Only the First Match Executes: The match statement evaluates the case blocks from top to bottom and executes the code for the first pattern that matches. There is no "fall-through" behavior like in some other languages' switch statements.
• The Wildcard _ is a Default: The case _: pattern acts as a catch-all or default case. It will match any subject that was not caught by a previous case.
• Can Bind Variables: You can capture parts of a matched pattern into variables directly within the case line (e.g., case (x, y):).