Как получить доступ к предыдущему / следующему элементу в цикле for?

Итераторы имеют только метод next (), поэтому вы не можете смотреть вперед или назад, вы можете получить только следующий элемент.

enumerate (iterable) может быть полезен, если вы выполняете итерацию списка или кортежа.

Самый простой способ - найти элемент в списке:

def get_previous(l, item):
    idx = l.find(item)
    return None if idx == 0 else l[idx-1]

Конечно, это работает, только если список содержит только уникальные элементы. Другое решение:

for idx in range(len(l)):
    item = l[idx]
    if item == 2:
        l[idx-1]

Я не думаю, что есть простой способ, особенно потому, что итерация может быть генератор (без возврата). Вы можете сделать это с помощью последовательности, передав индекс элемента в тело цикла:

for index, item in enumerate(l):
    if index > 0:
        previous_item = l[index - 1]
    else:
        previous_item = None 

Функция enumerate() является встроенной.

Выражается как функция генератора:

def neighborhood(iterable):
    iterator = iter(iterable)
    prev_item = None
    current_item = next(iterator)  # throws StopIteration if empty.
    for next_item in iterator:
        yield (prev_item, current_item, next_item)
        prev_item = current_item
        current_item = next_item
    yield (prev_item, current_item, None)

Использование:

for prev,item,next in neighborhood(l):
    print prev, item, next

При работе с генераторами, где вам нужен какой-то контекст, я часто использую приведенную ниже служебную функцию, чтобы отобразить скользящее окно на итераторе:

import collections, itertools

def window(it, winsize, step=1):
    """Sliding window iterator."""
    it=iter(it)  # Ensure we have an iterator
    l=collections.deque(itertools.islice(it, winsize))
    while 1:  # Continue till StopIteration gets raised.
        yield tuple(l)
        for i in range(step):
            l.append(it.next())
            l.popleft()

Он будет генерировать представление последовательности N элементов за раз, сдвигая шаг вперед. например.

>>> list(window([1,2,3,4,5],3))
[(1, 2, 3), (2, 3, 4), (3, 4, 5)]

При использовании в ситуациях, когда вам также нужно иметь дело с числами без следующего или предыдущего значения, вы можете дополнить последовательность соответствующим значением, например None.

l= range(10)
# Print adjacent numbers
for cur, next in window(l + [None] ,2):
    if next is None: print "%d is the last number." % cur
    else: print "%d is followed by %d" % (cur,next)

Сразу предыдущий?

Вы имеете в виду следующее, правда?

previous = None
for item in someList:
    if item == target: break
    previous = item
# previous is the item before the target

Если вам нужны предыдущие элементы п, вы можете сделать это с помощью своего рода циклической очереди размером п.

queue = []
for item in someList:
    if item == target: break
    queue .append( item )
    if len(queue ) > n: queue .pop(0)
if len(queue ) < n: previous = None
previous = previous[0]
# previous is *n* before the target

l = [1, 2, 3]
for i, item in enumerate(l):
    if item == 2:
        previous = l[i - 1]
        print(previous)

Выход:

1

Это завершится и вернет последний элемент в списке, если элемент, который вы ищете, является первым элементом в списке. Другими словами, изменение третьей строки на if item == 1: в приведенном выше коде приведет к печати 3.

Проверьте утилиту петлителя из Проект Темпита. Он дает вам объект-оболочку вокруг элемента цикла, который предоставляет такие свойства, как предыдущий, следующий, первый, последний и т. д.

Взгляните на исходный код для класса лупера, это довольно просто. Существуют и другие такие помощники цикла, но я не могу вспомнить других прямо сейчас.

Пример:

> easy_install Tempita
> python
>>> from tempita import looper
>>> for loop, i in looper([1, 2, 3]):
...     print loop.previous, loop.item, loop.index, loop.next, loop.first, loop.last, loop.length, loop.odd, loop.even
... 
None 1 0 2 True False 3 True 0
1 2 1 3 False False 3 False 1
2 3 2 None False True 3 True 0

Не очень питонический, но справляется и прост:

l=[1,2,3]
for index in range(len(l)):
    if l[index]==2:
        l[index-1]

ЧТО ДЕЛАТЬ: защитить края

Я знаю, что это старый, но почему бы просто не использовать enumerate?

l = ['adam', 'rick', 'morty', 'adam', 'billy', 'bob', 'wally', 'bob', 'jerry']

for i, item in enumerate(l):
    if i == 0:
        previous_item = None
    else:
        previous_item = l[i - 1]

    if i == len(l) - 1:
        next_item = None
    else:
        next_item = l[i + 1]

    print('Previous Item:', previous_item)
    print('Item:', item)
    print('Next Item:', next_item)
    print('')

    pass

Если вы запустите это, вы увидите, что он захватывает предыдущие и следующие элементы и не заботится о повторяющихся элементах в списке.

l = [1, 2, 3]

for i, j in zip(l, l[1:]):
    print(i, j)

Если вы хотите, чтобы решение работало с итерациями, у itertools документация есть рецепт, который делает именно то, что вы хотите, используя itertools.tee():

import itertools

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

Я знаю, что это старый вопрос, но я считаю важным показать простое решение, которое также работает с генераторами и другими типами итераций, в отличие от большинства ответов, работающих только со списками, такими как объекты. Это несколько похоже на ответ Брайана и решение здесь: https://www.programcreek.com/python/example/1754/itertools.tee

import itertools

iter0, iter1 = itertools.tee(iterable)

for item, next_item in itertools.zip_longest(
    iter0,
    itertools.islice(iter1, 1, None)
):

    do_something(item, next_item)

В качестве альтернативы вызов next на второй итерации (если вы уверены, что у нее есть хотя бы один элемент):

import itertools

iter0, iter1 = itertools.tee(iterable)
_ = next(iter1)

for item, next_item in itertools.zip_longest(iter0, iter1):

    do_something(item, next_item)