Ciclo Python che accede anche ai valori precedenti e successivi

Come posso iterare su un elenco di oggetti, accedendo agli elementi precedenti, correnti e successivi? Ti piace questo codice C / C ++, in Python?

foo = somevalue;
previous = next = 0;

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

Questo dovrebbe fare il trucco.

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]

Ecco i documenti sulla enumeratefunzione.

Le soluzioni fino ad ora riguardano solo gli elenchi e la maggior parte sta copiando l'elenco. Nella mia esperienza molte volte non è possibile.

Inoltre, non si occupano del fatto che puoi avere elementi ripetuti nell'elenco.

Il titolo della tua domanda dice " Valori precedenti e successivi all'interno di un ciclo ", ma se esegui la maggior parte delle risposte qui all'interno di un ciclo, finirai per iterare di nuovo l'intero elenco su ogni elemento per trovarlo.

Quindi ho appena creato una funzione che. utilizzando il itertoolsmodulo, divide e affetta l'iterabile e genera tuple con gli elementi precedente e successivo insieme. Non esattamente quello che fa il tuo codice, ma vale la pena dare un'occhiata, perché probabilmente può risolvere il tuo problema.

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)

Quindi usalo in un ciclo e avrai gli elementi precedenti e successivi in ​​esso:

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

I risultati:

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

Funzionerà con qualsiasi elenco di dimensioni (perché non copia l'elenco) e con qualsiasi iterabile (file, set, ecc.). In questo modo puoi semplicemente iterare sulla sequenza e avere gli elementi precedenti e successivi disponibili all'interno del ciclo. Non è necessario cercare di nuovo l'elemento nella sequenza.

Una breve spiegazione del codice:

• tee viene utilizzato per creare in modo efficiente 3 iteratori indipendenti sulla sequenza di input
• chaincollega due sequenze in una; è usato qui per aggiungere una sequenza [None]di un singolo elemento aprevs
• isliceviene utilizzato per creare una sequenza di tutti gli elementi tranne il primo, quindi chainviene utilizzato per aggiungere un Nonealla sua fine
• Ora ci sono 3 sequenze indipendenti basate su some_iterablequesto aspetto come:
  • prevs: None, A, B, C, D, E
  • items: A, B, C, D, E
  • nexts: B, C, D, E, None
• infine izipè usato per cambiare 3 sequenze in una sequenza di terzine.

Nota che si izipinterrompe quando una sequenza di input viene esaurita, quindi l'ultimo elemento di prevsverrà ignorato, il che è corretto: non esiste un elemento tale che l'ultimo elemento sarebbe il suo prev. Potremmo provare a togliere gli ultimi elementi da prevsmaizip il comportamento di rende ridondante

Si noti inoltre che tee, izip, islicee chainprovengono dal itertoolsmodulo; agiscono sulle loro sequenze di input al volo (pigramente), il che li rende efficienti e non introduce la necessità di avere l'intera sequenza in memoria contemporaneamente e in qualsiasi momento.

In python 3, mostrerà un errore durante l'importazione izip, puoi usare al zipposto di izip. Non è necessario importare zip, è predefinito in python 3- source

Usando una lista di comprensione, restituisci una 3-tupla con gli elementi corrente, precedente e successivo:

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

Non so come non sia ancora venuto fuori poiché utilizza solo funzioni integrate ed è facilmente estendibile ad altri offset:

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)

Ecco una versione che utilizza generatori senza errori di confine:

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

Si noti che il comportamento limite è che non cerchiamo mai "foo" nel primo o nell'ultimo elemento, a differenza del codice. Di nuovo, la semantica del confine è strana ... e difficile da capire dal tuo codice :)

usando espressioni condizionali per concisione per 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)

Per chiunque cerchi una soluzione a questo problema con anche il desiderio di ciclare gli elementi, di seguito potrebbe funzionare:

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)

Utilizzando i generatori, è abbastanza semplice:

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 )

Si noti che i test che includono None e lo stesso valore del valore del segnale funzionano ancora, perché il controllo del valore del segnale utilizza "is" e il segnale è un valore che Python non integra. Qualsiasi valore di marcatore singleton può essere utilizzato come segnale, tuttavia, il che potrebbe semplificare il codice utente in alcune circostanze.

Due semplici soluzioni:

1. Se è necessario definire variabili sia per i valori precedenti che per quelli successivi:

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. Se tutti i valori nell'elenco devono essere attraversati dalla variabile del valore corrente:

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

Puoi semplicemente usare indexl'elenco per trovare dove si somevaluetrova e quindi ottenere il precedente e il successivo secondo necessità:

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'

Per quanto ne so, dovrebbe essere abbastanza veloce, ma non l'ho testato:

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

Utilizzo di esempio:

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

Penso che funzioni e non sia complicato

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]

Soluzione in stile C / C ++ molto:

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

Modo pitonico ed elegante:

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