পাইথন লুপটি পূর্ববর্তী এবং পরবর্তী মানগুলিকেও অ্যাক্সেস করে

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তার শেষ
এই some_iterableচেহারাটির উপর ভিত্তি করে 3 টি স্বতন্ত্র সিকোয়েন্স রয়েছে :
- prevs: None, A, B, C, D, E
- items: A, B, C, D, E
- nexts: B, C, D, E, None
অবশেষে izip3 টি সিকোয়েন্সকে ট্রিপল্টের এক সিকোয়েন্সে পরিবর্তন করতে ব্যবহৃত হয়।

নোট করুন যে 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))

দয়া করে লক্ষ্য করুন যে সীমাবদ্ধ আচরণটি হ'ল আমরা আপনার কোডের বিপরীতে প্রথম বা শেষ উপাদানটিতে কখনই "foo" সন্ধান করি না। আবার, সীমানা শব্দার্থবিজ্ঞানগুলি অদ্ভুত ... এবং আপনার কোড থেকে অনুধাবন করা শক্ত :)

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

আফাইক এটিকে দ্রুত হওয়া উচিত, তবে আমি এটি পরীক্ষা করিনি:

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