[PYTHON] 루핑하는 동안 이전 / 다음 요소에 액세스하는 방법?

루핑하는 동안 이전 / 다음 요소에 액세스하는 방법?

for 루프로 반복하면서 목록 (또는 튜플 또는 다른 반복 가능)의 다음 또는 이전 요소에 액세스하는 방법이 있습니까?

l=[1,2,3]
for item in l:
    if item==2:
        get_previous(l,item)

해결법

1. ==============================

   1.발전기 기능으로 표현됨 :

   발전기 기능으로 표현됨 :

   def neighborhood(iterable):
       iterator = iter(iterable)
       prev_item = None
       current_item = next(iterator)  # throws StopIteration if empty.
       for next_item in iterator:
           yield (prev_item, current_item, next_item)
           prev_item = current_item
           current_item = next_item
       yield (prev_item, current_item, None)
   

   용법:

   for prev,item,next in neighborhood(l):
       print prev, item, next
   

2. ==============================

   2.한 가지 간단한 방법.

   한 가지 간단한 방법.

   l=[1,2,3]
   for i,j in zip(l, l[1:]):
       print i, j
   

3. ==============================

   3.

   l=[1,2,3]
   for i,item in enumerate(l):
       if item==2:
           get_previous=l[i-1]
           print get_previous
   
   >>>1
   

4. ==============================

   4.일부 컨텍스트가 필요한 생성자를 처리 할 때 종종 다음 유틸리티 함수를 사용하여 반복기에서 슬라이딩 창보기를 제공합니다.

   일부 컨텍스트가 필요한 생성자를 처리 할 때 종종 다음 유틸리티 함수를 사용하여 반복기에서 슬라이딩 창보기를 제공합니다.

   import collections, itertools
   
   def window(it, winsize, step=1):
       """Sliding window iterator."""
       it=iter(it)  # Ensure we have an iterator
       l=collections.deque(itertools.islice(it, winsize))
       while 1:  # Continue till StopIteration gets raised.
           yield tuple(l)
           for i in range(step):
               l.append(it.next())
               l.popleft()
   

   한 번에 N 개 항목의 시퀀스를 생성하여 단계를 넘깁니다. 예.

   >>> list(window([1,2,3,4,5],3))
   [(1, 2, 3), (2, 3, 4), (3, 4, 5)]
   

   앞 또는 뒤 값을 사용하지 않고 숫자를 처리해야하는 앞 / 뒤 상황에서 사용할 때는 None과 같은 적절한 값으로 시퀀스를 채울 수 있습니다.

   l= range(10)
   # Print adjacent numbers
   for cur, next in window(l + [None] ,2):
       if next is None: print "%d is the last number." % cur
       else: print "%d is followed by %d" % (cur,next)
   

5. ==============================

   5.템피 프로젝트에서 루퍼 유틸리티를 확인하십시오. 이전, 다음, 처음, 마지막 등과 같은 속성을 제공하는 루프 항목 주변의 래퍼 객체를 제공합니다.

   템피 프로젝트에서 루퍼 유틸리티를 확인하십시오. 이전, 다음, 처음, 마지막 등과 같은 속성을 제공하는 루프 항목 주변의 래퍼 객체를 제공합니다.

   루퍼 클래스의 소스 코드를 살펴보면 매우 간단합니다. 거기에는 다른 루프 도우미가 있지만 지금은 다른 어떤 것도 기억하지 못합니다.

   예:

   > easy_install Tempita
   > python
   >>> from tempita import looper
   >>> for loop, i in looper([1, 2, 3]):
   ...     print loop.previous, loop.item, loop.index, loop.next, loop.first, loop.last, loop.length, loop.odd, loop.even
   ... 
   None 1 0 2 True False 3 True 0
   1 2 1 3 False False 3 False 1
   2 3 2 None False True 3 True 0
   

6. ==============================

   6.나는 이것이 오래된 것을 알지만, 단순히 열거를 사용하지 않는 이유는 무엇입니까?

   나는 이것이 오래된 것을 알지만, 단순히 열거를 사용하지 않는 이유는 무엇입니까?

   l = ['adam', 'rick', 'morty', 'adam', 'billy', 'bob', 'wally', 'bob', 'jerry']
   
   for i, item in enumerate(l):
       if i == 0:
           previous_item = None
       else:
           previous_item = l[i - 1]
   
       if i == len(l) - 1:
           next_item = None
       else:
           next_item = l[i + 1]
   
       print('Previous Item:', previous_item)
       print('Item:', item)
       print('Next Item:', next_item)
       print('')
   
       pass
   

   이것을 실행하면 이전 및 다음 항목을 가져오고 목록의 항목을 반복하는 것에 신경 쓰지 않습니다.

7. ==============================

   7.나는 직설적 인 방법이 있다고 생각하지 않는다. 특히 iterable은 발전기가 될 수 없다. 인덱스를 루프 본문에 명시 적으로 전달하는 것에 의존하는 적절한 해결책이 있습니다.

   나는 직설적 인 방법이 있다고 생각하지 않는다. 특히 iterable은 발전기가 될 수 없다. 인덱스를 루프 본문에 명시 적으로 전달하는 것에 의존하는 적절한 해결책이 있습니다.

   for itemIndex, item in enumerate(l):
       if itemIndex>0:
           previousItem = l[itemIndex-1]
       else:
           previousItem = None 
   

   enumerate () 함수는 내장 함수입니다.

8. ==============================

   8.반복자는 next () 메서드 만 가지고 있으므로 앞으로 또는 뒤로 볼 수 없으므로 다음 항목 만 가져올 수 있습니다.

   반복자는 next () 메서드 만 가지고 있으므로 앞으로 또는 뒤로 볼 수 없으므로 다음 항목 만 가져올 수 있습니다.

   열거 (iterable)는 목록이나 튜플을 반복 할 때 유용 할 수 있습니다.

9. ==============================

   9.즉시 이전?

   즉시 이전?

   다음과 같은 뜻인가요?

   previous = None
   for item in someList:
       if item == target: break
       previous = item
   # previous is the item before the target
   

   n 개의 이전 항목이 필요하면 일종의 순환 대기열 크기 n으로이 작업을 수행 할 수 있습니다.

   queue = []
   for item in someList:
       if item == target: break
       queue .append( item )
       if len(queue ) > n: queue .pop(0)
   if len(queue ) < n: previous = None
   previous = previous[0]
   # previous is *n* before the target
   

10. ==============================

    10.당신이 iterables에서 작동하도록 솔루션을 원한다면, itertools의 워드 프로세서는 원하는 것을 정확하게 수행하는 방법을 가지고 있습니다 :

    당신이 iterables에서 작동하도록 솔루션을 원한다면, itertools의 워드 프로세서는 원하는 것을 정확하게 수행하는 방법을 가지고 있습니다 :

    import itertools
    
    def pairwise(iterable):
        "s -> (s0,s1), (s1,s2), (s2, s3), ..."
        a, b = itertools.tee(iterable)
        next(b, None)
        return zip(a, b)
    

    Python 2.x를 사용하는 경우 zip 대신 itertools.izip을 사용하십시오.

11. ==============================

    11.그다지 비단뱀이 아니지만 그것을 끝내고 간단합니다 :

    그다지 비단뱀이 아니지만 그것을 끝내고 간단합니다 :

    l=[1,2,3]
    for index in range(len(l)):
        if l[index]==2:
            l[index-1]
    

    해야 할 일 : 가장자리 보호

12. ==============================

    12.가장 간단한 방법은 항목에 대한 목록을 검색하는 것입니다.

    가장 간단한 방법은 항목에 대한 목록을 검색하는 것입니다.

    def get_previous(l, item):
        idx = l.find(item)
        return None if idx == 0 else l[idx-1]
    

    물론 목록에 고유 항목 만있는 경우에만 작동합니다. 다른 해결책은 다음과 같습니다.

    for idx in range(len(l)):
        item = l[idx]
        if item == 2:
            l[idx-1]
    

from https://stackoverflow.com/questions/323750/how-to-access-previous-next-element-while-for-looping by cc-by-sa and MIT license