Python - Предыдущие и следующие значения внутри цикла

использование условных выражений для краткости для python> = 2.5

def prenext(l,v) : 
   i=l.index(v)
   return l[i-1] if i>0 else None,l[i+1] if i<len(l)-1 else None


# example
x=range(10)
prenext(x,3)
>>> (2,4)
prenext(x,0)
>>> (None,2)
prenext(x,9)
>>> (8,None)

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

Кроме того, они не учитывают тот факт, что в списке могут быть повторяющиеся элементы.

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

Итак, я только что создал функция это. с помощью модуля itertools разделяет и нарезает итерируемый объект, а также генерирует кортежи с предыдущим и следующим элементами вместе. Не совсем то, что делает ваш код, но на него стоит взглянуть, потому что это, вероятно, может решить вашу проблему.

from itertools import tee, islice, chain, izip

def previous_and_next(some_iterable):
    prevs, items, nexts = tee(some_iterable, 3)
    prevs = chain([None], prevs)
    nexts = chain(islice(nexts, 1, None), [None])
    return izip(prevs, items, nexts)

Затем используйте его в цикле, и в нем будут предыдущий и следующий элементы:

mylist = ['banana', 'orange', 'apple', 'kiwi', 'tomato']

for previous, item, nxt in previous_and_next(mylist):
    print "Item is now", item, "next is", nxt, "previous is", previous

Результаты:

Item is now banana next is orange previous is None
Item is now orange next is apple previous is banana
Item is now apple next is kiwi previous is orange
Item is now kiwi next is tomato previous is apple
Item is now tomato next is None previous is kiwi

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

Краткое объяснение кода:

• tee используется для эффективного создания 3 независимых итераторов по входной последовательности
• цепочка связывает два последовательности в одну; здесь он используется для добавления одноэлементной последовательности [None] в prevs
• islice используется для создания последовательности всех элементов, кроме первого,
  • предыдущие : Нет, A, B, C, D, E
  • элементы : A, B, C, D, E
  • следующие : B, C, D, E, None
• наконец izip используется для преобразования 3 последовательностей в одну последовательность триплетов.

Обратите внимание, что izip останавливается при любом входная последовательность исчерпана, поэтому последний элемент prevs будет проигнорирован, что правильно - нет такого элемента, который был бы последним элементом prev . Мы могли бы попытаться удалить последние элементы из prevs , но поведение izip делает это лишним

Также обратите внимание, что tee , izip , islice и цепочка происходят из модуля itertools ; они работают со своими входными последовательностями на лету (лениво), что делает их эффективными и не требует одновременного хранения всей последовательности в памяти.

В python 3 при импорте izip будет отображаться ошибка. ], вы можете использовать zip вместо izip . Нет необходимости импортировать zip , он предопределен в python 3 - источник

Вот версия с использованием генераторов без граничных ошибок:

def trios(input):
    input = iter(input) # make sure input is an iterator
    try:
        prev, current = input.next(), input.next()
    except StopIteration:
        return
    for next in input:
        yield prev, current, next
        prev, current = current, next

def find_prev_next(objects, foo):
    prev, next = 0, 0
    for temp_prev, current, temp_next in trios(objects):
        if current == foo:
            prev, next = temp_prev, temp_next
    return prev, next

print find_prev_next(range(10), 1)
print find_prev_next(range(10), 0)
print find_prev_next(range(10), 10)
print find_prev_next(range(0), 10)
print find_prev_next(range(1), 10)
print find_prev_next(range(2), 10)

Обратите внимание, что граничное поведение состоит в том, что мы никогда не ищем «foo» в первом или последнем элементе, в отличие от вашего кода. Опять же, семантика границ странная ... и ее трудно понять из вашего кода :)

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

def find_prev_next(elem, elements):
    previous, next = None, None
    index = elements.index(elem)
    if index > 0:
        previous = elements[index -1]
    if index < (len(elements)-1):
        next = elements[index +1]
    return previous, next


foo = 'three'
list = ['one','two','three', 'four', 'five']

previous, next = find_prev_next(foo, list)

print previous # should print 'two'
print next # should print 'four'