Python 进化史:从 3.8 到 3.14 各版本重要新特性全盘点

目录

• 3.8
• 一、赋值表达式 :=（海象运算符）
• 二、仅位置参数语法 /
• 三、f-string 自文档化调试支持
• 3.9
• 一、字典合并与更新操作符 | 和 |=
• 二、字符串前缀 / 后缀移除方法
• 三、类型提示：泛型使用内置集合
• 3.10
• 一、结构化模式匹配 match-case 语句
• 二、括号上下文管理器支持
• 三、类型提示：联合类型运算符 |
• 3.11
• 一、异常组 (Exception Groups) 和 except* 语法
• 二、内置 TOML 解析
• 3.12
• 一、f-string 语法形式化与嵌套表达式支持
• 二、类型提示：新的类型参数语法
• 3.13
• 3.14
• 一、模板字符串 t-string
• 二、增强的 match-case 语句

前几天看到 Python 正式发布了 3.14 新版本，遥想当年我这个老登刚开始摸索的时候，使用的最新版本还是 3.6 版本，恍如隔世啊！这么多年过去了，随着版本的迭代，Python 也升级了很多新特性。今天我写下这篇文章，梳理了从 3.8 到 3.14 各版本中间重要新特性的优缺点、适用场景和使用方法。在日常工作当中，建议尽量使用最新发布的稳定版本，结合新特性来书写代码，这样会显著提升效率和代码可读性，毕竟人家 Anaconda 也是按照这个逻辑在进行版本更新的 ^_^

3.8

一、赋值表达式 :=（海象运算符）

形式为 variable := expression。它将表达式的结果赋值给变量，并返回该值，使赋值操作可以嵌入更大的表达式中。这种“在表达式中赋值”的能力此前只能通过语句实现，在表达式上下文（如列表推导式、if 条件判断等）中无法直接使用。海象运算符的引入填补了这一空白，使代码更加紧凑和高效。

# 示例1：简化 while 循环读取文件# 旧有实现defprocess_file_old(file_path):with open(file_path, 'r') as f:        line = f.readline()while line:            print(f"Processing line: {line.strip()}")            line = f.readline()# 使用海象运算符defprocess_file_new(file_path):with open(file_path, 'r') as f:while line := f.readline():            print(f"Processing line: {line.strip()}")# 假设我们有一个名为 'data.txt' 的文件with open('data.txt', 'w') as f:    f.write("First line\n")    f.write("Second line\n")print("--- Old Implementation ---")process_file_old('data.txt')print("\n--- New Implementation with Walrus Operator ---")process_file_new('data.txt')# 示例2：优化列表推导式import mathdefcomplex_computation(x):# 模拟一个耗时的计算return math.sin(x) * x**2data = [1, 2, 3, 4, 5, 6, 7, 8]# 旧有实现 (重复计算)result_old = [complex_computation(x) for x in data if complex_computation(x) > 10]# 或者使用生成器表达式 (稍显冗长)result_generator = [res for x in data if (res := complex_computation(x)) > 10] # 这种用法在3.8以前不合法# 使用海象运算符的正确方式result_new = [res for x in data if (res := complex_computation(x)) > 10]print(f"Old way (re-computation): {result_old}")print(f"New way (walrus operator): {result_new}")

1. 优缺点分析

海象运算符的优点主要体现在简洁性和性能上，缺点是可读性问题。如果滥用，代码可能变得难以理解，不利于调试和维护。官方文档和社区最佳实践都强调“谨慎使用”这一特性，仅在能显著简化逻辑、提高可读性的情况下才使用。

• 优势:
• 代码简化: 能够将“获取值”和“检查值”这两个步骤合二为一，从而减少代码行数，尤其在循环语句中效果显著。例如，可以避免在循环内外重复调用同一个函数 。
• 提升部分场景的可读性: 在某些模式下，如处理数据流或在列表推导中，使用海象运算符可以使意图更加直接和清晰。
• 性能微优化: 在某些情况下，可以避免重复计算或查找，带来轻微的性能提升。
• 局限性/缺点:
• 学习成本与滥用风险: 作为一个新语法，需要开发者适应。如果滥用，例如在复杂的表达式中嵌套多个海象运算符，会严重降低代码的可读性 。
• 兼容性: 仅在Python 3.8及以上版本可用，对于需要兼容旧版本Python的项目是个障碍。
• 社区争议: 该特性在提出时曾引起较大争议，部分开发者认为它违背了Python“代码应该清晰直白”的哲学 。

2. 适用场景

• 循环处理: 特别适合用在 while 循环中，用于读取数据块、消息队列或文件行，直到读取结束。
• 列表/字典/集合推导式: 当推导式中的过滤条件和元素构造都需要同一个计算结果时，海象运算符可以避免重复计算。
• 条件语句: 在 if 语句中，如果需要先计算一个值，然后判断这个值，并希望在条件块内部继续使用这个值，海象运算符非常方便。

二、仅位置参数语法 /

使用斜杠 / 作为函数参数列表中的分隔符，用于指定某些参数只能通过位置传递，而不能用作关键字参数。这一特性允许函数设计者明确区分参数的传递方式，从而避免用户在调用时产生歧义或误用。

# 定义一个同时包含仅限位置、普通和仅限关键字参数的函数defcomplex_func(pos_only1, pos_only2, /, standard_arg, *, kw_only1, kw_only2):"""    pos_only1, pos_only2: 必须按位置传递    standard_arg: 可以按位置或关键字传递    kw_only1, kw_only2: 必须按关键字传递    """    print(f"Positional-only: {pos_only1}, {pos_only2}")    print(f"Standard: {standard_arg}")    print(f"Keyword-only: {kw_only1}, {kw_only2}")# --- 合法调用 ---print("--- Valid Calls ---")# 1. 全部使用最直接的方式complex_func(1, 2, 3, kw_only1='a', kw_only2='b')# 2. standard_arg 也可以用关键字complex_func(1, 2, standard_arg=3, kw_only1='a', kw_only2='b')# --- 非法调用 ---print("\n--- Invalid Calls ---")try:# 错误：尝试用关键字传递仅限位置参数    complex_func(pos_only1=1, pos_only2=2, standard_arg=3, kw_only1='a', kw_only2='b')except TypeError as e:    print(f"Error caught: {e}")try:# 错误：尝试用位置传递仅限关键字参数    complex_func(1, 2, 3, 'a', 'b')except TypeError as e:    print(f"Error caught: {e}")

1. 优缺点分析

仅位置参数语法带来的主要优点是明确性和安全性。仅位置参数还有助于性能：对于接受任意关键字参数的函数，仅位置参数可以防止调用者意外地将本应作为关键字传递的值当作位置参数使用，从而减少运行时检查开销。缺点是这一特性在简单函数中可能显得冗余。如果函数的参数本身就很直观，使用仅位置参数语法反而增加了定义的复杂度。

• 优势:
• API健壮性: 库的作者可以更改仅限位置参数的名称，而不会破坏用户的代码，因为用户无法通过名称来传递这些参数 。
• 消除歧义: 避免了参数名与未来可能引入的关键字参数或 **kwargs 中的键发生冲突。
• 逻辑清晰: 明确地区分了哪些参数是函数签名的“稳定”部分（可通过关键字传递），哪些是“实现细节”（仅通过位置传递）。很多内置函数（如 pow）一直以来都有类似的行为，现在这个能力开放给了所有开发者。
• 性能: CPython解释器处理仅限位置参数的速度比关键字参数稍快。
• 局限性/缺点:
• 降低灵活性（对调用者而言）*: 调用者失去了使用关键字参数来提高代码可读性的能力（例如 my_func(value=10)）。
• 学习成本: 需要开发者理解 / 和 * 在函数签名中的新含义。

2. 适用场景

• 库和框架开发: 当设计公共API时，如果某些参数的名称在未来可能会改变，或者只是内部实现的占位符，应将其设为仅限位置参数。
• 模拟内置函数行为: 当你编写的函数行为类似于 len() 或 pow() 这类接受固定位置输入的函数时。
• 防止关键字参数冲突: 当函数接受 **kwargs 时，使用仅限位置参数可以确保核心参数不会与 kwargs 中的任意键名冲突。

三、f-string 自文档化调试支持

f-string 现在允许在表达式后面加上等号 =，用于打印表达式的原文和结果。这意味着开发者可以在调试时方便地输出某个变量或表达式的值及其来源，而无需额外编写 print(f"x={x}") 这样的代码。通过 f"{expr=}" 形式，Python 会自动在输出中包含表达式本身和其求值结果，格式为 expr=value，极大地方便了调试工作。

x = 42print(f"{x=}")          # 输出: x=42print(f"{3+5=}")        # 输出: 3+5=8

1. 优缺点分析

优点主要体现在调试便利上。开发者经常需要在运行时查看某个变量的值或某段表达式的结果，以往需要手动编写包含变量名和值的打印语句。而有了 f"{expr=}"，一行代码即可完成这一任务，大大简化了调试过程。此外，这种语法还能帮助减少拼写错误或遗漏：传统方式下，开发者可能在变量名和值之间忘记空格或写错变量名，而自文档化语法由Python自动处理，格式统一且不易出错。

主要局限在调试场景。在正式代码中直接使用 f"{expr=}" 输出可能并不合适，因为最终用户并不关心表达式本身的文本，只关心结果。因此，这一特性主要用于开发和调试阶段。另外，一些开发者可能认为在代码中大量出现 f"{...=}" 会影响代码美观，显得不专业。

2. 适用场景

• 调试变量值：在调试过程中，需要输出某个变量的当前值时，可以使用 f"{var=}" 快速打印变量名和值。这在快速检查程序状态时非常方便。
• 调试表达式结果：如果需要检查某个表达式的计算结果，也可以使用自文档化语法。例如，f"{func(args)=}" 可以输出函数调用及其返回值，帮助定位问题。
• 日志记录：在开发阶段的日志中，有时需要记录某些计算过程或中间结果。自文档化 f-string 可以在日志中同时保留表达式和值，方便后续分析。但需注意，在生产环境的日志中，应考虑仅输出需要的值，而不包含表达式文本，以免日志冗长。

3.9

一、字典合并与更新操作符 | 和 |=

Python 3.9 为内置的 dict 类型新增了合并（|）和更新（|=）两个操作符，用于字典之间的合并操作。这些操作符提供了与集合类似的语法：使用 | 可以得到两个字典合并后的新字典，而使用 |= 可以将一个字典的键值对就地更新到另一个字典中。这一特性填补了Python在字典操作上的一个语法空白，使代码更加简洁，同时保持了与其它可变容器操作符（如列表的 + 和 +=）的一致性。

# 基础配置base_config = {'user': 'default', 'theme': 'light', 'timeout': 30}# 用户A的配置user_a_config = {'user': 'Alice', 'theme': 'dark'}# 用户B的配置user_b_config = {'timeout': 60, 'notifications': True}# --- 1. 使用 | 合并字典 (返回新字典) ---# 合并基础配置和用户A的配置，用户A的配置会覆盖同名键final_config_a = base_config | user_a_configprint(f"Base config: {base_config}")print(f"User A config: {user_a_config}")print(f"Final config for Alice: {final_config_a}")# 注意：base_config 没有被修改print(f"Base config after merge: {base_config}")# 对比旧有实现# 方法一: update (会修改原字典，需要先复制)final_config_a_old1 = base_config.copy()final_config_a_old1.update(user_a_config)# 方法二: 字典解包 (Python 3.5+)final_config_a_old2 = {**base_config, **user_a_config}print(f"Old way (update): {final_config_a_old1}")print(f"Old way (unpacking): {final_config_a_old2}")print("\n" + "-"*20 + "\n")# --- 2. 使用 |= 原地更新字典 ---# 假设我们有一个动态的会话状态session_state = {'user_id': 123, 'is_logged_in': True}# 现在有一个新的事件数据需要更新到会话中event_data = {'last_action': 'view_product', 'is_logged_in': True} # is_logged_in 值相同session_state |= event_dataprint(f"Initial session state: {{'user_id': 123, 'is_logged_in': True}}")print(f"Event data: {event_data}")print(f"Updated session state: {session_state}")# 对比旧有实现 (dict.update)# session_state.update(event_data) 的效果与 |= 完全相同

1. 优缺点分析

优点是简洁与直观，引入字典操作符还保持了一致性。Python中，可变序列类型（如列表）有 + 和 += 用于拼接，而集合有 | 和 |= 用于合并。字典作为另一种常用的可变容器，一直缺乏类似的语法，Python 3.9 终于补齐了这一短板。这使得Python的API设计更加统一，开发者可以凭直觉在不同容器类型上使用相似的操作符。官方文档也指出，| 操作符设计上不支持链式合并超过两个字典，因为那样做会创建不必要的临时对象，降低效率。因此，开发者应避免在一个表达式中合并过多字典，而应拆分成多步或使用循环。需要注意的是，在性能敏感的场景下，应谨慎使用 | 合并过多字典。在这种情况下，应考虑使用循环逐步合并，或者使用 update() 方法直接累积结果，以减少中间对象的创建。此外，对于需要保留原字典不变的场景，务必使用 | 而不是 |=，因为后者会修改原字典。

• 优势:
• 语法简洁: 相较于 dict.update() 方法或 {**d1, **d2} 的解包语法，| 和 |= 更加直观和简洁 。
• 语义清晰: | 运算符返回一个新对象，符合函数式编程的习惯，不产生副作用。|= 则明确表示这是一个原地修改操作。
• 行为一致性: 使字典的操作行为与其他支持 | 和 |= 的数据类型（如 set）更加一致。
• 局限性/缺点:
• 兼容性: 仅在Python 3.9及以上版本可用。
• 潜在混淆: 对于不熟悉新语法的开发者，可能会与集合的并集操作或位运算的“或”操作混淆。

2. 适用场景

• 配置管理: 合并默认配置和用户自定义配置是常见场景。
• 数据聚合: 在数据处理流程中，将来自不同来源的数据片段合并成一个完整的记录。
• 状态更新: 在应用程序中，使用 |= 来更新状态字典，例如更新一个用户的会话信息。

二、字符串前缀 / 后缀移除方法

Python 3.9 为字符串对象新增了两个方法：str.removeprefix(prefix) 和 str.removesuffix(suffix)，用于方便地移除字符串开头或结尾的指定子串，使字符串操作更加安全和简便。

s = "Hello, world!"# 移除前缀 "Hello, "new_s = s.removeprefix("Hello, ")print(new_s)  # 输出: "world!"# 移除后缀 "!"new_s2 = new_s.removesuffix("!")print(new_s2)  # 输出: "world"s2 = "Hello, world!"result = s2.removeprefix("Hi")  # s2 不以 "Hi" 开头print(result)  # 输出: "Hello, world!"（与原字符串相同）

1. 优缺点分析

优点主要体现在安全和简洁上。以前要移除前缀，可能需要写类似 s[len(prefix):] if s.startswith(prefix) else s 的逻辑，而现在一句 s.removeprefix(prefix) 就可以完成，而且不会因为长度不匹配而报错。缺点是这两个方法的功能相对窄，只能移除开头或结尾的一个子串。如果需要移除中间的某部分子串，或者需要移除多个可能的前缀/后缀，这些方法无法直接满足需求。需要注意的是，removeprefix 和 removesuffix 只能移除一次指定的前缀或后缀。如果需要移除所有出现的前缀（例如字符串开头多次出现某子串），则需要循环调用或在调用前先处理。

2. 适用场景

• 移除固定前缀/后缀：当字符串的格式已知，需要去除开头或结尾的固定部分时，可以使用这些方法。例如，解析日志行，每行可能以时间戳开头，可以用 line.removeprefix(timestamp) 去除时间戳得到内容部分。
• 用户输入清理：在处理用户输入时，可能需要去除开头或结尾的多余字符。例如，用户输入的文件名可能带有路径前缀或扩展名后缀，可以用这两个方法清理，再进行后续处理。
• 代码重构与字符串规范化：在重构代码或统一字符串格式时，removeprefix/removesuffix 可以帮助快速调整字符串。例如，将所有模块导入语句中的 "__main__" 前缀移除，或统一在字符串末尾添加/移除标点符号等。
• 避免索引计算错误：在需要根据动态计算的前缀/后缀长度来切片字符串时，使用这些方法可以避免复杂的索引计算。例如，移除一个可能为空的字符串前缀时，如果用切片需要判断长度，而 removeprefix 内部已经处理了空字符串的情况，更安全。

三、类型提示：泛型使用内置集合

泛型（Generics）现在可以使用内置集合类型直接表示。在此之前，如果要在类型提示中使用泛型集合（例如“一个元素为整数的列表”），必须从 typing 模块导入专门的泛型类型，如 List[int]、Dict[str, int] 等。Python 3.9 放宽了这一限制，允许直接使用内置的 list、dict、set、frozenset 等作为泛型来标注类型。这一变化使类型提示更加简洁，也使Python的类型系统更加统一和直观。

# 在 Python 3.7, 3.8 中需要这样做:from typing import List, Dict, Setdefprocess_data_old(users: List[Dict[str, str]], active_ids: Set[int]) -> None:for user in users:if int(user.get('id', 0)) in active_ids:            print(f"Processing active user: {user['name']}")# 在 Python 3.9+ 中，可以这样做:defprocess_data_new(users: list[dict[str, str]], active_ids: set[int]) -> None:for user in users:if int(user.get('id', 0)) in active_ids:            print(f"Processing active user: {user['name']}")# 示例数据sample_users = [    {'id': '101', 'name': 'Alice'},    {'id': '102', 'name': 'Bob'},    {'id': '103', 'name': 'Charlie'}]sample_active_ids = {101, 103}print("--- Calling new style function ---")process_data_new(sample_users, sample_active_ids)

1. 优缺点分析

• 优势:
• 代码整洁: 无需从 typing 模块导入 List, Dict, Tuple, Set 等，减少了冗余的 import 语句。
• 更符合直觉: list[int] 的写法比 List[int] 更自然，因为它直接使用了日常创建列表时用的类型名称。
• 降低学习门槛: 新手学习类型提示时，不必再去区分 list 和 List 这两个概念。
• 局限性/缺点:
• 兼容性: 仅在Python 3.9及以上版本可用。在旧版本中，仍需使用 from typing import ...。对于需要支持旧版本的库，通常会使用 from __future__ import annotations 来延迟注解求值，但这并不能完全解决运行时的问题。

2. 适用场景

• 函数/方法参数和返回值标注：当需要标注参数或返回值为泛型集合时，可以使用小写形式。例如，def process(items: list[int]) -> list[str]: 表示接收一个整数列表，返回一个字符串列表。
• 类属性和全局变量标注：在类定义中，如果某个属性是泛型集合，也可以用小写形式标注。例如，class Counter:counts: dict[str, int] = {}。
• 类型别名定义：在定义类型别名时，也可以使用小写形式。例如，from typing import TypeAliasIdList: TypeAlias = list[int]。

需要注意的是，特殊泛型（如 Tuple、Union、Optional 等）目前仍然需要从 typing 导入。

3.10

一、结构化模式匹配 match-case 语句

模式匹配的核心思想是“匹配数据结构”。开发者可以编写一个 match 语句，其中包含多个 case 分支，每个分支定义一个模式。Python会将被匹配对象与这些模式依次尝试匹配，一旦找到匹配的模式，就执行对应的代码块，然后退出整个 match 语句（类似于 switch 语句的语义）。如果没有任何模式匹配，则执行可选的 case _ 分支（类似于 default:）或直接不执行任何分支。

#  示例：处理一个API返回的用户操作事件defhandle_event(event: dict):"""    使用 match-case 处理不同类型的用户事件    """    match event:# 1. 匹配一个简单的 'login' 事件        case {'type': 'login', 'username': str(username)}:            print(f"User '{username}' logged in.")# 2. 匹配 'post_comment' 事件，并使用 'if' 守卫检查评论长度        case {'type': 'post_comment', 'user_id': uid, 'comment': str(comment)} if len(comment) > 100:            print(f"User {uid} posted a long comment (length {len(comment)}).")# 3. 匹配普通的 'post_comment' 事件        case {'type': 'post_comment', 'user_id': uid, 'comment': _}:            print(f"User {uid} posted a comment.")# 4. 匹配 'update_profile' 事件，并捕获所有额外的数据        case {'type': 'update_profile', 'user_id': uid, **rest}:            print(f"User {uid} updated their profile with data: {rest}")# 5. 使用 | 组合匹配多种 'logout' 或 'disconnect' 事件        case {'type': 'logout' | 'disconnect', 'username': str(username)}:             print(f"User '{username}' left.")# 6. 通配符 case，处理所有其他未匹配的事件        case _:            print(f"Received an unknown event: {event}")# --- 测试不同的事件 ---events = [    {'type': 'login', 'username': 'Alice'},    {'type': 'post_comment', 'user_id': 101, 'comment': 'This is a great post!'},    {'type': 'post_comment', 'user_id': 102, 'comment': 'a' * 120}, # 长评论    {'type': 'update_profile', 'user_id': 101, 'email': 'alice@example.com', 'city': 'Wonderland'},    {'type': 'logout', 'username': 'Alice'},    {'type': 'unknown_action'}]for e in events:    handle_event(e)

1. 优缺点分析

• 优势:
• 极大地提升了可读性: 对于处理复杂、多分支的 if-elif-else 逻辑，match-case 可以使代码结构更清晰、意图更明确 。
• 强大的解包能力: 可以在匹配的同时，从列表、元组、字典和对象中提取数据并绑定到变量，将条件判断和数据提取合二为一。
• 表达力强: 支持字面量模式、捕获模式、通配符模式、序列模式、映射模式、类模式，以及通过 | 组合模式和 if 守卫 (guards) 进行条件匹配 。
• 局限性/缺点:
• 性能考量: 模式匹配在性能上与 if-elif-else 相当，不会带来额外的性能开销，因此无需从性能角度避免使用。
• 学习曲线: 语法和概念比 if-elif 复杂，需要时间来掌握其全部功能，如各种模式和守卫的用法。
• 兼容性: Python 3.10+ 的专属特性，无法在旧版本中使用。

2. 适用场景

• 解析结构化数据: 处理来自API的JSON响应、解析自定义数据格式、处理AST（抽象语法树）等。
• 实现状态机: 根据当前状态和输入的事件来决定下一个状态和要执行的动作。
• 命令分发器: 在命令行工具或机器人中，根据用户输入的命令及其参数来调用不同的处理函数。
• 数据清洗与转换: 根据数据的不同形态（如dict, list, None）执行不同的清洗或转换逻辑。

模式匹配并非万能灵药。对于简单的条件判断（如单条件或少量条件），传统的 if 语句可能更简洁。在决定是否使用 match 时，应考虑其可读性和必要性。如果引入模式匹配后代码反而变得更复杂或不如 if 清晰，那可能不是合适的使用场景。官方文档建议，仅在能显著简化代码、提高可读性的情况下才使用模式匹配。

二、括号上下文管理器支持

Python 3.10 允许在上下文管理器（with 语句）中使用括号将多个上下文管理器组合在一行。在此之前，with 语句只能在一个子句中指定一个上下文管理器，或者使用多个 with 嵌套来同时打开多个资源。Python 3.10 引入的新语法允许使用逗号分隔的上下文管理器列表，并将其用括号括起来，从而在一行中管理多个上下文。这一改进使得代码更加紧凑，特别是当需要同时打开多个资源（如文件、锁、数据库连接等）时，不再需要多行嵌套的 with。

# 示例：同时打开两个文件进行处理with (open('file1.txt') as f1, open('file2.txt') as f2):    data1 = f1.read()    data2 = f2.read()# 在这里对data1和data2进行操作

1. 适用场景

• 同时打开多个文件：如上面的示例，需要同时读取或写入多个文件时，可以用一行 with (...) 同时管理它们。
• 同时使用多个锁或资源：在并发编程中，有时需要同时获取多个锁或进入多个上下文（例如事务、网络连接等）。使用括号语法可以简化代码。
• 临时资源管理：在函数内部，可能需要临时创建和清理多个资源。使用一行 with (...) 可以使这些资源的生命周期与代码块绑定，避免忘记关闭。

如果上下文管理器之间有依赖关系（例如第二个上下文需要第一个上下文的对象），则应分别使用嵌套的 with，而不是括号语法。括号语法适用于并列的上下文管理，彼此之间没有先后依赖。此外，对于非常多的上下文管理器，一行括号可能过长，此时依然可以考虑多行嵌套的 with 以提高可读性。

三、类型提示：联合类型运算符 |

使用竖线 | 来表示联合类型（Union Types）。联合类型表示一个值可以是几种类型之一。在此之前，联合类型需要从 typing 模块导入 Union 来表示，例如 Union[int, str] 表示一个可以是整数或字符串的类型。Python 3.10 允许直接使用 int | str 的语法来表示相同的联合类型，使类型提示更加简洁。这一变化旨在简化类型提示的书写，并让类型系统更接近直观的表达。

from typing import Union# 旧有实现 (Python 3.6+)defget_item_old(item_id: Union[int, str]) -> Union[dict, None]:if isinstance(item_id, int) and item_id == 1:return {'name': 'Apple', 'id': 1}if isinstance(item_id, str) and item_id == 'item-2':return {'name': 'Banana', 'id': 2}returnNone# 新的 | 语法 (Python 3.10+)defget_item_new(item_id: int | str) -> dict | None:if isinstance(item_id, int) and item_id == 1:return {'name': 'Apple', 'id': 1}if isinstance(item_id, str) and item_id == 'item-2':return {'name': 'Banana', 'id': 2}returnNone# 调用示例print(f"New style call with int: {get_item_new(1)}")print(f"New style call with str: {get_item_new('item-2')}")print(f"New style call with invalid id: {get_item_new(999)}")

1. 优缺点分析

• 优势:
• 极度简洁: int | str | None 比 Union[int, str, None] 写起来更快，读起来也更流畅。
• 可读性高: | 符号在视觉上比 Union[...] 更轻量，使得复杂的类型注解不那么拥挤。
• 减少导入: 不再需要从 typing 模块导入 Union。
• 局限性/缺点:
• 兼容性: 仅在Python 3.10 及以上版本可用。对于需要兼容老版本的代码库，仍然需要使用 typing.Union。

2. 适用场景

• 函数参数类型标注：当函数可以接受多种类型的参数时，可以使用 | 标注。例如，def display(value: int | str): 表示 value 可以是整数或字符串。
• 变量和属性类型标注：在标注变量或类的属性时，也可以使用 |。例如，result: int | None = None 表示 result 可以是整数或空值。
• 类型别名：在定义类型别名时，也可以使用 |。例如，from typing import TypeAliasNumber: TypeAlias = int | float。

特殊类型（如 Tuple、Callable、TypeVar 等）目前仍然需要从 typing 导入。

3.11

一、异常组 (Exception Groups) 和 except* 语法

在Python 3.11之前，当多个异常同时发生时（例如在并发代码中多个任务都抛出异常），解释器只能报告其中一个异常，其余异常会被丢弃或以不太优雅的方式处理（如通过异常链）。Python 3.11 通过引入 ExceptionGroup 类和 BaseExceptionGroup 类，允许将多个异常打包成一个异常对象进行传播。同时，新的 except* 语法用于捕获异常组中的部分异常，而将未捕获的异常继续传播，从而实现对异常组的精细控制。

# 实例：使用 asyncio.TaskGroup 并发下载多个URLimport asyncioimport httpx # 需要安装 httpx: pip install httpxasyncdefdownload(url: str):"""模拟一个可能失败的下载任务"""    print(f"Starting download from {url}")if"fail"in url:raise ConnectionError(f"Failed to connect to {url}")if"timeout"in url:await asyncio.sleep(0.1) # 模拟网络延迟raise TimeoutError(f"Request to {url} timed out")# 模拟成功下载await asyncio.sleep(0.05)    print(f"Successfully downloaded from {url}")returnf"Content of {url}"asyncdefmain():    urls = ["http://example.com/success","http://example.com/fail","http://example.com/timeout","http://example.com/another-fail"    ]try:asyncwith asyncio.TaskGroup() as tg:            tasks = [tg.create_task(download(url)) for url in urls]        results = [t.result() for t in tasks]        print(f"\nAll downloads successful: {results}")except* ConnectionError as eg_conn:        print("\n--- Caught Connection Errors ---")for err in eg_conn.exceptions:            print(f"  - {err}")except* TimeoutError as eg_timeout:        print("\n--- Caught Timeout Errors ---")for err in eg_timeout.exceptions:            print(f"  - {err}")# 在 Python 3.11+ 中，asyncio.run() 会自动处理顶层异常组# 但为了清晰展示，我们使用 try-except*asyncio.run(main())# 输出示例Starting download from http://example.com/successStarting download from http://example.com/failStarting download from http://example.com/timeoutStarting download from http://example.com/another-failSuccessfully downloaded from http://example.com/success--- Caught Connection Errors ---  - Failed to connect to http://example.com/fail  - Failed to connect to http://example.com/another-fail--- Caught Timeout Errors ---  - Request to http://example.com/timeout timed out

1. 优缺点分析

• 优势:
• 解决了并发编程的痛点: 在异步编程或多线程任务中，多个任务可能同时失败。传统异常模型只能报告第一个发生的异常，而异常组可以收集所有异常，让调用者全面了解失败情况 。
• 精细的错误处理: except* 语法允许开发者像处理单个异常一样，根据类型分别处理组内的不同异常，提供了前所未有的灵活性。
• 与asyncio.TaskGroup完美集成: TaskGroup 是3.11中新的异步任务管理工具，它会自动将并发任务中的所有异常收集到一个 ExceptionGroup 中，使得并发错误处理变得结构化和简单。
• 局限性/缺点:
• 增加了复杂性: 新的异常类型和新的 except* 语法需要学习。错误处理逻辑可能会比传统的 try...except 更复杂。
• 主要适用于特定场景: 对于单线程的顺序执行代码，异常组的用处不大。它的威力主要体现在并发和并行编程中。

2. 适用场景

• 异步I/O操作： 使用 asyncio.TaskGroup 同时发起多个网络请求或数据库查询，并统一处理所有可能发生的连接错误、超时错误等。
• 并行数据处理： 使用线程池或进程池处理数据批次，当多个数据项处理失败时，收集所有处理错误。
• 重试逻辑： 在实现复杂的重试机制时，可以收集多次尝试失败的所有不同原因。
• 资源管理： 同时初始化或关闭多个资源（如文件、网络连接），并处理所有可能发生的关闭失败。
• 附加信息和调试：利用 add_note()，可以在异常上附加调试信息或上下文，在异常被打印时显示。这有助于在不修改异常消息本身的情况下提供额外信息。

异常组机制主要用于异常恢复和报告。在只需要捕获单个异常并处理的场景，传统的 try-except 已经足够，不需要引入异常组。此外，except* 语法仅用于异常组，对普通异常无效。因此，如果不确定是否会有多个异常，可以先使用普通 try-except，只有在确认可能有多个异常时，再考虑使用异常组。

二、内置 TOML 解析

在标准库中增加了一个新的 tomllib 模块，用于解析 TOML (Tom's Obvious, Minimal Language) 格式的文件。TOML 是 pyproject.toml 文件使用的配置格式。

tomllib 的使用非常简单，其API与 json 模块类似。关键点是 tomllib.load() 需要一个以二进制模式 ('rb') 打开的文件对象。

import tomllibimport os# 1. 创建一个示例 pyproject.toml 文件toml_content = """[project]name = "my-awesome-app"version = "1.2.3"description = "A demonstration of tomllib."dependencies = [    "requests>=2.20",    "numpy",][tool.pytest.ini_options]minversion = "6.0"addopts = "-ra -q"testpaths = [    "tests",]"""file_path = "pyproject.toml"with open(file_path, "w") as f:    f.write(toml_content)# 2. 使用 tomllib 解析文件try:with open(file_path, "rb") as f:  # tomllib.load 需要二进制模式打开文件        config_data = tomllib.load(f)# 3. 访问解析后的数据    project_name = config_data.get('project', {}).get('name')    dependencies = config_data.get('project', {}).get('dependencies')    pytest_opts = config_data.get('tool', {}).get('pytest', {}).get('ini_options', {})    print(f"Project Name: {project_name}")    print(f"Dependencies: {dependencies}")    print(f"Pytest Options: {pytest_opts}")finally:# 清理文件if os.path.exists(file_path):        os.remove(file_path)# 也可以直接解析字符串config_from_string = tomllib.loads("[server]\nip = '127.0.0.1'")print(f"\nConfig from string: {config_from_string}")

1. 优缺点分析

• 优势:
• 标准化: 提供了一个官方、统一的TOML解析方式，无需依赖第三方库（如 toml 或 tomli）。
• 可靠性: 作为标准库的一部分，其维护性和稳定性有保障。
• 便捷性: 对于需要读取 pyproject.toml 或其他TOML配置的工具和脚本来说，现在可以直接 import tomllib。
• 局限性/缺点:
• 只读: tomllib 只提供了加载（解析）TOML的功能 (load, loads)，但没有提供写入（序列化）的功能。如果需要生成TOML文件，仍然需要使用第三方库，如 tomli-w。

2. 适用场景

• 构建工具和脚本: 读取 pyproject.toml 文件以获取项目元数据、依赖项或其他配置。
• 应用程序配置: 使用TOML作为应用程序的配置文件格式，因为它比JSON更易于人类阅读和编辑。
• 任何需要解析TOML数据的场景。

3.12

一、f-string 语法形式化与嵌套表达式支持

• 支持更复杂的表达式：由于f-string表达式现在是任意的Python表达式，因此可以在其中使用列表推导式、条件表达式、函数调用等复杂逻辑。只要表达式最终能够求值为字符串，就可以嵌入f-string中。
• 语法形式化：Python 3.12将f-string的语法正式纳入了解析器语法中，使其不再是一种特殊语法hack。这意味着未来的Python版本可以更方便地扩展f-string的功能，也使得其他Python实现能够正确解析f-string。

# 示例数据users = [    {'name': 'Alice', 'age': 30, 'roles': ['admin', 'editor']},    {'name': 'Bob', 'age': 25, 'roles': ['viewer']},]# --- 1. 引号重用 ---# 在 3.12 之前，这会是语法错误query = f"SELECT * FROM users WHERE name = 'Alice'"print(f"1. Quote reuse:\n{query}\n")# --- 2. 多行表达式和注释 ---admin_users = [user['name'] for user in users if'admin'in user['roles']]report = f"""User Report:-------------Admin Users: {", ".join(admin_users) # 这是一个注释if admin_users else"No admins found"}Total Users: {len(users)}"""print(f"2. Multiline expression and comment:\n{report}")# --- 3. 任意嵌套 F-strings ---for i, user in enumerate(users):    user_info = f"  - User {i+1}: {f"Name: {user['name'].upper()}"}, {f"Age: {user['age']}"}"    print(f"3. Nested f-string:\n{user_info}")# --- 4. 在 F-strings 中使用反斜杠换行 ---   lines = ["Line1", "Line2", "Line3"]print(f"{chr(10).join(lines)}")  # 输出: Line1\nLine2\nLine3（实际打印三行）# --- 综合示例：生成调试信息 ---defcomplex_function(data):# ... 一些复杂操作 ...    intermediate_result = sum(d['age'] for d in data)    debug_message = f"""    [DEBUG] complex_function called:    - Input data length: {len(data)}    - Intermediate result: {        # 计算平均年龄        intermediate_result / len(data) if data else0    }    - First user name: {f"'{data[[60]]['name']}'"if data else"'N/A'"}    """return debug_messageprint(f"\n4. Complex debug message:\n{complex_function(users)}")

1. 优缺点分析

• 优势:
• 表达力极大提升: 移除了许多令人困惑和不便的限制，使得在 f-string 中编写复杂表达式成为可能。
• 语法一致性: 使 f-string 的行为更符合 Python 语言的整体直觉，减少了特殊规则的记忆负担。
• 代码更整洁: 对于需要格式化的复杂表达式，不再需要预先计算并存储在临时变量中，可以直接在 f-string 内部完成。
• 局限性/缺点:
• 滥用风险: 过于强大的能力可能诱使开发者在 f-string 中编写过于复杂的逻辑，从而损害代码的可读性。代码风格检查工具（linter）可能需要更新规则来引导健康的实践。
• 性能考虑。嵌套f-string和多行f-string本质上是将多个表达式拼接在一起，如果表达式中包含耗时的计算，可能影响性能。

2. 适用场景

• 复杂格式化需求：当需要在字符串中嵌入复杂计算或多次格式化时，可以使用嵌套f-string。例如，根据条件选择不同的子字符串，再进一步格式化。
• 多行字符串构建：当需要构建包含多行文本、嵌入变量或表达式的长字符串时，可以使用多行f-string。这比用 + 拼接多个字符串更直观，也避免了忘记加空格或引号的问题。
• 字符串模板和调试：在开发阶段，如果需要打印复杂的数据结构或调试信息，可以利用f-string的强大表达式嵌入能力，在一行中输出大量信息。这在调试时非常方便。
• 代码重构和简化：在重构代码时，如果发现某个地方使用了复杂的字符串拼接，可以考虑用f-string重写，以利用其简洁性和灵活性。

二、类型提示：新的类型参数语法

• 类型别名：使用新的 type 语句定义类型别名，并在其中使用类型参数语法。例如，type Point[T] = tuple[T, T] 定义了一个泛型类型别名 Point，表示一个包含两个相同类型元素的元组。
• 类型参数默认值：Python 3.12 允许为类型参数指定默认类型。例如，def func[T: int = int](arg: T) -> T: 表示如果调用 func 时不指定类型参数，T 默认为 int。

# 示例1：泛型类定义classBox[T]:def__init__(self, content: T):        self.content = contentdefget(self) -> T:return self.content# 示例2：泛型函数定义deffirst[T](items: list[T]) -> T:return items[0]# 示例3：类型别名type Point[T] = tuple[T, T]

1. 适用场景

• 泛型类定义：当编写一个需要支持多种类型的容器或类时，可以使用新语法定义泛型类。例如，实现一个泛型栈、队列等。
• 泛型函数定义：当函数的逻辑适用于多种类型，且参数或返回类型依赖于输入类型时，可以使用新语法定义泛型函数。例如，一个返回列表第一个元素的函数，如 first[T](items)。
• 类型别名定义：当需要为一个复杂类型或泛型类型起一个易读的别名时，可以使用 type 语句定义。例如，定义 UserId = int 或 Matrix[T] = list[list[T]]。
• 类型参数默认值：当泛型有一个常用类型时，可以指定默认值。例如，一个泛型函数通常处理整数，可以写成 def func[T: int = int](arg: T)，这样在大多数调用时无需指定类型参数。

3.13

Python 3.13 是一个交互式体验和性能全面提升的版本。它引入了一个全新的、功能丰富的交互式解释器（REPL），并开始探索自由线程（Free-Threading）和即时编译（JIT）等前沿特性。同时，Python 3.13 改进了类型提示（支持类型参数默认值）、错误信息（彩色回溯）以及标准库（移除过时的模块）。

3.14

一、模板字符串 t-string

t-string的核心价值在于将‍“模板定义”‍与‍“模板渲染”两个阶段分离。它提供了一种安全、灵活且可重用的机制，用于在运行时以结构化的方式处理字符串模板，特别是在需要上下文感知处理（如安全转义、格式转换）的场景中，其优势尤为突出 。

# 基础渲染（占位符${}）name = "Alice"age = 25basic_tpl = t"姓名：${name}，明年年龄：${age + 1}"print(basic_tpl)  # 输出：姓名：Alice，明年年龄：26# 多行模板（保留格式，支持字典/列表表达式）user = {"name": "Bob", "hobbies": ["coding", "reading"]}multi_tpl = t"""用户档案：  姓名：${user["name"]}  爱好：${", ".join(user["hobbies"])}  爱好数量：${len(user["hobbies"])}"""print(multi_tpl.strip())  # 输出：# 用户档案：#   姓名：Bob#   爱好：coding, reading#   爱好数量：2# 进阶技巧 1：预编译模板（提升多次渲染性能）# 假设 compile_t 为 Python 3.14 内置预编译函数（基于设计逻辑推断）from string import compile_t# 预编译模板（仅解析一次）user_tpl = compile_t(t"用户${id}：${name}（等级：${level}）")# 多次渲染（仅求值表达式，性能更优）users = [    {"id": 1, "name": "Charlie", "level": "VIP"},    {"id": 2, "name": "David", "level": "普通"}]for u in users:    print(user_tpl.render(**u))  # 输出：# 用户1：Charlie（等级：VIP）# 用户2：David（等级：普通）# 进阶技巧 2：模板内轻量控制流products = [    {"name": "手机", "price": 2999, "stock": 8},    {"name": "耳机", "price": 199, "stock": 0}]# 内置%for%/%if%控制流（假设语法，基于设计逻辑推断）product_tpl = t"""商品列表：%for% p in products %:%  - ${p["name"]}：¥${p["price"]}  %if% p["stock"] == 0 %:%    （缺货）  %elif% p["stock"] < 10 %:%    （库存紧张：${p["stock"]}件）  %else%:    （库存充足）  %endif%%endfor%"""print(product_tpl.strip())  # 输出：# 商品列表：#   - 手机：¥2999#     （库存紧张：8件）#   - 耳机：¥199#     （缺货）

1. 优缺点分析

优势：

• 安全可控： t-string 提供了对插值的完全访问，开发者可以在插值合并为字符串前对内容进行转义、验证或过滤，有效避免 SQL 注入、XSS 等安全漏洞。例如，在渲染 HTML 时，可以使用 t-string 获取插值并对其执行 HTML 转义，再输出结果字符串，从而防止恶意脚本注入。
• 灵活性高： 模板字符串可以被任意代码处理，而不仅限于字符串连接。开发者可以选择生成结构化日志、构造 DSL、实现复杂的国际化和本地化逻辑，甚至将模板用作数据校验的中间表示等。这种灵活性远超出了 f-string 或传统 str.format() 的能力范围。
• 可复用与组合： t-string 对象可以像普通对象一样传递和组合。多个 Template 对象可以通过 + 运算符拼接，实现模板的复用和模块化。例如，可以将页眉、页脚等公共部分定义为 t-string，然后在不同页面模板中组合使用。
• 语法兼容 f-string： t-string 借鉴了 f-string 的语法设计，支持几乎全部 f-string 特性。这意味着开发者无需学习全新语法，可以无缝迁移现有 f-string 代码到 t-string，同时获得对插值的控制能力。

局限性/缺点：

• 代码复杂度增加： 在许多简单场景下，使用 f-string 或 str.format() 一行代码即可完成字符串格式化，而使用 t-string 需要额外编写处理逻辑。这意味着对于不需要特殊处理的用例，t-string 可能显得有些大材小用，增加不必要的代码量。
• 性能开销： t-string 在创建 Template 对象时需要解析模板并存储多个部分，这比直接生成字符串要消耗更多内存和计算资源。此外，开发者需要自行实现将各部分合并的逻辑，这也可能引入额外的循环或条件判断。因此，在性能敏感且无需特殊处理的场景下，f-string 可能是更高效的选择。
• 生态与支持： 作为新特性，t-string 需要开发者主动编写处理代码，才能发挥作用。目前标准库并未提供“一键转义”或“一键格式化”的内置函数，开发者需要自行实现或依赖第三方库。这意味着短期内，t-string 的生态和最佳实践仍在发展中，开发者需要一定的学习曲线和探索成本。

2. 适用场景

模板字符串适用于需要对插值内容进行精细控制或安全处理的场景。

• Web 模板与安全输出： 在生成 HTML、SQL、JSON 等内容时，使用 t-string 可以在插值前对数据进行转义或校验，防止注入攻击。例如，渲染 HTML 页面时，自动对用户输入进行 HTML 实体转义，避免 XSS；拼接 SQL 查询时，对参数进行 SQL 转义或使用参数化查询，防止 SQL 注入。
• 结构化日志与调试： t-string 可以方便地实现结构化日志，即将日志消息与变量值分开处理。开发者可以编写一个日志处理函数，将模板中的插值提取出来作为结构化数据输出（例如 JSON 格式），同时保留人类可读的日志消息。这种方式便于后续的日志聚合和分析。
• 国际化与本地化： 对于多语言支持，t-string 提供了在翻译过程中处理插值的机会。开发者可以在翻译函数中获取原始插值，并根据语言环境调整格式或顺序，再输出最终字符串。相比硬编码 f-string，这种方式更灵活且易于维护。
• 领域特定语言（DSL）： t-string 可用作构建自定义模板引擎的基础。例如，开发者可以基于 t-string 实现一个简单的模板语言，支持条件、循环等高级语法，而无需引入第三方模板库。这在需要高度定制或性能优化的场景下非常有用。
• 代码生成与动态表达式： t-string 可以用于生成代码片段、配置文件等需要插入动态内容的场景。开发者可以在插值前对表达式进行静态分析或转换，确保生成的代码符合语法或规范。例如，根据环境变量生成不同的配置文件内容。

二、增强的 match-case 语句

增强逻辑：

1. 新增模式语法解析规则（如 [*head, x, *tail] 切片模式、int(x) 类型模式）；
2. 复杂模式会被预编译为优化的匹配逻辑，提升多次执行性能；
3. case int(x) 原生解析为 isinstance(目标, int)，无需手动判断；
4. 别名模式（as）会先匹配子模式，再赋值给别名供后续使用。

# 基础用法：类型简写 + 简化守卫# 3.10 写法（需嵌套守卫）defprocess_310(val):    match val:        case x if isinstance(x, int) and x > 0:returnf"正整数：{x}"# 3.14 增强写法（原生类型模式）defprocess_314(val):    match val:        case int(x) if x > 0:  # 原生int类型匹配，直接捕获xreturnf"正整数：{x}"        case str(s) if len(s) > 3:  # 原生str类型匹配returnf"长字符串：{s}"print(process_314(100))    # 输出：正整数：100print(process_314("hello"))# 输出：长字符串：hello# 进阶技巧 1：切片模式（列表 / 元组分段匹配）defanalyze_list(lst):    match lst:        case []:  # 空列表return"空列表"        case [*head, x]:  # 匹配最后一个元素，head为前面所有元素returnf"最后一个元素：{x}，前缀：{head}"        case [x, *middle, y]:  # 匹配首尾，middle为中间元素returnf"首：{x}，尾：{y}，中间：{middle}"print(analyze_list([1,2,3]))    # 输出：最后一个元素：3，前缀：[1,2]print(analyze_list([10,20,30,40]))  # 输出：首：10，尾：40，中间：[20,30]# 进阶技巧 2：字典精准匹配 + 别名模式defprocess_user(user):    match user:# 匹配包含name（字符串）和age（整数）的字典，定义别名user_data        case {"name": str(name), "age": int(age)} as user_data if age >= 18:            print(f"完整数据：{user_data}")returnf"成年用户：{name}"# 匹配age为None或未成年的情况        case {"name": str(name), "age": (None | int(age) if age < 18)}:returnf"未成年/年龄未知：{name}"user1 = {"name": "Frank", "age": 22, "gender": "male"}user2 = {"name": "Grace", "age": 16}print(process_user(user1))  # 输出：完整数据：{'name': 'Frank', 'age': 22, 'gender': 'male'} → 成年用户：Frankprint(process_user(user2))  # 输出：未成年/年龄未知：Grace

1. 优缺点分析

优势:

1. 代码即文档：复杂的匹配逻辑以一种近乎自解释的方式呈现，极大地降低了新成员理解代码的门槛。
2. 无与伦比的类型安全：将动态语言的灵活性与静态类型检查的严谨性结合起来，可以在编码阶段就发现大量潜在的TypeError。
3. 减少样板代码：替代了大量isinstance、getattr、字典/列表索引以及后续的if检查，代码更紧凑。
4. 更强的解构能力：可以轻松地从复杂的数据结构中“挖掘”出所需的数据，并直接绑定到变量上。

局限性/缺点:

1. 性能考量：尽管有优化，但在性能极其敏感的、只有简单值匹配的循环中，传统的if-elif链可能仍然是首选。性能对比结果显示，这取决于具体场景 。
2. 语法复杂性：对于初学者，match-case的完整语法（包括各种模式、as关键字、|操作符、if守卫）比if-elif更复杂，需要专门学习。
3. 版本依赖：这些强大的增强功能仅在Python 3.14及以上版本可用，对于需要兼容旧版本Python的项目无法使用。

2. 适用场景

增强后的 match-case 适用于需要复杂条件判断或自定义匹配逻辑的场景。

• 复杂条件分支： 在处理多层次的业务逻辑或状态机转换时，match-case 本身可以清晰地区分各种状态或条件。通过 __match__，可以进一步简化某些分支。例如，实现一个状态机，可以在状态类中定义 __match__ 来匹配不同事件，从而在 match-case 中用简洁的语法处理复杂状态转换逻辑。
• 数据解析与验证： 当需要根据输入数据的结构或类型决定处理方式时，match-case 非常有用。结合 __match__，可以在匹配阶段对数据进行预处理或验证。例如，解析 JSON 或 XML 数据时，可以针对不同数据结构编写不同的匹配分支，再在匹配前用 __match__ 校验数据完整性。
• 忽略大小写或特殊格式： 对于字符串匹配，有时需要忽略大小写或匹配特定模式。传统做法是在 if-elif 中进行预处理，而使用 __match__ 可以在匹配阶段统一处理。例如，实现一个 CaseInsensitiveString 类，在其 __match__ 中将自身和匹配值都转为小写后再比较，从而在 match-case 中实现不区分大小写的匹配。
• 正则表达式匹配： 虽然 match-case 支持常量和模式，但并不直接支持正则表达式。通过 __match__，开发者可以实现一个对象在匹配时应用正则。例如，定义一个 RegexPattern 类，其 __match__ 方法对字符串进行正则匹配，返回匹配结果。这样，match-case 就可以像使用内置模式一样使用正则表达式匹配字符串。
• DSL 或自定义语法： 如果构建一个小型领域特定语言，可以在语言内部的类中实现 __match__ 来定义语法元素的匹配规则。这将 DSL 的语法与 Python 的 match-case 无缝集成，使得解析和执行 DSL 语句更加方便。