python - 来自单个列表的对

Question

这个问题在这里已经有了答案:

How do I split a list into equally-sized chunks? (71 个回答)

关闭 4 个月前。

社区在4个月前审核了是否重新打开此问题并关闭:

原始关闭原因未解决

我经常发现需要成对处理列表。我想知道哪一种是pythonic和有效的方法，并在谷歌上找到了这个:

pairs = zip(t[::2], t[1::2])

我认为这已经足够pythonic了，但是在最近一次涉及idioms versus efficiency的讨论之后，我决定做一些测试:

import time
from itertools import islice, izip

def pairs_1(t):
    return zip(t[::2], t[1::2]) 

def pairs_2(t):
    return izip(t[::2], t[1::2]) 

def pairs_3(t):
    return izip(islice(t,None,None,2), islice(t,1,None,2))

A = range(10000)
B = xrange(len(A))

def pairs_4(t):
    # ignore value of t!
    t = B
    return izip(islice(t,None,None,2), islice(t,1,None,2))

for f in pairs_1, pairs_2, pairs_3, pairs_4:
    # time the pairing
    s = time.time()
    for i in range(1000):
        p = f(A)
    t1 = time.time() - s

    # time using the pairs
    s = time.time()
    for i in range(1000):
        p = f(A)
        for a, b in p:
            pass
    t2 = time.time() - s
    print t1, t2, t2-t1

这些是我电脑上的结果:

1.48668909073 2.63187503815 1.14518594742
0.105381965637 1.35109519958 1.24571323395
0.00257992744446 1.46182489395 1.45924496651
0.00251388549805 1.70076990128 1.69825601578

如果我对它们的解释正确，那应该意味着 Python 中的列表、列表索引和列表切片的实现非常有效。这是一个既令人欣慰又出乎意料的结果。

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

请注意，如果列表有奇数个元素，那么最后一个将不会出现在任何对中。

确保所有元素都包含在内的正确方法是什么？

我从测试的答案中添加了这两个建议:

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

def chunkwise(t, size=2):
    it = iter(t)
    return izip(*[it]*size)

结果如下:

0.00159502029419 1.25745987892 1.25586485863
0.00222492218018 1.23795199394 1.23572707176

目前的结果

最pythonic且非常高效:

pairs = izip(t[::2], t[1::2])

最高效且非常pythonic:

pairs = izip(*[iter(t)]*2)

我花了一点时间才发现第一个答案使用了两个迭代器，而第二个答案使用了一个。

为了处理具有奇数个元素的序列，建议在原始序列中增加一个与前一个元素配对的元素 (None)，这是可以实现的使用 itertools.izip_longest().

终于

请注意，在 Python 3.x 中，zip() 的行为类似于 itertools.izip() 和 itertools.izip()没了。

Answer 1

我最喜欢的做法:

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