Python Switch Case Statement (match-case)

Unlike many other programming languages, Python does not have a traditional switch-case statement. Before Python 3.10, developers used if-elif-else chains or dictionary lookups to achieve similar functionality.

Python 3.10 introduced the match-case statement (also called structural pattern matching), which provides a cleaner way to handle multiple conditions.

This article explains how to implement switch-case behavior in Python using all three approaches with practical examples.

Using if-elif-else #

The if-elif-else chain is the most straightforward way to handle multiple conditions. It works in all Python versions and is best suited for a small number of conditions.

Here is an example:

def get_day_type(day):
    if day == "Saturday" or day == "Sunday":
        return "Weekend"
    elif day == "Monday":
        return "Start of the work week"
    elif day == "Friday":
        return "End of the work week"
    else:
        return "Midweek"

print(get_day_type("Saturday"))
print(get_day_type("Monday"))
print(get_day_type("Wednesday"))

Weekend
Start of the work week
Midweek

The function checks each condition in order. When a match is found, it returns the result and stops. If none of the conditions match, the else block runs.

This approach is easy to read and debug, but it gets verbose when you have many conditions.

Using Dictionary Lookup #

A dictionary can map values to results or functions, acting as a lookup table. This approach is more concise than if-elif-else when you have many simple mappings.

In the following example, we are using a dictionary to map HTTP status codes to their descriptions:

def http_status(code):
    statuses = {
        200: "OK",
        301: "Moved Permanently",
        404: "Not Found",
        500: "Internal Server Error",
    }
    return statuses.get(code, "Unknown Status")

print(http_status(200))
print(http_status(404))
print(http_status(999))

OK
Not Found
Unknown Status

The get() method returns the value for the given key. If the key is not found, it returns the default value ("Unknown Status").

You can also map keys to functions. In the code below, we are creating a simple calculator using a dictionary of functions:

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

operations = {
    "+": add,
    "-": subtract,
    "*": multiply,
}

func = operations.get("+")
print(func(10, 5))

15

Dictionary lookups are fast and scale well, but they cannot handle complex conditions like ranges or pattern matching.

Using match-case (Python 3.10+) #

The match-case statement was introduced in Python 3.10 . It compares a value against a series of patterns and executes the matching block.

The match-case statement takes the following form:

match expression:
    case 1:
        ...
    case 2:
        ...
    case _:
        ...

The match keyword is followed by the expression to evaluate. Each case defines a pattern to match against. The case _ is the wildcard (default) case that matches any value not matched by previous patterns, similar to default in other languages.

Here is a basic example:

def http_error(status):
    match status:
        case 400:
            return "Bad Request"
        case 401 | 403:
            return "Not Allowed"
        case 404:
            return "Not Found"
        case _:
            return "Unknown Error"

print(http_error(403))
print(http_error(404))
print(http_error(999))

Not Allowed
Not Found
Unknown Error

You can combine multiple values in a single case using the | (or) operator, as shown with 401 | 403.

Let us look at the different pattern matching capabilities of the match-case statement.

Matching with Variables #

You can capture values from the matched expression and use them in the case block. In the following example, we are matching a tuple representing a point on a coordinate plane:

point = (3, 7)

match point:
    case (0, 0):
        print("Origin")
    case (x, 0):
        print(f"On x-axis at {x}")
    case (0, y):
        print(f"On y-axis at {y}")
    case (x, y):
        print(f"Point at ({x}, {y})")

Point at (3, 7)

The variables x and y are assigned the values from the tuple when the pattern matches.

Matching with Guards #

You can add an if condition (called a guard) to a case pattern for more precise matching:

def classify_age(age):
    match age:
        case n if n < 0:
            return "Invalid"
        case n if n < 18:
            return "Minor"
        case n if n < 65:
            return "Adult"
        case _:
            return "Senior"

print(classify_age(10))
print(classify_age(30))
print(classify_age(70))

Minor
Adult
Senior

The guard (if n < 18) adds an extra condition that must be true for the case to match.

Matching Dictionaries #

The match-case statement can match against dictionary structures, which is useful when working with JSON data or API responses:

def process_command(command):
    match command:
        case {"action": "create", "name": name}:
            print(f"Creating {name}")
        case {"action": "delete", "name": name}:
            print(f"Deleting {name}")
        case {"action": action}:
            print(f"Unknown action: {action}")

process_command({"action": "create", "name": "users"})
process_command({"action": "delete", "name": "logs"})
process_command({"action": "update"})

Creating users
Deleting logs
Unknown action: update

The pattern only needs to match the specified keys. Extra keys in the dictionary are ignored.

Matching Constants #

A plain name in a case pattern is a capture pattern. Python does not compare the value with a variable of that name. It assigns the value to the name, the same way x and y are assigned in the point example. This is a common mistake when matching against constants.

In the following example, we want to compare status with the HTTP_OK constant:

HTTP_OK = 200

def check(status):
    match status:
        case HTTP_OK:
            return "OK"
        case 404:
            return "Not Found"

Python refuses to run this code and reports the following error:

SyntaxError: name capture 'HTTP_OK' makes remaining patterns unreachable

The case HTTP_OK: pattern matches every value. The case 404: block below it can never run.

If you move case HTTP_OK: below case 404:, the error goes away. The function now returns "OK" for every status code other than 404, including 500.

To compare against a constant, you need a dotted name. Python treats a name with a dot as a value and compares it with ==. The HTTPStatus enum from the standard library already defines the HTTP status codes:

from http import HTTPStatus

def check(status):
    match status:
        case HTTPStatus.OK:
            return "OK"
        case HTTPStatus.NOT_FOUND:
            return "Not Found"
        case _:
            return "Other"

print(check(200))
print(check(404))
print(check(500))

OK
Not Found
Other

HTTPStatus is an IntEnum, and HTTPStatus.OK is equal to the integer 200. The same rule applies to members of your own Enum classes and to module attributes such as config.TIMEOUT.

Which Approach to Use #

Use if-elif-else when you have a handful of conditions or need complex boolean expressions. Use dictionary lookups when you are mapping values directly. Use match-case when you need to match against data structures, capture variables, or use guard conditions.

Quick Reference #

# if-elif-else
if x == 1:
    result = "one"
elif x == 2:
    result = "two"
else:
    result = "other"

# Dictionary lookup
result = {1: "one", 2: "two"}.get(x, "other")

# match-case (Python 3.10+)
match x:
    case 1:
        result = "one"
    case 2:
        result = "two"
    case _:
        result = "other"

FAQ #

Does Python have a switch statement?
Not a traditional one. Python uses if-elif-else chains, dictionary lookups, or the match-case statement (Python 3.10+) to achieve similar functionality.

What Python version do I need for match-case?
Python 3.10 or later. If you need to support older versions, use if-elif-else or dictionary lookups instead.

Is match-case faster than if-elif-else?
For most use cases the performance difference is negligible. Choose based on readability and the complexity of your conditions, not speed. Dictionary lookups are often the fastest for simple value mappings.

What happens if no case matches and there is no wildcard?
Nothing. If no pattern matches and there is no case _, the match statement completes without executing any block. No error is raised.

Can I use match-case with classes?
Yes. You can match against class instances using the case ClassName(attr=value) syntax. This is useful for handling different object types in a clean way.

Conclusion #

Python does not have a built-in switch statement, but it offers three alternatives. Use if-elif-else for simple conditions, dictionary lookups for direct value mappings, and match-case for pattern matching on complex data structures.

For more Python tutorials, see our guides on for loops , while loops , and dictionaries .

About the authors

Dejan Panovski

Dejan Panovski is the founder of Linuxize, an RHCSA-certified Linux system administrator and DevOps engineer based in Skopje, Macedonia. Author of 1000+ Linux tutorials with 20+ years of experience turning complex Linux tasks into clear, reliable guides.

View author page