Skip to content

Python Match Case：结构化模式匹配详解（Python 3.10+）

Soren Atelier
Name
Soren Atelier

Updated on

几十年来，Python 开发者一直依赖 if-elif 链来处理分支逻辑：把一个变量与多个值对比、检查数据结构、或根据对象类型进行路由，往往都需要冗长的条件块；当分支增多时，可读性会迅速下降。一个要根据十种命令类型分发的函数，最终可能变成一堵由 elif 组成的“墙”，真正的业务逻辑被重复比较淹没。

这不仅是可读性问题。深层 if-elif 链更容易出现隐蔽 bug——条件写错位置、漏掉某个分支、或者出现意外“漏网”导致错误数据静默流向下游。许多语言早已通过模式匹配类结构解决了这些痛点，但 Python 直到 3.10 才拥有原生方案。

Python 3.10 引入了 match-case 语句（PEP 634），将结构化模式匹配带入语言核心。它远不止“值相等比较”：你可以解构序列、匹配字典形状、绑定变量、添加守卫条件，并按类类型分发——同时保持干净、声明式的语法。本指南会用实用示例覆盖所有主要模式类型。

📚

    什么是结构化模式匹配（Structural Pattern Matching）？

    结构化模式匹配允许你将一个值（“subject”）与一系列模式进行匹配，并执行第一个匹配成功的模式对应的代码块。不同于 C 或 Java 的 switch 语句，Python 的 match-case 不只是比对值——它会检查数据的结构（shape）。

    基本语法：

    match subject:
    case pattern1:
        # code for pattern1
    case pattern2:
        # code for pattern2
    case _:
        # default case (wildcard)

    关键特性：

    • 模式按从上到下顺序评估；第一个匹配成功的模式获胜。
    • 通配符模式 _ 匹配任意值，充当默认分支。
    • 模式可以绑定变量：被匹配值的部分会被捕获到名称中，可在 case 代码块里使用。
    • 没有 fall-through 行为：只会执行一个 case 代码块。

    Python 版本要求：match-case 需要 Python 3.10 或更高版本。用 python --version 检查版本。如果你在使用旧版本，需要先升级才能使用该特性。

    字面量模式（Literal Patterns）：匹配精确值

    match-case 最简单的用法是把一个值与字面量常量匹配：

    def get_http_status_message(code):
    match code:
        case 200:
            return "OK"
        case 201:
            return "Created"
        case 301:
            return "Moved Permanently"
        case 400:
            return "Bad Request"
        case 403:
            return "Forbidden"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case _:
            return f"Unknown status code: {code}"
 
print(get_http_status_message(404))  # Not Found
print(get_http_status_message(418))  # Unknown status code: 418

    字面量模式适用于整数、字符串、布尔值和 None：

    def describe_value(value):
    match value:
        case True:
            return "Boolean true"
        case False:
            return "Boolean false"
        case None:
            return "None value"
        case "":
            return "Empty string"
        case 0:
            return "Zero"
        case _:
            return f"Other: {value}"

    重要：True、False、None 通过“身份”（类似 is）来匹配，而不是通过相等（==）。因此 match 1 不会匹配 case True，尽管在 Python 中 1 == True 为 True。

    Or-Patterns：匹配多个值

    使用管道操作符 |，可以在一个 case 中匹配多个模式中的任意一个：

    def classify_day(day):
    match day.lower():
        case "monday" | "tuesday" | "wednesday" | "thursday" | "friday":
            return "Weekday"
        case "saturday" | "sunday":
            return "Weekend"
        case _:
            return "Invalid day"
 
print(classify_day("Saturday"))  # Weekend
print(classify_day("Wednesday")) # Weekday

    Or-patterns 适用于任何模式类型，不仅仅是字面量：

    def categorize_error(code):
    match code:
        case 400 | 401 | 403 | 404 | 405:
            return "Client error"
        case 500 | 502 | 503 | 504:
            return "Server error"
        case _:
            return "Other"

    变量捕获模式（Variable Capture Patterns）

    模式可以将匹配到的值的一部分捕获到变量中。模式里出现的裸名称会作为变量使用，绑定到该位置出现的任何值：

    def parse_command(command):
    match command.split():
        case ["quit"]:
            return "Exiting program"
        case ["hello", name]:
            return f"Hello, {name}!"
        case ["add", x, y]:
            return f"Sum: {int(x) + int(y)}"
        case _:
            return "Unknown command"
 
print(parse_command("hello Alice"))  # Hello, Alice!
print(parse_command("add 3 5"))      # Sum: 8
print(parse_command("quit"))         # Exiting program

    在 case ["hello", name] 中，变量 name 会捕获列表第二个位置上的字符串。这与字面量匹配完全不同——这里不存在“拿一个叫 name 的变量去比较”的含义；相反，这个模式是在创建一个新的绑定。

    捕获 vs 常量：常见陷阱

    因为裸名称默认是捕获模式，所以你不能直接用它来与某个变量的值进行匹配：

    QUIT_COMMAND = "quit"
 
match user_input:
    case QUIT_COMMAND:  # This captures into QUIT_COMMAND, not compare!
        print("This always matches!")

    要与常量匹配，应使用带点的名称或字面量值：

    class Commands:
    QUIT = "quit"
    HELP = "help"
 
match user_input:
    case Commands.QUIT:  # Dotted name: compares against the value
        print("Quitting")
    case Commands.HELP:
        print("Showing help")

    带点的名称（包含 .）会被当作值查找，而不是捕获模式。这是 PEP 634 的刻意设计。

    序列模式（Sequence Patterns）：解构列表与元组

    match-case 在解构序列方面非常强大。你可以同时匹配长度和内容：

    def process_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})"
        case _:
            return "Not a valid point"
 
print(process_point((0, 0)))   # Origin
print(process_point((5, 0)))   # On x-axis at 5
print(process_point((3, 7)))   # Point at (3, 7)

    星号模式（Star Patterns）：可变长度序列

    使用 * 匹配可变长度的序列：

    def analyze_sequence(seq):
    match seq:
        case []:
            return "Empty sequence"
        case [single]:
            return f"Single element: {single}"
        case [first, second]:
            return f"Pair: {first}, {second}"
        case [first, *middle, last]:
            return f"First: {first}, Last: {last}, Middle has {len(middle)} items"
 
print(analyze_sequence([]))              # Empty sequence
print(analyze_sequence([42]))            # Single element: 42
print(analyze_sequence([1, 2, 3, 4, 5])) # First: 1, Last: 5, Middle has 3 items

    嵌套序列模式（Nested Sequence Patterns）

    模式可以嵌套，以匹配更复杂的数据结构：

    def process_matrix_row(row):
    match row:
        case [[a, b], [c, d]]:
            return f"2x2 block: {a}, {b}, {c}, {d}"
        case [first_row, *rest]:
            return f"First row: {first_row}, remaining rows: {len(rest)}"
 
print(process_matrix_row([[1, 2], [3, 4]]))
# 2x2 block: 1, 2, 3, 4

    映射模式（Mapping Patterns）：匹配字典

    映射模式通过检查特定 key（并可选捕获其值）来匹配类似字典的对象：

    def handle_api_response(response):
    match response:
        case {"status": "success", "data": data}:
            return f"Success! Data: {data}"
        case {"status": "error", "message": msg}:
            return f"Error: {msg}"
        case {"status": "error", "code": code, "message": msg}:
            return f"Error {code}: {msg}"
        case {"status": status}:
            return f"Unknown status: {status}"
        case _:
            return "Invalid response format"
 
print(handle_api_response({"status": "success", "data": [1, 2, 3]}))
# Success! Data: [1, 2, 3]
 
print(handle_api_response({"status": "error", "message": "Not found"}))
# Error: Not found

    映射模式只要字典包含指定 key 就会匹配——额外的 key 会被忽略。因此它非常适合处理 JSON 数据和 API 响应。

    用 **rest 捕获剩余 key：

    def extract_config(config):
    match config:
        case {"host": host, "port": port, **rest}:
            return f"Server: {host}:{port}, extra config: {rest}"
        case _:
            return "Missing required config"
 
print(extract_config({"host": "localhost", "port": 8080, "debug": True}))
# Server: localhost:8080, extra config: {'debug': True}

    守卫子句（Guard Clauses）：为模式增加条件

    守卫是在模式后添加 if 条件，只有条件为真时该模式才算匹配成功。流程是：先匹配模式；若模式匹配，再计算守卫表达式：

    def classify_number(n):
    match n:
        case x if x < 0:
            return "Negative"
        case 0:
            return "Zero"
        case x if x % 2 == 0:
            return "Positive even"
        case x if x % 2 == 1:
            return "Positive odd"
 
print(classify_number(-5))  # Negative
print(classify_number(0))   # Zero
print(classify_number(4))   # Positive even
print(classify_number(7))   # Positive odd

    当单靠模式无法表达完整条件时，守卫就非常关键：

    def validate_age(data):
    match data:
        case {"name": name, "age": age} if age < 0:
            return f"Invalid: {name} has negative age"
        case {"name": name, "age": age} if age < 18:
            return f"{name} is a minor (age {age})"
        case {"name": name, "age": age} if age >= 18:
            return f"{name} is an adult (age {age})"
        case _:
            return "Invalid data format"
 
print(validate_age({"name": "Alice", "age": 25}))
# Alice is an adult (age 25)

    类模式（Class Patterns）：匹配对象类型

    类模式检查值是否为某个类的实例，并可选解构其属性：

    from dataclasses import dataclass
 
@dataclass
class Point:
    x: float
    y: float
 
@dataclass
class Circle:
    center: Point
    radius: float
 
@dataclass
class Rectangle:
    top_left: Point
    width: float
    height: float
 
def describe_shape(shape):
    match shape:
        case Circle(center=Point(x=0, y=0), radius=r):
            return f"Circle at origin with radius {r}"
        case Circle(center=center, radius=r) if r > 100:
            return f"Large circle at ({center.x}, {center.y})"
        case Circle(center=center, radius=r):
            return f"Circle at ({center.x}, {center.y}) with radius {r}"
        case Rectangle(width=w, height=h) if w == h:
            return f"Square with side {w}"
        case Rectangle(top_left=tl, width=w, height=h):
            return f"Rectangle at ({tl.x}, {tl.y}), {w}x{h}"
        case _:
            return "Unknown shape"
 
print(describe_shape(Circle(Point(0, 0), 5)))
# Circle at origin with radius 5
 
print(describe_shape(Rectangle(Point(1, 2), 10, 10)))
# Square with side 10

    对于没有 __match_args__ 的类，使用关键字参数。dataclasses 和 named tuples 会自动设置 __match_args__，从而支持位置模式：

    @dataclass
class Color:
    r: int
    g: int
    b: int
 
def describe_color(color):
    match color:
        case Color(0, 0, 0):
            return "Black"
        case Color(255, 255, 255):
            return "White"
        case Color(r, 0, 0):
            return f"Red shade (r={r})"
        case Color(0, g, 0):
            return f"Green shade (g={g})"
        case Color(0, 0, b):
            return f"Blue shade (b={b})"
        case Color(r, g, b):
            return f"RGB({r}, {g}, {b})"
 
print(describe_color(Color(255, 0, 0)))   # Red shade (r=255)
print(describe_color(Color(128, 64, 32))) # RGB(128, 64, 32)

    匹配内置类型（Built-in Types）

    你也可以匹配内置类型来做类型检查：

    def process_value(value):
    match value:
        case int(n):
            return f"Integer: {n}"
        case float(n):
            return f"Float: {n}"
        case str(s):
            return f"String: '{s}'"
        case list(items):
            return f"List with {len(items)} items"
        case dict(d):
            return f"Dict with keys: {list(d.keys())}"
        case _:
            return f"Other type: {type(value).__name__}"
 
print(process_value(42))          # Integer: 42
print(process_value("hello"))     # String: 'hello'
print(process_value([1, 2, 3]))   # List with 3 items

    Match Case vs if-elif：分别适合什么场景？

    标准match-caseif-elif
    Python 版本仅 3.10+全版本
    值比较更清晰，每个 case 一个值重复写变量更啰嗦
    解构内置支持（序列、dict、对象）需要手动解包
    类型检查原生类模式需要 isinstance()
    守卫条件模式后 if标准 if/elif
    变量绑定自动捕获手动赋值
    性能优化过的模式分发顺序求值
    可读性4+ 且结构化分支更好1-3 个简单条件更好
    Fall-through无（设计如此）缺失 elif 时可能出现

    何时 match-case 明显更好：

    # Parsing structured data -- match-case
def handle_event(event):
    match event:
        case {"type": "click", "x": x, "y": y}:
            process_click(x, y)
        case {"type": "keypress", "key": key, "modifiers": [*mods]}:
            process_key(key, mods)
        case {"type": "scroll", "delta": delta} if delta != 0:
            process_scroll(delta)

    等价的 if-elif：

    # Same logic with if-elif -- more verbose
def handle_event(event):
    if event.get("type") == "click" and "x" in event and "y" in event:
        process_click(event["x"], event["y"])
    elif event.get("type") == "keypress" and "key" in event and "modifiers" in event:
        process_key(event["key"], event["modifiers"])
    elif event.get("type") == "scroll" and event.get("delta", 0) != 0:
        process_scroll(event["delta"])

    何时 if-elif 仍然更好：

    # Simple range checks -- if-elif is clearer
if temperature > 100:
    status = "boiling"
elif temperature > 50:
    status = "hot"
elif temperature > 20:
    status = "warm"
else:
    status = "cold"

    match-case 不支持直接在模式里做区间比较。你必须为每个分支都写 guard，这会抵消可读性优势。

    真实世界用例

    命令行参数解析（Command-Line Argument Parsing）

    import sys
 
def main():
    match sys.argv[1:]:
        case ["help"]:
            print("Available commands: help, version, run, test")
        case ["version"]:
            print("v1.0.0")
        case ["run", filename]:
            print(f"Running {filename}")
        case ["run", filename, "--verbose"]:
            print(f"Running {filename} with verbose output")
        case ["test", *test_files] if test_files:
            print(f"Testing: {', '.join(test_files)}")
        case ["test"]:
            print("Running all tests")
        case [unknown, *_]:
            print(f"Unknown command: {unknown}")
        case []:
            print("No command provided. Use 'help' for usage.")

    状态机实现（State Machine Implementation）

    from dataclasses import dataclass
from typing import Optional
 
@dataclass
class State:
    name: str
    data: Optional[dict] = None
 
def transition(state, event):
    match (state.name, event):
        case ("idle", "start"):
            return State("loading", {"progress": 0})
        case ("loading", "progress"):
            progress = state.data.get("progress", 0) + 25
            if progress >= 100:
                return State("ready", {"progress": 100})
            return State("loading", {"progress": progress})
        case ("loading", "cancel"):
            return State("idle")
        case ("ready", "process"):
            return State("processing", state.data)
        case ("processing", "complete"):
            return State("done", {"result": "success"})
        case ("processing", "error"):
            return State("error", {"message": "Processing failed"})
        case (_, "reset"):
            return State("idle")
        case (current, unknown_event):
            print(f"No transition from '{current}' on '{unknown_event}'")
            return state
 
# Usage
state = State("idle")
for event in ["start", "progress", "progress", "progress", "progress", "process", "complete"]:
    state = transition(state, event)
    print(f"Event: {event} -> State: {state.name}, Data: {state.data}")

    JSON API 响应处理器（JSON API Response Handler）

    def process_api_result(response):
    match response:
        case {"data": {"users": [*users]}, "meta": {"total": total}}:
            print(f"Found {total} users, received {len(users)}")
            for user in users:
                match user:
                    case {"name": name, "role": "admin"}:
                        print(f"  Admin: {name}")
                    case {"name": name, "role": role}:
                        print(f"  {role.title()}: {name}")
 
        case {"data": {"users": []}}:
            print("No users found")
 
        case {"error": {"code": code, "message": msg}} if code >= 500:
            print(f"Server error ({code}): {msg}")
            raise RuntimeError(msg)
 
        case {"error": {"code": code, "message": msg}}:
            print(f"Client error ({code}): {msg}")
 
        case _:
            print(f"Unexpected response format: {type(response)}")
 
# Example
process_api_result({
    "data": {"users": [
        {"name": "Alice", "role": "admin"},
        {"name": "Bob", "role": "editor"}
    ]},
    "meta": {"total": 2}
})

    配置文件解析器（Configuration File Parser）

    def apply_config(settings):
    for key, value in settings.items():
        match (key, value):
            case ("database", {"host": host, "port": int(port), "name": db}):
                print(f"DB connection: {host}:{port}/{db}")
            case ("database", _):
                raise ValueError("Invalid database config: need host, port, name")
            case ("logging", {"level": level}) if level in ("DEBUG", "INFO", "WARNING", "ERROR"):
                print(f"Log level set to {level}")
            case ("logging", {"level": level}):
                raise ValueError(f"Invalid log level: {level}")
            case ("features", {"enabled": list(features)}):
                print(f"Enabled features: {', '.join(features)}")
            case ("features", {"enabled": _}):
                raise TypeError("Features must be a list")
            case (key, _):
                print(f"Unknown config key: {key}")
 
apply_config({
    "database": {"host": "localhost", "port": 5432, "name": "mydb"},
    "logging": {"level": "INFO"},
    "features": {"enabled": ["auth", "cache", "metrics"]}
})

    数据转换流水线（Data Transformation Pipeline）

    def transform_record(record):
    """Transform raw data records into standardized format."""
    match record:
        case {"timestamp": ts, "value": float(v) | int(v), "unit": str(unit)}:
            return {"time": ts, "measurement": float(v), "unit": unit.lower()}
 
        case {"timestamp": ts, "value": str(v), "unit": str(unit)}:
            try:
                return {"time": ts, "measurement": float(v), "unit": unit.lower()}
            except ValueError:
                return {"time": ts, "measurement": None, "unit": unit.lower(), "error": f"Cannot parse: {v}"}
 
        case {"timestamp": ts, "value": v}:
            return {"time": ts, "measurement": float(v), "unit": "unknown"}
 
        case {"values": [*values]} if values:
            return [transform_record({"timestamp": None, "value": v, "unit": "batch"}) for v in values]
 
        case _:
            return {"error": f"Unrecognized format: {record}"}
 
# Examples
print(transform_record({"timestamp": "2026-01-01", "value": 42.5, "unit": "Celsius"}))
print(transform_record({"timestamp": "2026-01-01", "value": "98.6", "unit": "F"}))

    高级模式技巧（Advanced Pattern Techniques）

    AS 模式：绑定整个匹配值

    使用 as 可以在解构的同时捕获整个匹配值：

    def process_item(item):
    match item:
        case {"name": str(name), "price": float(price)} as product if price > 100:
            print(f"Premium product: {product}")
        case {"name": str(name), "price": float(price)} as product:
            print(f"Standard product: {product}")

    组合多种模式类型（Combining Pattern Types）

    模式可以自然组合：序列、映射、类模式可以混用：

    @dataclass
class Order:
    items: list
    customer: dict
 
def process_order(order):
    match order:
        case Order(items=[single_item], customer={"vip": True}):
            print(f"VIP single-item order: {single_item}")
        case Order(items=[_, _, *rest], customer={"name": name}) if len(rest) > 0:
            print(f"{name} ordered {2 + len(rest)} items")
        case Order(items=[], customer=_):
            print("Empty order")

    在 Jupyter Notebooks 中使用 Match-Case

    模式匹配在数据分析工作流中特别有用：你经常需要处理不同数据格式或 API 响应。在 Jupyter notebooks 里交互式探索数据时，match-case 能以更干净的方式处理你遇到的多种数据“形状”。

    def classify_cell_output(output):
    """Classify Jupyter cell output by type."""
    match output:
        case {"output_type": "stream", "text": text}:
            return f"Text output: {len(text)} chars"
        case {"output_type": "error", "ename": name, "evalue": value}:
            return f"Error: {name}: {value}"
        case {"output_type": "display_data", "data": {"image/png": _}}:
            return "Image output"
        case {"output_type": "execute_result", "data": {"text/html": html}}:
            return "HTML table output"
        case _:
            return "Unknown output type"

    对于希望在 notebooks 里使用 AI 辅助来处理模式匹配等 Python 3.10+ 特性的 data scientists，RunCell (opens in a new tab) 在 Jupyter 内提供了一个 AI agent，可以基于你的真实数据结构帮助编写、调试与优化 match-case 语句。

    常见错误与规避方法（Common Mistakes and How to Avoid Them）

    错误 1：在 Python < 3.10 中使用 match-case

    # This fails with SyntaxError on Python 3.9 and earlier
match value:
    case 1:
        print("one")

    修复：检查 sys.version_info >= (3, 10) 或升级 Python。

    错误 2：把 case 名称当作比较

    expected = 200
 
match status_code:
    case expected:  # WRONG: creates a new variable 'expected'
        print("OK")

    修复：使用 dotted name、字面量，或使用 guard：

    match status_code:
    case code if code == expected:
        print("OK")

    错误 3：忘记通配符分支

    没有 case _ 时，未匹配的值会静默地什么都不做：

    match command:
    case "start":
        run()
    case "stop":
        halt()
    # If command is "pause", nothing happens -- no error, no warning

    修复：总是包含一个通配符分支来显式处理：

    match command:
    case "start":
        run()
    case "stop":
        halt()
    case _:
        raise ValueError(f"Unknown command: {command}")

    错误 4：顺序依赖但缺乏特异性

    模式自上而下匹配。把“宽泛模式”放在“具体模式”前面会造成遮蔽：

    # WRONG: the first case always matches
match point:
    case (x, y):       # Captures everything
        print("generic")
    case (0, 0):       # Never reached
        print("origin")

    修复：把更具体的模式放在前面：

    match point:
    case (0, 0):
        print("origin")
    case (x, y):
        print(f"point at ({x}, {y})")

    性能考量（Performance Considerations）

    match-case 会被编译为高效的字节码。对于简单字面量匹配，Python 编译器会做类似字典查找的优化；对于结构化模式，它会生成决策树以避免重复检查。

    基准测试显示：当 case 数较少（少于 5 个）时，match-case 与 if-elif 性能相近；当分发分支较多（10+）时，match-case 可能因为字节码优化而更快，尤其是字面量模式的情况。

    不过，如果你只是做“值到函数”的映射，字典分发仍然更简洁、更快：

    # For simple value-to-action mapping, a dict is cleaner and faster
handlers = {
    "click": handle_click,
    "scroll": handle_scroll,
    "keypress": handle_keypress,
}
 
handler = handlers.get(event_type, handle_unknown)
handler(event_data)

    当你需要结构检查、解构或守卫条件（字典查找无法表达）时，再使用 match-case。

    常见问答（FAQ）

    match-case 需要什么 Python 版本？

    match-case 语句需要 Python 3.10 或更高版本。它在 2021 年 10 月发布的 Python 3.10 中作为 PEP 634 的一部分引入。在 Python 3.9 或更早版本中使用 match-case 会导致 SyntaxError。你可以在终端运行 python --version 来检查版本。

    Python match-case 和其他语言的 switch-case 一样吗？

    不一样。Python 的 match-case 是结构化模式匹配，比传统 switch-case 更强大。C 或 Java 的 switch-case 通常只做值比较；而 Python 的 match-case 可以解构序列和字典、按属性匹配类实例、从匹配的数据中绑定变量，并应用守卫条件。它更接近 Rust、Scala 或 Haskell 的模式匹配。

    match-case 像 C switch 那样支持 fall-through 吗？

    不支持。Python 的 match-case 只执行第一个匹配成功的 case 块，然后退出 match 语句。没有 fall-through 行为，也不需要 break。如果你希望多个模式执行相同代码，使用 or-patterns 与管道操作符：case "a" | "b" | "c": 会匹配其中任意值。

    match-case 可以配合正则表达式使用吗？

    不能直接使用。match-case 的模式是结构化的，不是基于 regex 的。不过你可以用守卫子句来做 regex 匹配：case str(s) if re.match(r"pattern", s): 将结构化类型检查与 guard 中的正则校验结合起来。

    match-case 如何处理 None？

    None 可以用字面量模式 case None: 来匹配。由于 None 在 Python 中是单例对象，匹配使用身份比较（等价于 is None）。因此 case None: 只会匹配真正的 None，而不会匹配 0、False、空字符串等其他 falsy 值。

    如果没有任何 case 匹配，会发生什么？

    如果没有 case 匹配且不存在通配符模式（case _:），match 语句会静默地什么都不做——执行会继续到 match 块之后，不会抛异常。这也是为什么最佳实践是总包含通配符分支：提供默认行为，或对意外值抛出异常。

    结论（Conclusion）

    Python 的 match-case 语句将结构化模式匹配带入了这门长期依赖 if-elif 链来处理复杂分支逻辑的语言。它提供了一种声明式方法来检查数据形状、解构序列与字典、按对象类型分发，并进行变量绑定——读起来也比等价的条件代码更清晰。

    关键点在于：match-case 不只是 switch 语句的替代品，而是一个面向结构化数据的工具：用于解析命令、处理 API 响应、实现状态机、以及按对象类型进行路由。当你的分支逻辑关注的是“数据长什么样”，而不是简单的“值是否相等”，match-case 往往能生成更短、更易维护的代码。

    可以从最简单的字面量模式开始，然后按需求逐步引入序列解构、映射模式与类模式。始终包含一个通配符分支来显式处理意外输入，把具体模式放在通用模式之前，并牢记：裸名称会捕获值，而不是与现有变量进行比较。

    如果你希望用自己的数据交互式探索 match-case 模式，Jupyter notebooks 是逐步测试模式的理想环境。RunCell (opens in a new tab) 通过理解 Python 3.10+ 特性并根据你的数据形状提出模式结构建议，用 AI 辅助增强这一工作流。

    📚