结构模式匹配（Structural Pattern Matching）（一）匹配序列

match 匹配序列（Matching sequences）

  match语句允许匹配和解构不同类型的序列，包括列表、元组和其他可迭代对象。这提供了一种便捷的方式来处理各种序列数据，同时提取和使用它们的元素。
  math语句语法：
  match 后的对象会依次与case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_可以匹配一切。

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>
1
2
3
4
5
6
7
8
9

1.匹配空列表

# 输出 匹配了空列表
data = []
match data:
    case []:
        print("匹配了空列表。")
    case _:
        print("没有匹配。")
1
2
3
4
5
6
7

2.匹配含特定元素的列表

# 输出 匹配上特定元素
data = [1,'a',True]
match data:
    case [1,'a',True]:
        print("匹配上特定元素。")
    case _:
        print("没有匹配上特定元素。")
1
2
3
4
5
6
7

3.匹配特定元素开头的列表

# 输出 匹配了以5开头的列表，除了开头剩下的元素为[6, 7, 9].
data = [5,6,7,9]
match data:
    case [5, *rest]:
        print(f'匹配了以5开头的列表，除了开头剩下的元素为{rest}.')
    case _:
        print("没有匹配上。")
1
2
3
4
5
6
7

4.匹配特定长度的列表

# 输出 匹配了长度为3的列表，a=3,b=a,c=6。
data = [3,'a',6]
match data:
    case [a,b,c] if len(data)==3:
        print(f'匹配了长度为3的列表，a={a},b={b},c={c}。')
    case _:
        print("没有匹配上。")
1
2
3
4
5
6
7

5.匹配嵌套的列表

# 输出 匹配上嵌套的列表，a=4,b=5,c=6,7,剩余的元素为：[8, 9]。
data = [4,[5,6],[7,8,9]]
match data:
    case [a,[b,c],[7,*rest]]:
        print(f'匹配上嵌套的列表，a={a},b={b},c={c},7,剩余的元素为：{rest}。')
    case _:
        print("没有匹配上。")
1
2
3
4
5
6
7

6.匹配任何可迭代对象

"""
	输出：
	匹配了以1、True开头的可迭代对象，剩余部分为[3, 4, 5]
	其他情况
	匹配了以a、20开头的可迭代对象，剩余部分为[30]
	匹配了以0、1开头的可迭代对象，剩余部分为[2]
""" 
def process_iterable(iterable):
    match iterable:
        case []:
            print("空可迭代对象")
        case [x,y, *rest]:
            print(f"匹配了以{x}、{y}开头的可迭代对象，剩余部分为{rest}")
        case _:
            print("其他情况")

# 测试不同类型的可迭代对象
process_iterable([1, True, 3, 4, 5])
process_iterable("Hello, World!")
process_iterable(('a', 20, 30))
process_iterable(range(3))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7.匹配特定元素的元组

# 输出 匹配了元组5
data = (5,'apple',3.1415,True)
match data:
    case (int,str,float,bool):
        print('匹配了元组')
    case _:
        print('匹配不了。')
1
2
3
4
5
6
7

8.匹配字典元素

# 输出 匹配了包含特定键和值类型的字典
data = {"name": "Alice", "age": 30, "city": "New York"}
match data:
    case {"name": name, "age": age, "city": city}:
        print("匹配了包含特定键和值类型的字典")
    case _:
        print("其他情况")
1
2
3
4
5
6
7

9.官网案例

  match语句的第一个case块验证了命令是否匹配[action, obj]这种结构，如果匹配，它会提取并绑定action和obj变量。如果不匹配，就会进入下一个case块，使用通配符_匹配不合法的输入。
  请注意，可以使用括号、圆括号或逗号分隔模式，它们都是等效的，因此可以写成不同的形式：case action, obj或case (action, obj)。

command = input('What are you doing next!')
match command.split():
    case [action,obj]:
        print(f'{action} {obj}')
    case _:
        print('不知道你想做什么。')
1
2
3
4
5
6

  参考：匹配序列：https://peps.python.org/pep-0636/#matching-sequences