Pares de una sola lista

A menudo, he encontrado la necesidad de procesar una lista por pares. Me preguntaba cuál sería la forma pitónica y eficiente de hacerlo, y encontré esto en Google:

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

Pensé que era lo suficientemente pitónico, pero después de una discusión reciente que involucró modismos versus eficiencia , decidí hacer algunas pruebas:

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

Estos fueron los resultados en mi computadora:

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

Si los estoy interpretando correctamente, eso debería significar que la implementación de listas, indexación de listas y división de listas en Python es muy eficiente. Es un resultado reconfortante e inesperado.

¿Existe otra forma "mejor" de recorrer una lista por parejas?

Tenga en cuenta que si la lista tiene un número impar de elementos, el último no estará en ninguno de los pares.

¿Cuál sería la forma correcta de garantizar que se incluyan todos los elementos?

Agregué estas dos sugerencias de las respuestas a las pruebas:

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

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

Estos son los resultados:

0.00159502029419 1.25745987892 1.25586485863
0.00222492218018 1.23795199394 1.23572707176

Resultados hasta ahora

Más pitónico y muy eficiente:

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

Más eficiente y muy pitónico:

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

Me tomó un momento asimilar que la primera respuesta usa dos iteradores mientras que la segunda usa uno solo.

Para tratar con secuencias con un número impar de elementos, la sugerencia ha sido aumentar la secuencia original agregando un elemento ( None) que se empareja con el último elemento anterior, algo con lo que se puede lograr itertools.izip_longest().

Finalmente

Tenga en cuenta que, en Python 3.x, se zip()comporta como itertools.izip()y itertools.izip() se ha ido.

Mi forma favorita de hacerlo:

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)

Cuando desee emparejar todos los elementos, obviamente es posible que necesite un valor de relleno:

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

Yo diría que su solución inicial pairs = zip(t[::2], t[1::2])es la mejor porque es más fácil de leer (y en Python 3, zipdevuelve automáticamente un iterador en lugar de una lista).

Para asegurarse de que todos los elementos estén incluidos, simplemente puede ampliar la lista en None.

Entonces, si la lista tiene un número impar de elementos, el último par será (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)]

Empiezo con un pequeño descargo de responsabilidad: no use el código a continuación. No es Pythonic en absoluto, escribí solo por diversión. Es similar a la pairwisefunción @ THC4k pero usa itery lambdacierra. No usa itertoolsmódulo y no es compatible fillvalue. Lo puse aquí porque alguien podría encontrarlo interesante:

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

En lo que respecta a la mayoría de Pythonic, diría que las recetas proporcionadas en los documentos fuente de Python (algunas de las cuales se parecen mucho a las respuestas que @JochenRitzel proporcionó) son probablemente su mejor opción;)

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)

En Python moderno, solo tiene que usarlo de zip_longest(*args, fillvalue=fillvalue) acuerdo con la página del documento correspondiente .

¿Existe otra forma "mejor" de recorrer una lista por parejas?

No puedo decirlo con certeza, pero lo dudo: cualquier otro recorrido incluiría más código Python que debe interpretarse. Las funciones integradas como zip () están escritas en C, que es mucho más rápido.

¿Cuál sería la forma correcta de garantizar que se incluyan todos los elementos?

Verifique la longitud de la lista y si es impar ( len(list) & 1 == 1), copie la lista y agregue un elemento.

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

Solo hazlo:

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

Aquí hay un ejemplo de cómo crear pares / piernas usando un generador. Los generadores están libres de límites de pila

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

Ejemplo:

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

Salida:

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

En caso de que alguien necesite el algoritmo de respuesta, aquí está:

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

Pero tenga en cuenta que su lista original también se reducirá a su último elemento, porque utilizó popen él.

>>> k
[4]