Python 高级教程之结构化模式匹配

Posted 2022-05-04 海拥✘

Python 3.10 开始充满了许多令人着迷的新特性。其中一个特别引起了我的注意——结构模式匹配——或者我们大多数人都知道的 switch/case 语句。

尽管 Switch 语句是大多数语言的共同特征，但 Python 中没有使用 Switch 语句。通过将 match-case 语句作为 switch-case v2.0 引入，Python 超越了这些语言。

早在 2006 年，就提出了 PEP 3103，建议实施 switch-case 语句。然而，在 PyCon 2007 的一项民意调查没有收到对该功能的支持后，Python 开发人员放弃了它。

到 2020 年，Python 的创建者 Guido van Rossum 提交了第一个显示新匹配语句的文档，这些语句被命名为结构模式匹配，见 PEP 634。

让我们来看看这个新逻辑是如何工作的。

结构化模式匹配

模式匹配在 match 之后接受一个值，并允许我们写出几个潜在的案例，每个案例都由case 定义。 在匹配案例之间找到匹配的地方，我们将执行相应的代码。

语法和操作

模式匹配的通用语法是：

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

match 语句接受一个表达式并将其值与作为一个或多个 case 块给出的连续模式进行比较。具体来说，模式匹配通过以下方式进行操作：

1. 使用具有类型和形状的数据 (the subject)
2. 评估语句subject中的match
3. case从上到下将主题与语句中的每个模式进行比较，直到确认匹配。
4. 执行与已确认匹配的模式相关联的动作
5. 如果未确认完全匹配，则最后一种情况，即通配符_（如果提供）将用作匹配情况。如果未确认完全匹配且不存在通配符大小写，则整个匹配块为空操作。

声明式方法

读者可能会通过使用 C、Java 或 javascript（以及许多其他语言）中的 switch 语句将主题（数据对象）与文字（模式）进行匹配的简单示例来了解模式匹配。switch 语句通常用于将对象/表达式与包含文字的 case 语句进行比较。

更强大的模式匹配示例可以在 Scala 和 Elixir 等语言中找到。对于结构模式匹配，该方法是“声明性的”，并明确说明数据匹配的条件（模式）。

虽然使用嵌套“if”语句的“命令式”指令系列可用于完成类似于结构模式匹配的事情，但它不如“声明式”方法清晰。相反，“声明性”方法说明了匹配的条件，并且通过其显式模式更具可读性。虽然结构模式匹配可以以最简单的形式使用，将变量与 case 语句中的文字进行比较，但它对 Python 的真正价值在于它对主题类型和形状的处理。

简单模式：匹配文字

让我们把这个例子看成最简单形式的模式匹配：一个值，即主题，被匹配到几个字面量，即模式。在下面的示例中，status是 match 语句的主题。模式是每个 case 语句，其中文字表示请求状态代码。匹配后执行与案例相关的操作：

例如：

http_code = "418"
match http_code:
    case "200":
        print("OK")
        do_something_good()
    case "404":
        print("Not Found")
        do_something_bad()
    case "418":
        print("yyds")
        make_coffee()
    case _:
        print("Code not found")

在这里，我们根据在 http_code 中找到的值检查多个条件并执行不同的操作。

很明显我们也可以使用一大块 if-elif-else 语句构建相同的逻辑：

http_code = "418"
if http_code == "418":
    print("OK")
elif http_code == "404":
    print("Not Found")
elif http_code == "418"
    print("yyds")
else:
    print("Code not found")

如果传给上述函数的 status 为 418，则会返回 “yyds”。 如果传给上述函数的 status 为 500，则带有 _ 的 case 语句将作为通配符匹配，并会返回 "Code not found"。 请注意最后一个代码块：变量名 _ 将作为 通配符 并确保目标将总是被匹配。 _ 的使用是可选的。

通过使用 match-case 语句，我们删除了重复的 http_code == ，这在测试许多不同的条件时看起来更清晰。

你可以使用 | （“ or ”）在一个模式中组合几个字面值:

case 401 | 403 | 404:
    return "Not allowed"

无通配符的行为

如果我们修改上面的例子，去掉最后一个 case 块，这个例子就变成:

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "yyds"

如果不在 case 语句中使用 _，可能会出现不存在匹配的情况。如果不存在匹配，则行为是一个 no-op。例如，如果传入了值为 500 的 status ，就会发生 no-op。

带有字面值和变量的模式

模式可以看起来像解包形式，而且模式可以用来绑定变量。在这个例子中，一个数据点可以被解包为它的 x 坐标和 y 坐标:

# point 是一个 (x, y) 元组
match point:
    case (0, 0):
        print("Origin")
    case (0, y):
        print(f"Y=y")
    case (x, 0):
        print(f"X=x")
    case (x, y):
        print(f"X=x, Y=y")
    case _:
        raise ValueError("Not a point")

第一个模式有两个字面值 (0, 0) ，可以看作是上面所示字面值模式的扩展。接下来的两个模式结合了一个字面值和一个变量，而变量 绑定 了一个来自主词的值（point）。 第四种模式捕获了两个值，这使得它在概念上类似于解包赋值 (x, y) = point 。

模式和类

如果你使用类来结构化你的数据，你可以使用类的名字，后面跟一个类似构造函数的参数列表，作为一种模式。这种模式可以将类的属性捕捉到变量中:

class Point:
    x: int
    y: int

def location(point):
    match point:
        case Point(x=0, y=0):
            print("Origin is the point's location.")
        case Point(x=0, y=y):
            print(f"Y=y and the point is on the y-axis.")
        case Point(x=x, y=0):
            print(f"X=x and the point is on the x-axis.")
        case Point():
            print("The point is located somewhere else on the plane.")
        case _:
            print("Not a point")

带有位置参数的模式

你可以在某些为其属性提供了排序的内置类（例如 dataclass）中使用位置参数。 你也可以通过在你的类中设置 match_args 特殊属性来为模式中的属性定义一个专门的位置。 如果它被设为 (“x”, “y”)，则以下模式均为等价的（并且都是将 y 属性绑定到 var 变量）:

Point(1, var)
Point(1, y=var)
Point(x=1, y=var)
Point(y=var, x=1)

嵌套模式

模式可以任意地嵌套。 例如，如果我们的数据是由点组成的短列表，则它可以这样被匹配:

match points:
    case []:
        print("列表中没有points。")
    case [Point(0, 0)]:
        print("原点是列表中的唯一点。")
    case [Point(x, y)]:
        print(f"单点 x, y 在列表中。")
    case [Point(0, y1), Point(0, y2)]:
        print(f"Y 轴上的两个点 y1, y2 在列表中。")
    case _:
        print("列表中还有其他内容。")

复杂模式和通配符

到目前为止，这些例子仅在最后一个 case 语句中使用了 _。 但通配符可以被用在更复杂的模式中，例如 ('error', code, _)。 举例来说:

match test_variable:
    case ('warning', code, 40):
        print("A warning has been received.")
    case ('error', code, _):
        print(f"An error code occurred.")

在上述情况下，test_variable 将可匹配 (‘error’, code, 100) 和 (‘error’, code, 800)。

约束项

我们可以向一个模式添加 if 子句，称为“约束项”。 如果约束项为假值，则 match 将继续尝试下一个 case 语句块。 请注意值的捕获发生在约束项被求值之前。:

match point:
    case Point(x, y) if x == y:
        print(f"The point is located on the diagonal Y=X at x.")
    case Point(x, y):
        print(f"Point is not on the diagonal.")

其他关键特性

一些其他关键特性:

• 类似于解包赋值，元组和列表模式具有完全相同的含义，而且实际上能匹配任意序列。 从技术上说，目标必须为一个序列。 因而，一个重要的例外是模式不能匹配迭代器。 而且，为了避免一个常见的错误，序列模式不能匹配字符串。

• 序列模式支持通配符: [x, y, *rest] 和 (x, y, *rest) 的作用类似于解包赋值中的通配符。 在 * 之后的名称也可以为 _，因此 (x, y, *_) 可以匹配包含两个条目的序列而不必绑定其余的条目。

• 映射模式: "bandwidth": b, "latency": l 会从一个字典中捕获 “bandwidth” 和 “latency” 值。 与序列模式不同，额外的键会被忽略。 也支持通配符 **rest。 （但 **_ 是冗余的，因而不被允许。）

• 子模式可使用 as 关键字来捕获:

case (Point(x1, y1), Point(x2, y2) as p2): ...

x1, y1, x2, y2 等绑定就如你在没有 as 子句的情况下所期望的，而 p2 会绑定目标的整个第二项。

• 大多数字面值是按相等性比较的。 但是，单例对象 True, False 和 None 则是按标识号比较的。

• 命名常量也可以在模式中使用。 这些命名常量必须为带点号的名称以防止常量被解读为捕获变量:

from enum import Enum
class Color(Enum):
    RED = 0
    GREEN = 1
    BLUE = 2

match color:
    case Color.RED:
        print("I see red!")
    case Color.GREEN:
        print("Grass is green")
    case Color.BLUE:
        print("I'm feeling the blues :(")

完整规格说明参见 PEP 634。 动机与理由参见 PEP 635，更详细的教程参见 PEP 636。