Python的match-case通過模式匹配簡化條件邏輯，支持值匹配、結構解構、守衛(wèi)條件和類模式。其基本語法以match開頭，根據(jù)值或結構選擇case分支；如def http_status(code): match code: case 200: return "OK"；可匹配複雜數(shù)據(jù)類型如元組、列表、對象屬性；使用守衛(wèi)增加額外條件判斷如case x if x > 0；支持按類類型和屬性匹配對像如case Point(x=0, y=0)；從而減少嵌套條件，提升代碼可讀性和表達力。

Python's match-case (introduced in Python 3.10) works by allowing you to match values against patterns, making it easier to write cleaner and more readable conditional logic based on structure rather than just value.

Basic Syntax and How It Works

At its core, match-case behaves like a souped-up if-elif-else block. You start with the match keyword followed by a value to examine. Then, each case line tries to match that value using pattern matching.

Here's a simple example:

 def http_status(code):
    match code:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case _:
            return "Unknown"

In this function:

• If code is 200 , it returns "OK" .
• If it's 404 , it returns "Not Found" .
• The _ acts as a wildcard — if none of the above match, it catches everything else.

This kind of syntax becomes much more powerful when dealing with structured data types.

Matching Complex Data Structures

One of the strongest features of match-case is its ability to destructure complex data like lists, tuples, or classes.

For example:

 def handle_point(point):
    match point:
        case (x, y):
            print(f"Point at ({x}, {y})")
        case _:
            print("Not a valid point")

If you pass (3, 5) into this function, it will extract x=3 and y=5 . But if you pass something like [1, 2, 3] , it won't match the (x, y) pattern and fall back to the wildcard case.

You can also match nested structures:

 def describe_command(cmd):
    match cmd:
        case ["move", ("up" | "down" | "left" | "right")]:
            print("Moving direction:", cmd[1])
        case ["quit"]:
            print("Quitting game")
        case _:
            print("Invalid command")

This helps avoid deeply nested conditionals and makes your code more declarative.

Using Guards for Extra Conditions

Sometimes you need to match a pattern but also check an additional condition. That's where guards come in — they let you add an if condition to a case .

Example:

 def describe_number(num):
    match num:
        case x if x > 0:
            print("Positive number")
        case x if x < 0:
            print("Negative number")
        case _:
            print("Zero")

Here, each case matches any number, but only proceeds if the guard condition ( if x > 0 ) is true. This gives you fine-grained control without complicating the pattern itself.

Class Patterns (Matching Objects)

If you're working with objects, match-case lets you match based on class type and even extract attributes.

Say you have a class like:

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

Then you can do:

 def process(obj):
    match obj:
        case Point(x=0, y=0):
            print("Origin point")
        case Point(x=x, y=y):
            print(f"Point at ({x}, {y})")
        case _:
            print("Not a point object")

This makes it easy to write logic that reacts differently depending on the shape or content of the object passed in.

Match-case isn't just syntactic sugar — it changes how you think about handling different shapes of input. While basic use feels familiar, combining patterns, guards, and destructuring really shows its power.

It's not always needed, but when you find yourself writing long chains of if and elif checking structure, this feature might simplify things a lot.

基本上就這些。

以上是Python的匹配案例結構模式匹配（Python 3.10）如何工作？的詳細內(nèi)容。更多資訊請關注PHP中文網(wǎng)其他相關文章！