如何快速筛选大型列表列表中含指定有序双元素的子列表？

针对你的200万个子列表的筛选需求，尤其是只需要检查有序双元素序列的存在，我们可以做很多针对性的优化——毕竟通用子列表匹配算法对于双元素场景来说太冗余了，下面是几个从快到慢的高效实现方案：

1. Numba编译的纯Python循环（最快选项） #

Numba可以把Python循环编译成机器码，彻底避开Python解释器的循环开销，对于大规模数据处理来说速度提升非常明显。

from numba import jit

@jit(nopython=True)
def has_target_pair(lst, target_first, target_second):
    # 先处理子列表长度不足2的边界情况
    lst_len = len(lst)
    if lst_len < 2:
        return False
    # 遍历相邻元素对
    for i in range(lst_len - 1):
        if lst[i] == target_first and lst[i+1] == target_second:
            return True
    return False

# 假设你的目标序列是 (a, b)
target_a, target_b = a, b
# 执行筛选
filtered_list = [sublst for sublst in my_huge_list_of_lists if has_target_pair(sublst, target_a, target_b)]

这个方法的优势是：编译后循环速度接近C语言级别，且不需要额外的数据结构转换，内存开销极小。

2. Numpy向量化操作 #

利用Numpy的C级向量化运算，批量处理相邻元素对的比较，适合习惯用Numpy的场景：

import numpy as np

# 定义目标序列
target = np.array([a, b])
filtered_list = []

for sublst in my_huge_list_of_lists:
    arr = np.array(sublst)
    # 生成所有相邻元素对的二维数组
    adjacent_pairs = np.stack((arr[:-1], arr[1:]), axis=1)
    # 检查是否存在匹配的元素对
    if np.any(np.all(adjacent_pairs == target, axis=1)):
        filtered_list.append(sublst)

注意：虽然Numpy的向量化很快，但每个子列表转成Numpy数组有一定开销，对于50元素的子列表来说这个开销可以接受，但如果子列表更长，需要权衡转换成本和运算速度。

3. 迭代器遍历（无额外依赖，速度不错） #

不用任何第三方库，通过迭代器直接遍历相邻元素，避免创建切片或额外列表，内存效率很高：

def has_target_pair(lst, target):
    if len(lst) < 2:
        return False
    # 把列表转成迭代器，逐个取元素
    iter_lst = iter(lst)
    prev_element = next(iter_lst)
    for curr_element in iter_lst:
        if (prev_element, curr_element) == target:
            return True
        prev_element = curr_element
    return False

# 目标序列
target = (a, b)
filtered_list = [sublst for sublst in my_huge_list_of_lists if has_target_pair(sublst, target)]

这个方法比你原来的切片方法快很多，因为它不需要每次创建新的切片列表来比较，直接对比两个元素即可。

4. 简化的Zip生成器写法（代码简洁） #

用zip(lst, lst[1:])生成所有相邻元素对，代码非常简洁，适合对代码可读性要求高的场景：

target = (a, b)
filtered_list = [sublst for sublst in my_huge_list_of_lists if any(pair == target for pair in zip(sublst, sublst[1:]))]

不过这里lst[1:]会创建一个长度为49的新列表，虽然对于50元素的子列表来说开销不大，但在200万次循环下，累积的内存开销会比迭代器方法略高。

为什么你的原方法效率低？ #

你原来的代码用any((sublst == lst[i:i + n]) for i in xrange...)，每次循环都会创建一个长度为2的切片列表，然后和目标子列表比较——这个切片创建和列表比较的操作，比直接对比两个元素的开销大得多，在200万次循环下会浪费大量时间。

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