Önceki ve sonraki değerlere de erişen Python döngüsü

Önceki, mevcut ve sonraki öğelere erişerek bir nesne listesi üzerinde nasıl yineleme yapabilirim? Python'daki bu C / C ++ kodu gibi mi?

foo = somevalue;
previous = next = 0;

for (i=1; i<objects.length(); i++) {
    if (objects[i]==foo) {
        previous = objects[i-1];
        next = objects[i+1];
    }
}

Bu hile yapmalı.

foo = somevalue
previous = next_ = None
l = len(objects)
for index, obj in enumerate(objects):
    if obj == foo:
        if index > 0:
            previous = objects[index - 1]
        if index < (l - 1):
            next_ = objects[index + 1]

İşte enumeratefonksiyonla ilgili dokümanlar .

Çözümler şimdiye kadar sadece listelerle ilgileniyor ve çoğu listeyi kopyalıyor. Benim deneyimlerime göre bu pek çok kez mümkün değil.

Ayrıca, listede tekrarlanan öğelere sahip olabileceğiniz gerçeğiyle ilgilenmezler.

Sorunuzun başlığında " Bir döngü içindeki önceki ve sonraki değerler , ancak burada çoğu yanıtı bir döngü içinde çalıştırırsanız, bulmak için her öğede tüm listeyi tekrar yinelersiniz.

Bu yüzden yeni bir fonksiyon yarattım. itertoolsmodülü kullanarak yinelenebilir olanı böler ve dilimler ve önceki ve sonraki öğelerle birlikte tuples oluşturur. Kodunuzun yaptığı tam olarak bu değil, ancak bir göz atmaya değer çünkü muhtemelen sorununuzu çözebilir.

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)

Sonra bir döngüde kullanın ve içinde önceki ve sonraki öğelere sahip olacaksınız:

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

Sonuçlar:

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

Herhangi bir boyut listesiyle (çünkü listeyi kopyalamadığı için) ve herhangi bir yinelenebilir (dosyalar, kümeler, vb.) İle çalışacaktır. Bu şekilde, sırayı yineleyebilir ve önceki ve sonraki öğelerin döngü içinde kullanılabilir olmasını sağlayabilirsiniz. Sıradaki öğeyi tekrar aramaya gerek yoktur.

Kodun kısa bir açıklaması:

• tee giriş dizisi üzerinde 3 bağımsız yineleyici verimli bir şekilde oluşturmak için kullanılır
• chainiki diziyi bir diziye bağlar; tek unsur sırası eklemek için kullanılan [None]içinprevs
• isliceilki dışındaki tüm öğelerin bir sırasını oluşturmak chainiçin kullanılır , daha sonra birNone sonuna kadar
• Şimdi buna benzer 3 bağımsız sekans var some_iterable:
  • prevs: None, A, B, C, D, E
  • items: A, B, C, D, E
  • nexts: B, C, D, E, None
• son izipolarak 3 diziyi bir üçlü diziye dönüştürmek için kullanılır.

Not izipherhangi bir giriş sekansı bitkin aldığında son elemanı bu yüzden, durur prevsson öğe onun olacağını böyle öğe bulunsa - doğrudur göz ardı edilecektir, prev. Son öğeleri çıkarmaya çalışabiliriz, prevsancak izipdavranışları bu gereksiz

Ayrıca unutmayın tee, izip, isliceve chaingelen itertoolsmodül; Girdi dizileri üzerinde anında (tembel olarak) çalışırlar, bu da onları verimli kılar ve tüm dizinin herhangi bir zamanda bir kerede bellekte olması gerekliliğini doğurmaz.

İçinde python 3, içe aktarırken bir hata gösterecek izip, zipyerine kullanabilirsiniz izip. İthalat gerek yok zip, bu önceden tanımlanmıştır python 3- kaynağını

Bir liste anlayışı kullanarak, şu anki, önceki ve sonraki öğeleri içeren 3'lü bir demet döndür:

three_tuple = [(current, 
                my_list[idx - 1] if idx >= 1 else None, 
                my_list[idx + 1] if idx < len(my_list) - 1 else None) for idx, current in enumerate(my_list)]

Sadece yerleşik işlevleri kullandığı ve diğer ofsetlere kolayca genişletilebildiği için bunun nasıl ortaya çıkmadığını henüz bilmiyorum:

values = [1, 2, 3, 4]
offsets = [None] + values[:-1], values, values[1:] + [None]
for value in list(zip(*offsets)):
    print(value) # (previous, current, next)

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

Sınır hatası olmayan jeneratörlerin kullanıldığı bir sürümü burada bulabilirsiniz:

def trios(iterable):
    it = iter(iterable)
    try:
        prev, current = next(it), next(it)
    except StopIteration:
        return
    for next in it:
        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))

Lütfen sınır davranışının, kodunuzun aksine, ilk veya son öğede asla "foo" aramamamız olduğuna dikkat edin. Yine, sınır semantikleri garip ... ve kodunuzdan anlaşılması zor :)

python> = 2.5 için kısalık için koşullu ifadeler kullanma

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)

Buna bir çözüm arayan ve aynı zamanda öğeleri döngüye sokmak isteyen herkes için, aşağıda işe yarayabilir -

from collections import deque  

foo = ['A', 'B', 'C', 'D']

def prev_and_next(input_list):
    CURRENT = input_list
    PREV = deque(input_list)
    PREV.rotate(-1)
    PREV = list(PREV)
    NEXT = deque(input_list)
    NEXT.rotate(1)
    NEXT = list(NEXT)
    return zip(PREV, CURRENT, NEXT)

for previous_, current_, next_ in prev_and_next(foo):
    print(previous_, current_, next)

Jeneratör kullanmak oldukça basittir:

signal = ['→Signal value←']
def pniter( iter, signal=signal ):
    iA = iB = signal
    for iC in iter:
        if iB is signal:
            iB = iC
            continue
        else:
            yield iA, iB, iC
        iA = iB
        iB = iC
    iC = signal
    yield iA, iB, iC

if __name__ == '__main__':
    print('test 1:')
    for a, b, c in pniter( range( 10 )):
        print( a, b, c )
    print('\ntest 2:')
    for a, b, c in pniter([ 20, 30, 40, 50, 60, 70, 80 ]):
        print( a, b, c )
    print('\ntest 3:')
    cam = { 1: 30, 2: 40, 10: 9, -5: 36 }
    for a, b, c in pniter( cam ):
        print( a, b, c )
    for a, b, c in pniter( cam ):
        print( a, a if a is signal else cam[ a ], b, b if b is signal else cam[ b ], c, c if c is signal else cam[ c ])
    print('\ntest 4:')
    for a, b, c in pniter([ 20, 30, None, 50, 60, 70, 80 ]):
        print( a, b, c )
    print('\ntest 5:')
    for a, b, c in pniter([ 20, 30, None, 50, 60, 70, 80 ], ['sig']):
        print( a, b, c )
    print('\ntest 6:')
    for a, b, c in pniter([ 20, ['→Signal value←'], None, '→Signal value←', 60, 70, 80 ], signal ):
        print( a, b, c )

Yok ve sinyal değeriyle aynı değeri içeren testlerin hala çalıştığını unutmayın, çünkü sinyal değerinin kontrolü "eşittir" kullanır ve sinyal Python'un intern yapmadığı bir değerdir. Bununla birlikte, herhangi bir tekil işaretleyici değeri bir sinyal olarak kullanılabilir, bu da bazı durumlarda kullanıcı kodunu basitleştirebilir.

İki basit çözüm:

1. Hem önceki hem de sonraki değerler için değişkenlerin tanımlanması gerekiyorsa:

alist = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five']

prev = alist[0]
curr = alist[1]

for nxt in alist[2:]:
    print(f'prev: {prev}, curr: {curr}, next: {nxt}')
    prev = curr
    curr = nxt

Output[1]:
prev: Zero, curr: One, next: Two
prev: One, curr: Two, next: Three
prev: Two, curr: Three, next: Four
prev: Three, curr: Four, next: Five

2. Listedeki tüm değerlerin geçerli değer değişkeni tarafından çevrilmesi gerekiyorsa:

alist = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five']

prev = None
curr = alist[0]

for nxt in alist[1:] + [None]:
    print(f'prev: {prev}, curr: {curr}, next: {nxt}')
    prev = curr
    curr = nxt

Output[2]:
prev: None, curr: Zero, next: One
prev: Zero, curr: One, next: Two
prev: One, curr: Two, next: Three
prev: Two, curr: Three, next: Four
prev: Three, curr: Four, next: Five
prev: Four, curr: Five, next: None

indexListede nerede somevalueolduğunu bulmak için kullanabilirsiniz ve ardından gerektiğinde öncekini ve sonrakini alabilirsiniz:

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'

AFAIK bu oldukça hızlı olmalı, ancak ben test etmedim:

def iterate_prv_nxt(my_list):
    prv, cur, nxt = None, iter(my_list), iter(my_list)
    next(nxt, None)

    while True:
        try:
            if prv:
                yield next(prv), next(cur), next(nxt, None)
            else:
                yield None, next(cur), next(nxt, None)
                prv = iter(my_list)
        except StopIteration:
            break

Örnek kullanım:

>>> my_list = ['a', 'b', 'c']
>>> for prv, cur, nxt in iterate_prv_nxt(my_list):
...    print prv, cur, nxt
... 
None a b
a b c
b c None

Bunun işe yaradığını düşünüyorum ve karmaşık değil

array= [1,5,6,6,3,2]
for i in range(0,len(array)):
    Current = array[i]
    Next = array[i+1]
    Prev = array[i-1]

Çok C / C ++ tarzı çözüm:

    foo = 5
    objectsList = [3, 6, 5, 9, 10]
    prev = nex = 0
    
    currentIndex = 0
    indexHigher = len(objectsList)-1 #control the higher limit of list
    
    found = False
    prevFound = False
    nexFound = False
    
    #main logic:
    for currentValue in objectsList: #getting each value of list
        if currentValue == foo:
            found = True
            if currentIndex > 0: #check if target value is in the first position   
                prevFound = True
                prev = objectsList[currentIndex-1]
            if currentIndex < indexHigher: #check if target value is in the last position
                nexFound = True
                nex = objectsList[currentIndex+1]
            break #I am considering that target value only exist 1 time in the list
        currentIndex+=1
    
    if found:
        print("Value %s found" % foo)
        if prevFound:
            print("Previous Value: ", prev)
        else:
            print("Previous Value: Target value is in the first position of list.")
        if nexFound:
            print("Next Value: ", nex)
        else:
            print("Next Value: Target value is in the last position of list.")
    else:
        print("Target value does not exist in the list.")

Pythonic ve zarif yol:

objects = [1, 2, 3, 4, 5]
value = 3
if value in objects:
   index = objects.index(value)
   previous_value = objects[index-1]
   next_value = objects[index+1] if index + 1 < len(objects) else None