遍历列表中所有连续项对[重复]

问题描述：

给定一个列表

l = [1, 7, 3, 5]

我想遍历所有连续的列表项对(1,7), (7,3), (3,5)，即

for i in xrange(len(l) - 1):
    x = l[i]
    y = l[i + 1]
    # do something

我想以更紧凑的方式做到这一点，例如

for x, y in someiterator(l): ...

有没有办法使用内置 Python 迭代器来实现这一点？我确信itertools模块应该有一个解决方案，但我就是想不出来。

解决方案 1：

只需使用zip

>>> l = [1, 7, 3, 5]
>>> for first, second in zip(l, l[1:]):
...     print(first, second)
...
1 7
7 3
3 5

如果您使用 Python 2（不建议），您可能会考虑使用该izip函数来处理itertools非常长的列表，而您不想创建新列表。

import itertools

for first, second in itertools.izip(l, l[1:]):
    ...

解决方案 2：

查看pairwiseitertools 配方：http ://docs.python.org/2/library/itertools.html#recipes

引用自那里：

def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = tee(iterable)
    next(b, None)
    return izip(a, b)

通用版本

产生任何给定正自然大小的元组的通用版本可能如下所示：

def nwise(iterable, n=2):                                                      
    iters = tee(iterable, n)                                                     
    for i, it in enumerate(iters):                                               
        next(islice(it, i, i), None)                                               
    return izip(*iters)   

解决方案 3：

我会创建一个通用grouper生成器，像这样

def grouper(input_list, n = 2):
    for i in xrange(len(input_list) - (n - 1)):
        yield input_list[i:i+n]

样品运行 1

for first, second in grouper([1, 7, 3, 5, 6, 8], 2):
    print first, second

输出

1 7
7 3
3 5
5 6
6 8

样品运行 1

for first, second, third in grouper([1, 7, 3, 5, 6, 8], 3):
    print first, second, third

输出

1 7 3
7 3 5
3 5 6
5 6 8

解决方案 4：

将 sberry 的方法推广到具有理解力的 nwise：

def nwise(lst, k=2):
    return list(zip(*[lst[i:] for i in range(k)])) 

例如

nwise(list(range(10)),3)

[(0,1,2),(1,2,3),(2,3,4),(3,4,5),(4,5,6),(5,6,7),( 6,7,8),(7,8,9)]

解决方案 5：

实现此目的而无需进行不必要复制的简单方法是使用存储前一个元素的生成器。

def pairs(iterable):
    """Yield elements pairwise from iterable as (i0, i1), (i1, i2), ..."""
    it = iter(iterable)
    try:
        prev = next(it)
    except StopIteration:
        return
    for item in it:
        yield prev, item
        prev = item

与基于索引的解决方案不同，它适用于任何可迭代对象，包括不支持索引的迭代对象（例如生成器）或速度较慢的迭代对象（例如collections.deque）。

解决方案 6：

您可以使用zip。

>>> list(zip(range(5), range(2, 6)))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]

就像拉链一样，它会形成对。因此，要混合这两个列表，您将获得：

>>> l = [1,7,3,5]
>>> list(zip(l[:-1], l[1:]))
[(1, 7), (7, 3), (3, 5)]

然后迭代如下

for x, y in zip(l[:-1], l[1:]):
    pass

解决方案 7：

如果你想要一些内联但可读性不强的东西，这里有另一个利用生成器的解决方案。我估计它也不是性能最好的 :-/

将列表转换为生成器，并进行调整以在最后一项之前结束：

gen = (x for x in l[:-1])

将其转换成对：

[(gen.next(), x) for x in l[1:]]

这就是你所需要的。