पायथन लूप जो पिछले और अगले मूल्यों तक पहुंचता है

Question 1

मैं पिछली, वर्तमान और अगली वस्तुओं तक पहुँचने वाली वस्तुओं की सूची पर कैसे पुनरावृति कर सकता हूँ? इस सी / सी ++ कोड की तरह, पायथन में?

foo = somevalue;
previous = next = 0;

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

Question 2

यह काम कर जाना चाहिए।

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]

यहाँ enumerateफ़ंक्शन पर डॉक्स दिए गए हैं।

Question 3

अब तक के समाधान केवल सूचियों से संबंधित हैं, और अधिकांश सूची की प्रतिलिपि बना रहे हैं। मेरे अनुभव में बहुत बार ऐसा संभव नहीं है।

इसके अलावा, वे इस तथ्य से नहीं निपटते हैं कि आपके पास सूची में बार-बार तत्व हो सकते हैं।

आपके प्रश्न का शीर्षक " एक लूप के अंदर और अगले मूल्य " कहता है , लेकिन यदि आप एक लूप के अंदर अधिकांश उत्तर यहां चलाते हैं, तो आप इसे खोजने के लिए प्रत्येक तत्व पर फिर से पूरी सूची पर पुनरावृत्ति करेंगे।

इसलिए मैंने अभी एक फंक्शन बनाया है। 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 स्वतंत्र पुनरावृत्तियों को बनाने के लिए उपयोग किया जाता है
chainएक में दो अनुक्रम लिंक; इसका उपयोग यहां एकल-तत्व अनुक्रम [None]को जोड़ने के लिए किया जाता हैprevs
isliceपहले को छोड़कर सभी तत्वों का अनुक्रम बनाने के लिए उपयोग किया जाता है, फिर chainइसका उपयोग Noneइसके अंत में करने के लिए किया जाता है
अब 3 स्वतंत्र क्रम हैं some_iterableजो इस तरह दिखते हैं:
- prevs: None, A, B, C, D, E
- items: A, B, C, D, E
- nexts: B, C, D, E, None
अंत izipमें 3 अनुक्रमों को तीन अनुक्रमों में बदलने के लिए उपयोग किया जाता है।

ध्यान दें कि izipजब कोई इनपुट अनुक्रम समाप्त हो जाता है, तो अंतिम तत्व को prevsनजरअंदाज कर दिया जाएगा, जो सही है - ऐसा कोई तत्व नहीं है जो अंतिम तत्व होगा prev। हम आखिरी तत्वों को हटाने की कोशिश कर सकते हैं, prevsलेकिन izipयह व्यवहार उस बेमानी बना देता है

यह भी ध्यान रखें कि tee, izip, isliceऔर chainसे आते हैं itertoolsमॉड्यूल; वे अपने इनपुट सीक्वेंस ऑन-द-फ्लाई (लज़ीली) पर काम करते हैं, जो उन्हें कुशल बनाता है और किसी भी समय एक बार में पूरे अनुक्रम को मेमोरी में रखने की आवश्यकता का परिचय नहीं देता है।

में python 3, यह एक त्रुटि है, जबकि आयात करने दिखाएगा izip, तो आप उपयोग कर सकते हैं zipके बजाय izip। आयात करने की आवश्यकता नहीं है zip, यह पूर्वनिर्धारित है python 3- स्रोत

Question 4

सूची समझ का उपयोग करते हुए, वर्तमान, पिछले और अगले तत्वों के साथ एक 3-टपल लौटें:

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

Question 5

मुझे नहीं पता कि यह अभी तक कैसे सामने नहीं आया क्योंकि यह केवल अंतर्निहित कार्यों का उपयोग करता है और आसानी से अन्य कार्यालयों के लिए विस्तार योग्य है:

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)

Question 6

यहाँ कोई सीमा नहीं त्रुटियों के साथ जनरेटर का उपयोग कर एक संस्करण है:

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

कृपया ध्यान दें कि सीमा व्यवहार यह है कि हम आपके कोड के विपरीत, पहले या अंतिम तत्व में "फू" की तलाश नहीं करते हैं। फिर, सीमा शब्दार्थ अजीब हैं ... और अपने कोड से थाह लेना कठिन हैं :)

Question 7

अजगर के लिए संक्षिप्तता के लिए सशर्त अभिव्यक्ति का उपयोग करना> = 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)

Question 8

तत्वों को चक्रित करने के इच्छुक लोगों के लिए इसका समाधान ढूंढने वाले किसी व्यक्ति के लिए, नीचे काम कर सकते हैं -

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)

Question 9

जनरेटर का उपयोग करना, यह काफी सरल है:

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 )

ध्यान दें कि परीक्षण जिसमें कोई भी शामिल नहीं है और सिग्नल मूल्य के समान मूल्य अभी भी काम करते हैं, क्योंकि सिग्नल मूल्य का उपयोग "चेक" है और सिग्नल एक ऐसा मूल्य है जो पायथन इंटर्न नहीं करता है। किसी भी सिंगलटन मार्कर मूल्य को एक संकेत के रूप में इस्तेमाल किया जा सकता है, हालांकि, जो कुछ परिस्थितियों में उपयोगकर्ता कोड को सरल बना सकता है।

Question 10

दो सरल उपाय:

यदि पिछले और अगले दोनों मानों के चर को परिभाषित किया जाना है:

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

यदि सूची के सभी मानों को वर्तमान मान चर द्वारा ट्रेस किया जाना है:

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

Question 11

आप indexसूची का उपयोग केवल यह जानने के लिए कर सकते हैं कि कहाँ somevalueहै और फिर आवश्यकतानुसार पिछला और अगला प्राप्त करें:


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'

Question 12

AFAIK यह बहुत तेज़ होना चाहिए, लेकिन मैंने इसका परीक्षण नहीं किया:

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

उदाहरण उपयोग:

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

Question 13

मुझे लगता है कि यह काम करता है और जटिल नहीं

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]

Question 14

बहुत सी / सी ++ शैली समाधान:

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

Question 15

पायथोनिक और सुरुचिपूर्ण तरीका:

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