Python Match Case – Pattern Matching (Python 3.10+)

Basic Match-Case Syntax

The match statement compares a value against multiple patterns. The first matching pattern executes its block. The case _: is the wildcard (matches anything — like "else").

def describe_http_status(status):
    match status:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Server Error"
        case _:              # wildcard - matches anything
            return f"Unknown status: {status}"

print(describe_http_status(200))
print(describe_http_status(404))
print(describe_http_status(999))

OR Patterns – Multiple Values

Use | to match multiple values in a single case.

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

print(day_type("Monday"))    # Weekday
print(day_type("Saturday"))  # Weekend

Guard Conditions with if

Add an if guard to a case for additional conditions.

def classify(value):
    match value:
        case x if x < 0:
            return f"{x} is negative"
        case 0:
            return "zero"
        case x if x > 0 and x <= 100:
            return f"{x} is between 1 and 100"
        case _:
            return f"{value} is over 100"

print(classify(-5))
print(classify(0))
print(classify(42))

Matching Sequences and Dicts

Match can destructure lists, tuples, and dicts directly.

# Match sequences (lists/tuples)
def describe_point(point):
    match point:
        case [0, 0]:
            return "Origin"
        case [x, 0]:
            return f"On X-axis at {x}"
        case [0, y]:
            return f"On Y-axis at {y}"
        case [x, y]:
            return f"Point at ({x}, {y})"

print(describe_point([0, 0]))
print(describe_point([3, 0]))
print(describe_point([4, 5]))

match/case: Structural Pattern Matching, Not Just a Switch

Python 3.10's match looks like a switch, but it does far more — it can destructure data and bind variables while matching, which a chain of if/elif can't do cleanly.

def handle(command):
    match command.split():
        case ["go", direction]:            # unpacks a 2-item list, binds direction
            return f"Moving {direction}"
        case ["drop", *items]:             # captures the rest
            return f"Dropping {items}"
        case ["quit" | "exit"]:            # OR pattern
            return "Bye"
        case _:                            # wildcard = default
            return "Unknown"

Match on shape, with guards

match point:
    case (0, 0):              return "origin"
    case (x, 0):              return f"on x-axis at {x}"     # binds x
    case (x, y) if x == y:    return "diagonal"              # guard condition
    case Point(x=px, y=py):   return f"point {px},{py}"      # class pattern

Key distinction: a plain switch only compares equality; match matches structure — list/tuple shapes, dict keys, class attributes — and captures parts into variables in the same step. Gotcha: a bare name like case x: is a capture (matches anything, binds x), not a comparison — to match against a constant, use a dotted name (case Color.RED) or a literal. Reach for it when branching on the shape of data; simple value checks are still fine as if/elif.

Interview Questions on Match-Case

• What is the match-case statement and in which Python version was it introduced?
• How is match-case different from a chain of if/elif?
• What is structural pattern matching?
• How do you match multiple values in a single case?
• What is a guard condition in a case clause?
• How does the wildcard _ pattern work?
• Can match destructure sequences and dictionaries?

Related Topics