如何实现嵌套列表图书结构的模式匹配函数并返回匹配结果？

需求说明 #

我们需要开发一个适配嵌套列表存储图书数据的模式匹配函数，图书数据结构如下：

books = [['author', ['elon', 'musk']],
        ['title', ['book', 'one']],
       
        ['author', ['elon', 'tusk']],
        ['title', ['book', 'two']]]

每本图书包含author和title两个字段，匹配规则为：

• &：匹配单个任意元素
• --：匹配多个任意元素（含零个）

测试用例 #

用例1

search1 = [['author', ['elon', '&']],
           ['title', ['book', '&']]]

匹配逻辑：

• 作者规则：elon + 任意单个元素 → 匹配两本图书
• 标题规则：book + 任意单个元素 → 匹配两本图书
• 预期结果：返回全部两本图书

用例2

search2 = ['--', 
          ['title', ['book', 'one']]]

匹配逻辑：

• --：匹配任意作者（所有作者均符合）
• 标题规则：精确匹配book one
• 预期结果：仅返回第一本图书

现有通用模式匹配函数仅返回布尔值，无法返回匹配的图书条目，需改造以实现需求：

def match(seq, pattern):
    if not pattern:
        return not seq
    elif pattern[0] == '--':
        if match(seq, pattern[1:]):
            return True
        elif not seq:
            return False
        else:
            return match(seq[1:], pattern)
    elif not seq:
        return False
    elif pattern[0] == '&':
        return match(seq[1:], pattern[1:])
    elif seq[0] == pattern[0]:
        return match(seq[1:], pattern[1:])
    elif type(seq[0]) == list and type(seq[0]) == list:  # 原代码存在bug，重复判断seq[0]
        if not match(seq, pattern):
            return False
    else:
        return False

改造方案 #

1. 先处理图书数据分组 #

原books是扁平结构，需先按author+title分组为单本图书的列表：

def group_books(raw_books):
    grouped = []
    current_book = []
    for item in raw_books:
        current_book.append(item)
        if len(current_book) == 2:
            grouped.append(current_book)
            current_book = []
    return grouped

分组后得到结构化的图书列表：

grouped_books = [
    [['author', ['elon', 'musk']], ['title', ['book', 'one']]],
    [['author', ['elon', 'tusk']], ['title', ['book', 'two']]]
]

2. 拆分匹配逻辑为两个函数 #

将序列匹配和字段匹配拆分，明确职责：

def match_sequence(seq, pattern):
    # 核心序列匹配逻辑，修复原代码bug
    if not pattern:
        return not seq
    elif pattern[0] == '--':
        if match_sequence(seq, pattern[1:]):
            return True
        elif not seq:
            return False
        else:
            return match_sequence(seq[1:], pattern)
    elif not seq:
        return False
    elif pattern[0] == '&':
        return match_sequence(seq[1:], pattern[1:])
    elif seq[0] == pattern[0]:
        return match_sequence(seq[1:], pattern[1:])
    elif isinstance(seq[0], list) and isinstance(pattern[0], list):
        if not match_sequence(seq[0], pattern[0]):
            return False
        return match_sequence(seq[1:], pattern[1:])
    else:
        return False

def is_field_match(book_item, pattern_item):
    # 匹配单个字段（如author/title项）
    if pattern_item[0] == '--':
        # --匹配任意字段，直接验证值部分
        return match_sequence(book_item[1], pattern_item[1])
    # 字段名必须一致，再验证值
    if book_item[0] != pattern_item[0]:
        return False
    return match_sequence(book_item[1], pattern_item[1])

3. 实现结果收集的外层函数 #

遍历分组后的图书，收集所有符合匹配规则的条目：

def match(search_pattern, raw_books):
    grouped_books = group_books(raw_books)
    matched = []
    for book in grouped_books:
        # 验证当前图书是否满足所有搜索条件
        all_conditions_met = True
        for pattern in search_pattern:
            field_matched = False
            for book_item in book:
                if is_field_match(book_item, pattern):
                    field_matched = True
                    break
            if not field_matched:
                all_conditions_met = False
                break
        if all_conditions_met:
            matched.append(book)
    return matched

测试验证 #

# 测试用例1
search1 = [['author', ['elon', '&']], ['title', ['book', '&']]]
print(match(search1, books))
# 输出：[[['author', ['elon', 'musk']], ['title', ['book', 'one']]], [['author', ['elon', 'tusk']], ['title', ['book', 'two']]]]

# 测试用例2
search2 = ['--', ['title', ['book', 'one']]]
print(match(search2, books))
# 输出：[[['author', ['elon', 'musk']], ['title', ['book', 'one']]]]

内容的提问来源于stack exchange，提问作者Bart