[python] 단일 목록의 쌍

종종 나는 쌍으로 목록을 처리해야 할 필요성을 발견했습니다. 나는 그것을 수행하는 비단뱀적이고 효율적인 방법이 무엇인지 궁금해했으며 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

올바르게 해석하고 있다면 파이썬에서 목록, 목록 인덱싱 및 목록 분할을 구현하는 것이 매우 효율적이라는 것을 의미합니다. 편안함과 예상치 못한 결과입니다.

쌍으로 목록을 순회하는 또 다른 “더 나은”방법이 있습니까?

목록에 홀수 개의 요소가있는 경우 마지막 요소는 쌍에 포함되지 않습니다.

모든 요소가 포함되도록하는 올바른 방법은 무엇입니까?

테스트에 대한 답변에서 다음 두 가지 제안을 추가했습니다.

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()좋습니다.

드디어

파이썬 3.x를, 즉 참고 zip()로 동작 itertools.izip()하고, itertools.izip() 사라 졌어요.

답변

from itertools import izip

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

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

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

>>> 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)]

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

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)

>>> 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)]