Итерировать список как пару (текущий, следующий) в Python

Иногда мне нужно перебирать список в Python, глядя на «текущий» элемент и «следующий» элемент. До сих пор я делал это с помощью кода вроде:

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

Это работает и делает то, что я ожидаю, но есть ли более идиоматичный или эффективный способ сделать то же самое?

Вот соответствующий пример из документации модуля 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)   

Для Python 2 itertools.izipвместо 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)

Как это работает:

Сначала создаются два параллельных итератора aи b( tee()вызов), указывающие на первый элемент исходного итератора. Второй итератор bперемещается на 1 шаг вперед ( next(b, None)вызов). В этот момент aуказывает на s0 и bуказывает на s1. Оба aи bмогут обходить исходный итератор независимо - функция izip берет два итератора и создает пары из возвращенных элементов, продвигая оба итератора с одинаковой скоростью.

Одно предостережение: tee()функция создает два итератора, которые могут продвигаться независимо друг от друга, но за это приходится платить. Если один из итераторов продвигается дальше, чем другой, то tee() потребляемые элементы должны оставаться в памяти до тех пор, пока второй итератор тоже их не поглотит (он не может «перемотать» исходный итератор). Здесь это не имеет значения, потому что один итератор всего на 1 шаг впереди другого, но в целом таким образом легко использовать много памяти.

И поскольку tee()может принимать nпараметр, его также можно использовать для более чем двух параллельных итераторов:

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)

Брось свой!

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

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

Поскольку the_list[1:]фактически создает копию всего списка (за исключением его первого элемента) и zip()создает список кортежей сразу при вызове, в общей сложности создаются три копии вашего списка. Если ваш список очень большой, вы можете предпочесть

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

который вообще не копирует список.

Я просто выкладываю это и очень удивлен, что никто не подумал о enumerate ().

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

Итерация по индексу может сделать то же самое:

#!/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)

Вывод:

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

Теперь это простой импорт с 16 мая 2020 г.

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

Документы для more-itertools Под капотом этот код такой же, как и в других ответах, но я предпочитаю импорт, когда он доступен.

Если он еще не установлен, выполните следующие действия: pip install more-itertools

пример

Например, если у вас есть последовательность Фиббонначчи, вы можете рассчитать отношения последующих пар как:

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} ')

Пары из списка с использованием понимания списка

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)

Вывод:

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

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

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

Он работает для попарной итерации путем передачи n=2, но может обрабатывать любое большее число:

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

Базовое решение:

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