ьно часто я обнаружил необходимость обрабатывать список по парам. Мне было интересно, какой будет питон и эффективный способ сделать это, и нашел это в Google:

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

Я думал, что это было достаточно питоническим, но после недавнего обсуждения с участиемидиомы против эффективностиЯ решил сделать несколько тестов:

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

Результаты пока что

Наиболее питонны и очень эффективны:

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

Самый эффективный и очень питонический:

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

Мне потребовалось время, чтобы понять, что в первом ответе используются два итератора, а во втором - один.

Чтобы иметь дело с последовательностями с нечетным числом элементов, было предложено дополнить исходную последовательность добавлением одного элемента (None) в сочетании с предыдущим последним элементом, чего можно достичь с помощьюitertools.izip_longest().

в заключение

Обратите внимание, что в Python 3.xzip() ведет себя какitertools.izip(), а такжеitertools.izip() ушел