Python The match Statement

match is new syntax, so it is checked when Python parses the file. On Python 3.9 or older, a file containing match fails with SyntaxError before a single line runs; you can't guard it with an if at run time. Check your version first:

python --version

import sys
print(sys.version_info >= (3, 10))

If your code must support older versions, use an if/elif chain or a dictionary lookup instead. match and case are soft keywords: they only act as keywords at the start of a match statement, so existing code that uses match as a variable name, such as match = re.search(...), keeps working.

Each case holds a pattern. The common kinds are:

Sequence patterns match lists and tuples but deliberately not strings. Mapping patterns ignore any extra keys, which suits JSON messages that carry more fields than you need. This structural checking is what makes match more than a switch: one case can verify the type, the length and specific values, and unpack the rest.

A guard is an if condition written after a pattern. The case runs only if the pattern matches and the guard is true:

match message:
    case ("deliver", qty) if qty > 0:
        print("Pack", qty)
    case ("deliver", qty):
        print("Invalid quantity:", qty)

The guard is checked only after the pattern succeeds, so it can use the captured qty. If the guard is false, Python moves on to the next case. A guard can't rescue a pattern that didn't match: ("collect", 3) never reaches the guard of a ("deliver", qty) case.

Put more specific cases first. Python tries cases from top to bottom and stops at the first match, exactly like an if/elif chain.

A bare name in a pattern captures whatever is in that position; it does not compare against an existing variable with that name:

LIMIT = 10
match 25:
    case LIMIT:          # captures 25 into LIMIT; matches anything
        print(LIMIT)     # 25

Python actually rejects this when another case follows, with "name capture 'LIMIT' makes remaining patterns unreachable". To compare against a constant, use a dotted name (case Limits.MAX:), an enum member, a literal, or a guard (case x if x == LIMIT:).

The underscore _ is the wildcard: it matches anything and binds nothing. case _: is the conventional fallback and must come last, since every later case would be unreachable. Inside larger patterns, _ ignores positions you don't care about, as in case ("deliver", _):.

Task: route parcel commands with a sequence pattern, a positive quantity guard and a final fallback. Handle ("deliver", n) with n > 0, ("cancel", parcel_id), and anything else.

def handle(command):
    match command:
        case ("deliver", qty) if qty > 0:
            return f"Deliver {qty}"
        case ("cancel", parcel_id):
            return f"Cancel {parcel_id}"
        case _:
            return "Check the message"

for cmd in [("deliver", 2), ("deliver", 0), ("cancel", "P-7"), ("lost",)]:
    print(handle(cmd))

This prints Deliver 2, Check the message, Cancel P-7 and Check the message. The zero quantity matches the pattern but fails the guard, so it falls through to the wildcard. For the worked check, a bare name in a pattern normally captures a value; it does not compare against a variable of the same name.

PEP 636 is the official pattern matching tutorial, and the match statement reference defines every pattern. Revisit if, elif and else for the alternative, then practise with the Python exercises and Python quiz.