Iterar una lista como par (actual, siguiente) en Python

A veces necesito iterar una lista en Python mirando el elemento "actual" y el elemento "siguiente". Hasta ahora lo he hecho con un código como:

for current, next in zip(the_list, the_list[1:]):
    # Do something

Esto funciona y hace lo que espero, pero ¿hay alguna forma más idiomática o eficiente de hacer lo mismo?

Aquí hay un ejemplo relevante de los documentos del módulo itertools :

import itertools
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return zip(a, b)   

Para Python 2, necesita en itertools.iziplugar de zip:

import itertools
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return itertools.izip(a, b)

Cómo funciona esto:

Primero, se crean dos iteradores paralelos ay b(la tee()llamada), ambos apuntando al primer elemento del iterable original. El segundo iterador, bse mueve 1 paso adelante (la next(b, None)) llamada). En este punto aapunta a s0 y bapunta a s1. Tanto ay bpuede atravesar el iterador original de forma independiente - la función IZIP toma los dos iteradores y hace que los pares de elementos devueltos, avanzando dos iteradores al mismo ritmo.

Una advertencia: la tee()función produce dos iteradores que pueden avanzar independientemente uno del otro, pero tiene un costo. Si uno de los iteradores avanza más que el otro, entonces tee() necesita mantener los elementos consumidos en la memoria hasta que el segundo iterador los consuma también (no puede 'rebobinar' el iterador original). Aquí no importa porque un iterador está solo un paso por delante del otro, pero en general es fácil usar mucha memoria de esta manera.

Y como tee()puede tomar un nparámetro, esto también se puede usar para más de dos iteradores paralelos:

def threes(iterator):
    "s -> (s0,s1,s2), (s1,s2,s3), (s2, s3,4), ..."
    a, b, c = itertools.tee(iterator, 3)
    next(b, None)
    next(c, None)
    next(c, None)
    return zip(a, b, c)

¡Ruede el suyo!

def pairwise(iterable):
    it = iter(iterable)
    a = next(it, None)

    for b in it:
        yield (a, b)
        a = b

Como en the_list[1:]realidad crea una copia de toda la lista (excluyendo su primer elemento), y zip()crea una lista de tuplas inmediatamente cuando se llama, en total se crean tres copias de su lista. Si su lista es muy grande, puede preferir

from itertools import izip, islice
for current_item, next_item in izip(the_list, islice(the_list, 1, None)):
    print(current_item, next_item)

que no copia la lista en absoluto.

Solo estoy publicando esto, estoy muy sorprendido de que nadie haya pensado en enumerate ().

for (index, thing) in enumerate(the_list):
    if index < len(the_list):
        current, next_ = thing, the_list[index + 1]
        #do something

Iterar por índice puede hacer lo mismo:

#!/usr/bin/python
the_list = [1, 2, 3, 4]
for i in xrange(len(the_list) - 1):
    current_item, next_item = the_list[i], the_list[i + 1]
    print(current_item, next_item)

Salida:

(1, 2)
(2, 3)
(3, 4)

Esta es ahora una importación simple a partir del 16 de mayo de 2020

from more_itertools import pairwise
for current, next in pairwise(your_iterable):
  print(f'Current = {current}, next = {nxt}')

Documentos para más herramientas de iterto De manera este código es el mismo que en las otras respuestas, pero prefiero las importaciones cuando están disponibles.

Si aún no lo tiene instalado, entonces: pip install more-itertools

Ejemplo

Por ejemplo, si tuviera la secuencia de fibbonnacci, podría calcular las proporciones de pares posteriores como:

from more_itertools import pairwise
fib= [1,1,2,3,5,8,13]
for current, nxt in pairwise(fib):
    ratio=current/nxt
    print(f'Curent = {current}, next = {nxt}, ratio = {ratio} ')

Pares de una lista usando una comprensión de lista

the_list = [1, 2, 3, 4]
pairs = [[the_list[i], the_list[i + 1]] for i in range(len(the_list) - 1)]
for [current_item, next_item] in pairs:
    print(current_item, next_item)

Salida:

(1, 2)
(2, 3)
(3, 4)

Estoy realmente sorprendido de que nadie haya mencionado la solución general más breve, simple y más importante :

Python 3:

from itertools import islice

def n_wise(iterable, n):
    return zip(*(islice(iterable, i, None) for i in range(n)))

Python 2:

from itertools import izip, islice

def n_wise(iterable, n):
    return izip(*(islice(iterable, i, None) for i in xrange(n)))

Funciona para la iteración por pares pasando n=2, pero puede manejar cualquier número mayor:

>>> for a, b in n_wise('Hello!', 2):
>>>     print(a, b)
H e
e l
l l
l o
o !

>>> for a, b, c, d in n_wise('Hello World!', 4):
>>>     print(a, b, c, d)
H e l l
e l l o
l l o
l o   W
o   W o
  W o r
W o r l
o r l d
r l d !

Una solución básica:

def neighbors( list ):
  i = 0
  while i + 1 < len( list ):
    yield ( list[ i ], list[ i + 1 ] )
    i += 1

for ( x, y ) in neighbors( list ):
  print( x, y )

code = '0016364ee0942aa7cc04a8189ef3'
# Getting the current and next item
print  [code[idx]+code[idx+1] for idx in range(len(code)-1)]
# Getting the pair
print  [code[idx*2]+code[idx*2+1] for idx in range(len(code)/2)]