来自单个列表的对[重复]

我最喜欢的做法：

def pairwise(t):
    it = iter(t)
    return zip(it,it)

# for "pairs" of any length
def chunkwise(t, size=2):
    it = iter(t)
    return zip(*[it]*size)

当您想配对所有元素时，您显然可能需要一个填充值：

from itertools import izip_longest
def blockwise(t, size=2, fillvalue=None):
    it = iter(t)
    return izip_longest(*[it]*size, fillvalue=fillvalue)

在 Python 3 中，itertools.izip 现在只是 zip .. 要使用较旧的 Python，请使用

from itertools import izip as zip

我会说您的初始解决方案 pairs = zip(t[::2], t[1::2]) 是最好的解决方案，因为它最容易阅读（在 Python 3 中，zip 自动返回迭代器而不是列表）。

为确保包含所有元素，您只需将列表扩展 None。

然后，如果列表有奇数个元素，最后一对将是 (item, None)。

>>> t = [1,2,3,4,5]
>>> t.append(None)
>>> zip(t[::2], t[1::2])
[(1, 2), (3, 4), (5, None)]
>>> t = [1,2,3,4,5,6]
>>> t.append(None)
>>> zip(t[::2], t[1::2])
[(1, 2), (3, 4), (5, 6)]

我从小免责声明开始 - 不要使用下面的代码。它根本不是 Pythonic，我只是为了好玩而写的。它类似于@THC4k pairwise 函数，但它使用 iter 和 lambda 闭包。它不使用 itertools 模块，也不支持 fillvalue。我把它放在这里是因为有人可能会觉得它很有趣：

pairwise = lambda t: iter((lambda f: lambda: (f(), f()))(iter(t).next), None)

就大多数 pythonic 而言，我会说 recipes supplied in the python source docs （其中一些看起来很像@JochenRitzel 提供的答案）可能是你最好的选择；）

def grouper(iterable, n, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

在现代 python 上，您只需要使用 zip_longest(*args, fillvalue=fillvalue) according to the corresponding doc page。

还有另一种“更好”的成对遍历列表的方式吗？

我不能肯定地说，但我对此表示怀疑：任何其他遍历都将包含更多必须解释的 Python 代码。像 zip() 这样的内置函数是用 C 编写的，速度要快得多。

哪种方法是确保包含所有元素的正确方法？

检查列表的长度，如果它是奇数 (len(list) & 1 == 1)，则复制列表并附加一个项目。

>>> my_list = [1,2,3,4,5,6,7,8,9,10]
>>> my_pairs = list()
>>> while(my_list):
...     a = my_list.pop(0); b = my_list.pop(0)
...     my_pairs.append((a,b))
... 
>>> print(my_pairs)
[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

只做：

>>> l = [1, 2, 3, 4, 5, 6]
>>> [(x,y) for x,y in zip(l[:-1], l[1:])]
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]

以防万一有人需要算法方面的答案，这里是：

>>> def getPairs(list):
...     out = []
...     for i in range(len(list)-1):
...         a = list.pop(0)
...         for j in a:
...             out.append([a, j])
...     return b
>>> 
>>> k = [1, 2, 3, 4]
>>> l = getPairs(k)
>>> l
[[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

但请注意，您的原始列表也将减少到最后一个元素，因为您在其上使用了 pop。

>>> k
[4]

这是使用生成器创建对/腿的示例。生成器不受堆栈限制

def pairwise(data):
    zip(data[::2], data[1::2])

例子：

print(list(pairwise(range(10))))

输出：

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

这个片段对我有用。如果列表长度为奇数 (fillvalue="")，它会创建元组对并将空字符串添加到最后一对。

zip_longest(*[iter(my_list)] * 2, fillvalue="")

# odd
list(zip_longest(*[iter([0, 1, 2, 3, 4, 5, 6])] * 2, fillvalue=""))
[(0, 1), (2, 3), (4, 5), (6, '')]

# even
list(zip_longest(*[iter([0, 1, 2, 3, 4, 5])] * 2, fillvalue=""))
[(0, 1), (2, 3), (4, 5)]