Python - itertools.pairwise函数在算法刷题中的高效应用

1. 别再写 for i in range(len()-1) 了，试试 pairwise

如果你和我一样，在LeetCode或者日常写Python时，经常需要处理一个序列里相邻两个元素的关系，那你一定写过这样的代码：

nums = [1, 2, 3, 4, 5]
for i in range(len(nums) - 1):
    current = nums[i]
    next_elem = nums[i + 1]
    # 然后对 current 和 next_elem 做一些操作...

或者，为了更“Pythonic”一点，可能会用 zip：

for current, next_elem in zip(nums, nums[1:]):
    # 操作...

这两种写法都没错，但前者略显啰嗦，后者在列表很长时会创建一个 nums[1:] 的切片副本，虽然通常影响不大，但在追求极致或者处理海量数据时，总感觉不够优雅和高效。这时候，就该 itertools.pairwise 登场了。这个从 Python 3.10 开始加入标准库的小工具，简直就是为这种“滑动窗口”式处理相邻元素而生的。我第一次在刷题时用它替换掉冗长的索引循环后，感觉代码瞬间清爽了一个档次，可读性也大大提升。

简单来说，pairwise 会接收一个可迭代对象（比如列表、字符串、元组，甚至是生成器），然后返回一个迭代器，这个迭代器会依次产出输入中连续的重叠对。用官方文档的例子最直观：pairwise('ABCDEFG') 会依次产出 ('A', 'B')， ('B', 'C')， ('C', 'D')…… 一直到 ('F', 'G')。看到没？它自动帮你把“当前元素”和“下一个元素”打包好了，你直接在一个 for 循环里解包就能用，完全不用操心索引越界或者手动切片。

我刚开始用的时候也犯过嘀咕：这玩意儿不就是 zip(iterable, iterable[1:]) 的封装吗？用起来能有多大区别？但实际用下来，尤其是在算法题这种对边界条件和性能有微妙要求的场景里，我发现它的优势不止一点半点。首先，它处理的是迭代器，是“惰性”的，不会像 nums[1:] 那样产生额外的内存开销，对于超大流式数据非常友好。其次，它的语义极其清晰，for x, y in pairwise(data): 一眼就能看出这是在处理相邻元素对，比 for i in range(len(data)-1): 这种需要脑补索引关系的写法，意图明确太多了。接下来，我们就深入看看怎么把它用到刀刃上。

2. 庖丁解牛：pairwise 的里里外外

2.1 基本用法与核心行为

要用好一个工具，首先得摸清它的脾气。itertools.pairwise(iterable) 的使用非常简单，但有几个关键行为你必须了然于胸，否则很容易踩坑。

第一，输入要求。 它期望一个可迭代对象。什么是可迭代对象？列表、字符串、元组、集合、字典的键、文件对象，或者任何实现了 __iter__ 方法的对象都行。这给了我们极大的灵活性。但有一个重要的边界条件：如果输入的可迭代对象包含的元素少于两个，那么 pairwise 返回的迭代器就是空的。比如 pairwise([1]) 或 pairwise('A')，你用它来迭代，什么也得不到。这是因为至少需要两个元素才能形成一个“对”。这个特性在写通用函数时要特别注意，可能需要先判断长度。

第二，输出特性。 它返回的是一个迭代器，而不是列表。这意味着它是“按需生成”的，非常节省内存。如果你需要查看所有结果，可以用 list() 把它转成列表：list(pairwise([1,2,3,4])) 会得到 [(1,2), (2,3), (3,4)]。注意看，输出的对数总比输入的元素数少一个。输入4个数，得到3个对，这很符合“相邻”的直觉。

让我们看几个具体的例子，巩固一下印象：

from itertools import pairwise

# 例子1：处理列表
data_list = [10, 20, 30, 40]
for a, b in pairwise(data_list):
    print(f"差值: {b - a}")
# 输出:
# 差值: 10
# 差值: 10
# 差值: 10

# 例子2：处理字符串（判断是否连续字母）
s = "abcde"
for c1, c2 in pairwise(s):
    if ord(c2) - ord(c1) == 1:
        print(f"{c1}{c2} 是连续的")
# 输出:
# ab 是连续的
# bc 是连续的
# cd 是连续的
# de 是连续的

# 例子3：处理生成器（无限序列的局部）
def count_up():
    n = 0
    while True:
        yield n
        n += 1

# 取前5个相邻对
import itertools
for a, b in itertools.islice(pairwise(count_up()), 5):
    print(a, b)
# 输出:
# 0 1
# 1 2
# 2 3
# 3 4
# 4 5

第三个例子展示了 pairwise 与无限生成器配合的能力，这在某些数学计算或流处理场景中很有用，当然要记得用 itertools.islice 之类的工具来限制输出，不然循环就停不下来了。

2.2 自己动手实现一个 pairwise

理解一个函数最好的方式，就是尝试自己实现它。Python官方文档里其实给出了 pairwise 的一个等价实现，我们一起来拆解一下，这对理解迭代器的工作机制大有裨益：

def my_pairwise(iterable):
    # 步骤1：获取输入可迭代对象的迭代器
    iterator = iter(iterable)
    # 步骤2：取出第一个元素，如果为空则用None填充
    a = next(iterator, None)
    # 步骤3：遍历剩下的元素
    for b in iterator:
        # 步骤4：产出当前对 (a, b)
        yield a, b
        # 步骤5：将b赋值给a，为下一轮循环做准备
        a = b

我们来一步步分析这个“教科书式”的实现：

1. iter(iterable)：这是关键的第一步。它把传入的“可迭代对象”转换成了一个“迭代器对象”。你可以把迭代器想象成一个带状态的“指针”，它记得自己遍历到哪个位置了。列表本身是可迭代的，但不是迭代器，iter() 函数让它变成了一个可以调用 next() 的迭代器。
2. next(iterator, None)：这是第二步，尝试从迭代器中取出第一个元素，并把它赋值给变量 a。next() 函数的第二个参数 None 是默认值，如果迭代器里已经没有元素了（即输入为空），那么 a 就会被赋值为 None。在我们的实现里，如果输入只有一个元素，那么 a 会被赋值为这个元素，但随后 for b in iterator: 循环会因为迭代器耗尽而根本不会执行，所以整个生成器不会产出任何值，这与官方行为一致。
3. for b in iterator:：这是一个非常巧妙的写法。注意，这里遍历的是 iterator，而不是原始的 iterable。因为 iterator 在上一步 next() 调用后，“指针”已经指向了第二个元素（如果存在）。所以这个 for 循环会从第二个元素开始依次取出，赋值给 b。
4. yield a, b 和 a = b：在循环体内，我们产出当前的 (a, b) 对。然后，至关重要的一步，我们把 b 赋值给 a。这样，在下一次循环时，上一次的“下一个元素” b 就变成了这次的“当前元素” a，实现了滑动窗口的移动。

自己实现一遍后，你就能深刻体会到 pairwise 的优雅之处：它只用了一个迭代器，通过一个临时变量 a 来缓存前一个元素，就高效地完成了任务，没有多余的内存拷贝。这也解释了为什么它比 zip(iterable, iterable[1:]) 更优，后者在内存中创建了整个列表的副本（除了第一个元素）。

3. 刷题实战：当 pairwise 遇见“分组循环”

理论知识讲得再多，不如真刀真枪在题目里练练。pairwise 在算法刷题中有一个非常经典的应用场景，我称之为“相邻关系判断与分组”，这常常对应着一种叫做“分组循环”的解题模板。很多处理数组或字符串，需要根据相邻元素的某种关系（如相等、递增、具有相同特征）进行分组的题目，都可以用 pairwise 优雅地解决。

3.1 案例一：最长连续递增子串

我们来看 LeetCode 上的一道简单题（但很能说明问题）：最长连续递增子串。题目要求找到一个字符串中最长的连续字母子串（在字母表中是连续的）。例如，"abcde" 的答案是5，"abczyx" 的答案是3 ("abc")。

传统的“分组循环”解法会使用双指针（或单指针模拟），代码逻辑清晰但略显繁琐：

class Solution:
    def longestContinuousSubstring(self, s: str) -> int:
        i, n = 0, len(s)
        ans = 0
        while i < n:
            start = i  # 记录当前连续子串的起点
            i += 1
            # 内层循环：只要相邻字符连续，就扩展右指针i
            while i < n and ord(s[i]) - ord(s[i-1]) == 1:
                i += 1
            # 更新答案
            ans = max(ans, i - start)
        return ans

这段代码没问题，是标准的“外层循环找起点，内层循环扩展终点”的模式。但你看内层的判断条件 ord(s[i]) - ord(s[i-1]) == 1，需要小心地处理索引 i-1。现在，我们用 pairwise 来改造它：

from itertools import pairwise

class Solution:
    def longestContinuousSubstring(self, s: str) -> int:
        ans = cnt = 1  # 初始化答案为1，当前连续长度cnt为1
        for x, y in pairwise(map(ord, s)):  # 关键在这里
            cnt = cnt + 1 if x + 1 == y else 1
            ans = max(ans, cnt)
        return ans

代码瞬间缩短了一半，而且逻辑异常清晰！ 我们来拆解一下：

1. map(ord, s)：将字符串 s 中的每个字符先转换成其 Unicode 码点（ASCII值），得到一个数字迭代器。这样我们后续就可以直接对数字进行加减比较。
2. pairwise(...)：对这个数字迭代器使用 pairwise，它就会依次产出相邻字符的码点对 (x, y)。
3. for x, y in ...：在循环中，x 是前一个字符的码点，y 是后一个字符的码点。我们只需要判断 y 是否等于 x + 1。
4. 状态维护：cnt 变量记录当前连续递增序列的长度。如果 x+1 == y，说明连续，cnt 加1；否则，序列中断，cnt 重置为1（因为当前 y 本身算作一个长度为1的新序列起点）。ans 始终记录遇到过的最大 cnt。

这种写法完全避免了显式的双指针和索引计算，把“比较相邻元素”这个核心逻辑直接暴露在了 for 循环的头部，非常符合人类的直觉思维。我第一次写出这种解法时，感觉解题体验提升了一个维度。

3.2 案例二：按位计数分组排序

再来看一个稍微复杂点的例子，这是一道中等题。题目要求判断一个数组能否通过一种特定规则排序：你只能对数组中“二进制1的个数”相同的连续元素进行排序。最终检查排序后的数组是否整体非递减。

传统的分组循环解法同样需要嵌套循环来找到每一组：

class Solution:
    def canSortArray(self, nums: List[int]) -> bool:
        n = len(nums)
        i = 0
        while i < n:
            start = i
            ones = nums[i].bit_count()  # 当前组的1的个数
            i += 1
            # 找到所有具有相同ones的连续元素
            while i < n and nums[i].bit_count() == ones:
                i += 1
            # 对这一段进行排序
            nums[start:i] = sorted(nums[start:i])
        # 最后检查整个数组是否有序
        return all(nums[i] <= nums[i+1] for i in range(n-1))

这个解法中，分组排序的部分很清晰，但最后检查整个数组是否有序时，又出现了 for i in range(n-1) 和 nums[i] <= nums[i+1] 这种模式。这正是 pairwise 的用武之地！我们可以用 pairwise 来简化最终的检查：

from itertools import pairwise

class Solution:
    def canSortArray(self, nums: List[int]) -> bool:
        n = len(nums)
        i = 0
        while i < n:
            start = i
            ones = nums[i].bit_count()
            i += 1
            while i < n and nums[i].bit_count() == ones:
                i += 1
            nums[start:i] = sorted(nums[start:i])
        # 使用 pairwise 检查相邻元素是否非递减
        return all(x <= y for x, y in pairwise(nums))

看最后一行，all(x <= y for x, y in pairwise(nums))。这行代码的意思一目了然：“对于数组 nums 中的每一对相邻元素 (x, y)，检查是否 x <= y，如果所有对都满足，则返回 True”。这比用索引写出来的 all(nums[i] <= nums[i+1] for i in range(n-1)) 在可读性上更胜一筹，因为它直接表达了“相邻对”这个概念。

3.3 模式总结与扩展思考

从上面两个例子，我们可以总结出 pairwise 在分组循环类题目中的典型应用模式：

当你需要根据“当前元素与下一个元素的关系”来决定是延续当前组还是开启新组时，pairwise 可以帮助你简化“关系判断”的逻辑，让你更专注于维护组的状态。

它特别适合处理那些“连续性”或“局部性”问题，比如：

• 判断序列是否单调（递增/递减）：all(x <= y for x, y in pairwise(nums))
• 计算序列中相邻元素的差值：[y - x for x, y in pairwise(data)]
• 寻找峰值或谷值：检查 (x, y, z) 三元组，但可以用 pairwise 辅助生成相邻对进行比较。
• 字符串中寻找重复或特定模式：比如判断字符串中是否有两个连续相同的字符 any(c1 == c2 for c1, c2 in pairwise(s))。

你可能会问，如果分组条件不是基于“相邻”关系呢？比如根据元素自身的值分组，而不考虑邻居。那 pairwise 就不太适用了，因为它核心处理的就是“相邻性”。这时候还是得用传统的循环或 groupby。所以，工具虽好，也要看场景。

4. 进阶技巧：组合 map、filter 与生成器表达式

pairwise 本身已经很强大了，但它的威力在于可以无缝嵌入到Python强大的函数式编程和迭代器工具链中。和 map、filter、生成器表达式一结合，就能写出既简洁又高效的“一行流”代码。

4.1 与 map 函数联用

在上面的最长连续子串例子中，我们已经看到了 pairwise(map(ord, s)) 的用法。map(ord, s) 首先将字符序列转换为码点序列，然后 pairwise 再对这个数字序列生成相邻对。这是一种非常常见的模式：在比较之前，先对元素进行预处理。

再举一个例子，假设我们有一个温度列表，想找出所有温度上升的日子（后一天比前一天温度高）：

temperatures = [22.5, 23.1, 21.8, 25.0, 24.5, 26.2]
# 使用 pairwise 找出所有升温的相邻对
warming_days = [(day1, day2) for day1, day2 in pairwise(temperatures) if day2 > day1]
print(warming_days)  # 输出: [(22.5, 23.1), (21.8, 25.0), (24.5, 26.2)]
# 如果想直接得到升温的幅度
warming_increments = [day2 - day1 for day1, day2 in pairwise(temperatures) if day2 > day1]
print(warming_increments)  # 输出: [0.6000000000000014, 3.2, 1.7000000000000028]

这里我们结合了列表推导式和 pairwise，代码非常直观。如果预处理更复杂，可以定义函数然后用 map：

def complex_transform(x):
    # 一些复杂的计算
    return processed_x

processed_pairs = pairwise(map(complex_transform, raw_data))
for a, b in processed_pairs:
    # 使用处理后的a, b进行比较或计算

4.2 在生成器表达式中使用

对于超大的数据集，我们可能不希望一次性在内存中创建整个结果列表。这时，生成器表达式就派上用场了，而 pairwise 返回的是迭代器，天生与之契合。

# 假设有一个很大的日志文件，每行是一个数字
def read_large_file(file_path):
    with open(file_path, 'r') as f:
        for line in f:
            yield int(line.strip())

# 计算文件中相邻数字之和超过1000的对数
file_path = 'huge_data.txt'
count = 0
# 这里 pairwise 和生成器表达式都是惰性的，内存友好
for num1, num2 in pairwise(read_large_file(file_path)):
    if num1 + num2 > 1000:
        count += 1
        # 可以在这里处理符合条件的对，而不必保存所有数据
print(f"相邻和超过1000的对数: {count}")

这个例子中，read_large_file 是一个生成器函数，逐行读取文件并转换为整数。pairwise 作用于这个生成器，会动态地产生相邻数字对。整个处理流程是流式的，即使文件有几十GB，内存占用也基本是常数级别。

4.3 构建更复杂的滑动窗口

pairwise 处理的是大小为2的窗口。那如果我们想要大小为3、4甚至n的滑动窗口呢？itertools 库还有一个更通用的工具叫 sliding_window，但在 Python 3.10 的 itertools 中还没有（注：Python 3.12 的 itertools 中新增了 batched，但也不是滑动窗口）。我们可以用 pairwise 的思路，或者用 collections.deque 来实现。不过，对于简单的3元组，我们可以巧妙地组合 pairwise：

from itertools import tee, pairwise

def triplewise(iterable):
    "返回连续的三元组 (s0, s1, s2), (s1, s2, s3), ..."
    a, b, c = tee(iterable, 3)
    next(b, None)
    next(c, None); next(c, None)
    return zip(a, b, c)

# 或者，利用 pairwise 的思想
def triplewise_via_pairwise(iterable):
    it = iter(iterable)
    a = next(it, None)
    b = next(it, None)
    for c in it:
        yield a, b, c
        a, b = b, c

# 使用示例：计算滑动平均（窗口大小为3）
data = [1, 2, 3, 4, 5, 6]
moving_avg = [(x+y+z)/3 for x, y, z in triplewise_via_pairwise(data)]
print(moving_avg)  # 输出: [2.0, 3.0, 4.0, 5.0]

虽然 pairwise 直接解决的是两两相邻的问题，但理解它的原理后，你完全可以举一反三，写出处理任意大小窗口的函数。这在一些需要查看局部上下文的问题中很有用，比如时间序列分析、信号处理等。

5. 性能对比与使用陷阱

在刷题和实际开发中，我们不仅要关心代码是否优雅，还得关心它快不快。我们来对比一下 pairwise 和几种常见替代方法的性能，并聊聊使用时需要注意的“坑”。

5.1 性能基准测试

我写了一个简单的测试脚本，用于比较在长度为 N 的列表上，计算相邻元素差的和时，几种写法的性能：

import timeit
from itertools import pairwise
import random

def test_performance(N):
    data = [random.random() for _ in range(N)]

    # 方法1: 传统索引循环
    def method_index():
        total = 0
        for i in range(len(data) - 1):
            total += data[i + 1] - data[i]
        return total

    # 方法2: 使用 zip
    def method_zip():
        total = 0
        for a, b in zip(data, data[1:]):
            total += b - a
        return total

    # 方法3: 使用 pairwise
    def method_pairwise():
        total = 0
        for a, b in pairwise(data):
            total += b - a
        return total

    # 方法4: 使用列表推导式+sum (zip版)
    def method_sum_zip():
        return sum(b - a for a, b in zip(data, data[1:]))

    # 方法5: 使用列表推导式+sum (pairwise版)
    def method_sum_pairwise():
        return sum(b - a for a, b in pairwise(data))

    setups = [method_index, method_zip, method_pairwise, method_sum_zip, method_sum_pairwise]
    names = ['索引循环', 'zip循环', 'pairwise循环', 'sum+zip推导', 'sum+pairwise推导']

    print(f"数据量 N = {N}")
    for name, func in zip(names, setups):
        # 执行多次取平均时间
        time_taken = timeit.timeit(func, number=1000)
        print(f"  {name:20} 耗时: {time_taken:.5f} 秒")

if __name__ == '__main__':
    for N in [100, 1000, 10000]:
        test_performance(N)
        print("-" * 50)

在我的电脑上运行，结果趋势非常明显（具体数值因机器而异）：

• 当 N 较小时（100）：几种方法差异微乎其微，zip 和 pairwise 可能因为函数调用的开销略慢一丁点，但完全可以忽略。
• 当 N 增大时（10000）：zip(data, data[1:]) 这种写法因为要创建 data[1:] 的完整切片副本，内存分配和复制的开销会显现出来，速度开始明显慢于 pairwise 和索引循环。pairwise 和索引循环的性能则非常接近，有时 pairwise 甚至因为更简洁的Python字节码而略有优势。
• sum 配合生成器表达式：sum(b - a for a, b in pairwise(data)) 这种写法通常是最快的之一。因为它将循环和求和都推给了高度优化的C语言层执行，避免了Python层循环的开销。

结论：对于大多数刷题场景（数据量通常在 10^5 以内），几种写法在时间上都能接受。但 pairwise 在内存效率上完胜 zip 切片写法，在代码简洁性和可读性上完胜索引循环。而 sum + 生成器表达式 + pairwise 的组合，往往是性能和优雅的绝佳平衡点。

5.2 常见“坑”与注意事项

1. 空或单元素输入：这是最容易出错的地方。pairwise 在输入元素少于2时返回空迭代器。如果你的逻辑默认至少有一对数据，就会出错。安全的做法是预先判断：

   if len(data) < 2:
       # 处理边界情况，例如返回0、空列表或特定值
       return 0
   for a, b in pairwise(data):
       # 主逻辑
   

2. 迭代器耗尽：pairwise 返回的是迭代器，只能遍历一次。如果你需要多次使用结果，需要先转换为列表或使用 itertools.tee 进行复制。

   pairs = list(pairwise(data))  # 转换为列表，可重复使用
   # 或者
   iter1, iter2 = itertools.tee(pairwise(data), 2)
   

3. 与 zip 的微妙区别：zip 在输入长度不同时，会以最短的为准停止。pairwise 只接受一个可迭代对象，行为是确定的。不要混淆。pairwise 专注于单个序列的内部相邻关系。

4. 状态维护：像最长连续子串那样的题目，使用 pairwise 后，状态（如当前连续长度 cnt）的维护需要在循环体内显式进行。这比双指针解法中“循环边界即状态”的模式更需要留心。确保在状态重置时（如 cnt = 1）理解其含义：新的一对 (x, y) 中，y 是新区间的开始。

5. 不是万能的：pairwise 解决的是“相邻”问题。对于需要访问更远距离元素、或者分组条件与相邻性无关的问题，它就不适用了。不要强行套用。

总的来说，pairwise 是一个“用了就回不去”的工具。它可能不会让你的算法时间复杂度从 O(n^2) 降到 O(n)，但它能让你的 O(n) 解法写得更漂亮、更不容易出错。在刷题这种追求快速、清晰表达思路的场合，以及在实际项目注重代码可维护性的场景下，它的价值远超一个简单的语法糖。下次再遇到需要比较相邻元素的时候，先别急着写 for i in range(len()-1)，想想 pairwise，也许一行代码就能搞定。