복붙노트

[PYTHON] 목록에서 최대 값의 모든 위치를 찾는 방법?

PYTHON

목록에서 최대 값의 모든 위치를 찾는 방법?

목록이 있습니다.

a = [32, 37, 28, 30, 37, 25, 27, 24, 35, 55, 23, 31, 55, 21, 40, 18, 50,
             35, 41, 49, 37, 19, 40, 41, 31]

최대 요소는 55입니다 (9 및 12 위치의 두 요소)

최대 값이 어느 위치에 있는지 찾아야합니다. 도와주세요.

해결법

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

    1.

    >>> m = max(a)
    >>> [i for i, j in enumerate(a) if j == m]
    [9, 12]
    
  2. ==============================

    2.

    a.index(max(a))
    

    리스트 a의 가장 큰 값을 갖는 요소의 첫 번째 인스턴스의 인덱스를 알려줍니다.

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

    3.선택한 답변 (및 대부분의 다른 답변)은 목록을 통해 최소한 두 번 통과해야합니다. 긴 목록에 더 좋은 선택 일 수있는 원 패스 솔루션이 있습니다.

    선택한 답변 (및 대부분의 다른 답변)은 목록을 통해 최소한 두 번 통과해야합니다. 긴 목록에 더 좋은 선택 일 수있는 원 패스 솔루션이 있습니다.

    편집 됨 : @ John Machin이 지적한 두 가지 결점을 해결하기 위해. (2) 나는 각 조건의 발생 확률과 전임자가 허용 한 추론에 근거하여 시험을 최적화하려고 시도했다. 가능한 모든 경우에 대해 작동하는 max_val 및 max_indices에 대한 적절한 초기화 값을 알아내는 일이 약간 까다 롭습니다. 특히 최대 값이 목록의 첫 번째 값인 경우에는 특히 그렇습니다.

    def maxelements(seq):
        ''' Return list of position(s) of largest element '''
        max_indices = []
        if seq:
            max_val = seq[0]
            for i,val in ((i,val) for i,val in enumerate(seq) if val >= max_val):
                if val == max_val:
                    max_indices.append(i)
                else:
                    max_val = val
                    max_indices = [i]
    
        return max_indices
    
  4. ==============================

    4.나는 다음과 같은 것을 생각해 냈고 최대, 최소 및 기타 기능이 다음과 같은 목록에서 볼 수있는 것처럼 작동합니다.

    나는 다음과 같은 것을 생각해 냈고 최대, 최소 및 기타 기능이 다음과 같은 목록에서 볼 수있는 것처럼 작동합니다.

    따라서 다음 예제 목록을 고려하여 목록의 최대 위치를 찾으십시오.

    >>> a = [3,2,1, 4,5]
    

    발전기를 사용하여 열거하고 주물 만들기

    >>> list(enumerate(a))
    [(0, 3), (1, 2), (2, 1), (3, 4), (4, 5)]
    

    이 시점에서 max의 위치를 ​​추출 할 수 있습니다.

    >>> max(enumerate(a), key=(lambda x: x[1]))
    (4, 5)
    

    위의 내용은 최대 값이 4의 위치에 있고 값이 5임을 나타냅니다.

    보시다시피, 핵심 인수에서 람다를 적절하게 정의하여 모든 반복 가능한 객체에 대한 최대 값을 찾을 수 있습니다.

    나는 그것이 그것이 기여하기를 바란다.

    PD : @PaulOyster가 의견에서 언급했듯이. Python 3.x를 사용하면 min 및 max를 사용하면 인수가 빈 목록 인 경우 ValueError 발생 예외를 피하는 새 키워드 기본값을 사용할 수 있습니다. max (enumerate (list), key = (lambda x : x [1]), default = -1)

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

    5.@martineau에서 인용 한 @ SilentGhost-beating 성능을 재현 할 수 없습니다. 다음은 비교를위한 노력입니다.

    @martineau에서 인용 한 @ SilentGhost-beating 성능을 재현 할 수 없습니다. 다음은 비교를위한 노력입니다.

    === maxelements.py ===

    a = [32, 37, 28, 30, 37, 25, 27, 24, 35, 55, 23, 31, 55, 21, 40, 18, 50,
                 35, 41, 49, 37, 19, 40, 41, 31]
    b = range(10000)
    c = range(10000 - 1, -1, -1)
    d = b + c
    
    def maxelements_s(seq): # @SilentGhost
        ''' Return list of position(s) of largest element '''
        m = max(seq)
        return [i for i, j in enumerate(seq) if j == m]
    
    def maxelements_m(seq): # @martineau
        ''' Return list of position(s) of largest element '''
        max_indices = []
        if len(seq):
            max_val = seq[0]
            for i, val in ((i, val) for i, val in enumerate(seq) if val >= max_val):
                if val == max_val:
                    max_indices.append(i)
                else:
                    max_val = val
                    max_indices = [i]
        return max_indices
    
    def maxelements_j(seq): # @John Machin
        ''' Return list of position(s) of largest element '''
        if not seq: return []
        max_val = seq[0] if seq[0] >= seq[-1] else seq[-1]
        max_indices = []
        for i, val in enumerate(seq):
            if val < max_val: continue
            if val == max_val:
                max_indices.append(i)
            else:
                max_val = val
                max_indices = [i]
        return max_indices
    

    Windows XP SP3에서 파이썬 2.7을 실행하는 오래된 랩톱 결과 :

    >\python27\python -mtimeit -s"import maxelements as me" "me.maxelements_s(me.a)"
    100000 loops, best of 3: 6.88 usec per loop
    
    >\python27\python -mtimeit -s"import maxelements as me" "me.maxelements_m(me.a)"
    100000 loops, best of 3: 11.1 usec per loop
    
    >\python27\python -mtimeit -s"import maxelements as me" "me.maxelements_j(me.a)"
    100000 loops, best of 3: 8.51 usec per loop
    
    >\python27\python -mtimeit -s"import maxelements as me;a100=me.a*100" "me.maxelements_s(a100)"
    1000 loops, best of 3: 535 usec per loop
    
    >\python27\python -mtimeit -s"import maxelements as me;a100=me.a*100" "me.maxelements_m(a100)"
    1000 loops, best of 3: 558 usec per loop
    
    >\python27\python -mtimeit -s"import maxelements as me;a100=me.a*100" "me.maxelements_j(a100)"
    1000 loops, best of 3: 489 usec per loop
    
  6. ==============================

    6.numpy 패키지를 사용할 수도 있습니다.

    numpy 패키지를 사용할 수도 있습니다.

    import numpy as np
    A = np.array(a)
    maximum_indices = np.where(A==max(a))
    

    이것은 최대 값을 포함하는 모든 인덱스의 배열을 반환합니다.

    목록으로 바꾸려면 다음을 수행하십시오.

    maximum_indices_list = maximum_indices.tolist()
    
  7. ==============================

    7.

    >>> max(enumerate([1,2,3,32,1,5,7,9]),key=lambda x: x[1])
    >>> (3, 32)
    
  8. ==============================

    8.

    a = [32, 37, 28, 30, 37, 25, 27, 24, 35, 
             55, 23, 31, 55, 21, 40, 18, 50,
             35, 41, 49, 37, 19, 40, 41, 31]
    
    import pandas as pd
    
    pd.Series(a).idxmax()
    
    9
    

    그것이 내가 보통하는 방법입니다.

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

    9.여기에 나타나는 최대 값과 색인은 다음과 같습니다.

    여기에 나타나는 최대 값과 색인은 다음과 같습니다.

    >>> from collections import defaultdict
    >>> d = defaultdict(list)
    >>> a = [32, 37, 28, 30, 37, 25, 27, 24, 35, 55, 23, 31, 55, 21, 40, 18, 50, 35, 41, 49, 37, 19, 40, 41, 31]
    >>> for i, x in enumerate(a):
    ...     d[x].append(i)
    ... 
    >>> k = max(d.keys())
    >>> print k, d[k]
    55 [9, 12]
    

    나중에 : @ SilentGhost의 만족을 위해

    >>> from itertools import takewhile
    >>> import heapq
    >>> 
    >>> def popper(heap):
    ...     while heap:
    ...         yield heapq.heappop(heap)
    ... 
    >>> a = [32, 37, 28, 30, 37, 25, 27, 24, 35, 55, 23, 31, 55, 21, 40, 18, 50, 35, 41, 49, 37, 19, 40, 41, 31]
    >>> h = [(-x, i) for i, x in enumerate(a)]
    >>> heapq.heapify(h)
    >>> 
    >>> largest = heapq.heappop(h)
    >>> indexes = [largest[1]] + [x[1] for x in takewhile(lambda large: large[0] == largest[0], popper(h))]
    >>> print -largest[0], indexes
    55 [9, 12]
    
  10. ==============================

    10.한 줄만 :

    한 줄만 :

    idx = max(range(len(a)), key = lambda i: a[i])
    
  11. ==============================

    11.@shash가 다른 곳에서 이것을 대답했다.

    @shash가 다른 곳에서 이것을 대답했다.

    어느 쪽이 통과 할까. 그러나 @Silent_Ghost와 @nmichaels에 의한 해결책보다 느립니다.

    for i in s m j n; do echo $i;  python -mtimeit -s"import maxelements as me" "me.maxelements_${i}(me.a)"; done
    s
    100000 loops, best of 3: 3.13 usec per loop
    m
    100000 loops, best of 3: 4.99 usec per loop
    j
    100000 loops, best of 3: 3.71 usec per loop
    n
    1000000 loops, best of 3: 1.31 usec per loop
    
  12. ==============================

    12.목록 이해력과 비슷한 개념이지만 열거하지 않음

    목록 이해력과 비슷한 개념이지만 열거하지 않음

    m = max(a)
    [i for i in range(len(a)) if a[i] == m]
    
  13. ==============================

    13.

    import operator
    
    def max_positions(iterable, key=None, reverse=False):
      if key is None:
        def key(x):
          return x
      if reverse:
        better = operator.lt
      else:
        better = operator.gt
    
      it = enumerate(iterable)
      for pos, item in it:
        break
      else:
        raise ValueError("max_positions: empty iterable")
        # note this is the same exception type raised by max([])
      cur_max = key(item)
      cur_pos = [pos]
    
      for pos, item in it:
        k = key(item)
        if better(k, cur_max):
          cur_max = k
          cur_pos = [pos]
        elif k == cur_max:
          cur_pos.append(pos)
    
      return cur_max, cur_pos
    
    def min_positions(iterable, key=None, reverse=False):
      return max_positions(iterable, key, not reverse)
    

    >>> L = range(10) * 2
    >>> L
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> max_positions(L)
    (9, [9, 19])
    >>> min_positions(L)
    (0, [0, 10])
    >>> max_positions(L, key=lambda x: x // 2, reverse=True)
    (0, [0, 1, 10, 11])
    
  14. ==============================

    14.이 코드는 이전에 게시 된 답변만큼 정교하지는 않지만 제대로 작동합니다.

    이 코드는 이전에 게시 된 답변만큼 정교하지는 않지만 제대로 작동합니다.

    m = max(a)
    n = 0    # frequency of max (a)
    for number in a :
        if number == m :
            n = n + 1
    ilist = [None] * n  # a list containing index values of maximum number in list a.
    ilistindex = 0
    aindex = 0  # required index value.    
    for number in a :
        if number == m :
            ilist[ilistindex] = aindex
            ilistindex = ilistindex + 1
        aindex = aindex + 1
    
    print ilist
    

    위 코드의 ilist에는 목록에있는 최대 숫자의 모든 위치가 포함됩니다.

  15. ==============================

    15.당신은 다양한 방법으로 그것을 할 수 있습니다.

    당신은 다양한 방법으로 그것을 할 수 있습니다.

    예전의 전통적인 방식은

    maxIndexList = list() #this list will store indices of maximum values
    maximumValue = max(a) #get maximum value of the list
    length = len(a)       #calculate length of the array
    
    for i in range(length): #loop through 0 to length-1 (because, 0 based indexing)
        if a[i]==maximumValue: #if any value of list a is equal to maximum value then store its index to maxIndexList
            maxIndexList.append(i)
    
    print(maxIndexList) #finally print the list
    

    목록의 길이를 계산하지 않고 최대 값을 모든 변수에 저장하지 않고 다른 방법으로,

    maxIndexList = list()
    index = 0 #variable to store index
    for i in a: #iterate through the list (actually iterating through the value of list, not index )
        if i==max(a): #max(a) returns a maximum value of list.
            maxIndexList.append(index) #store the index of maximum value
    index = index+1 #increment the index
    
    print(maxIndexList)
    

    우리는 파이썬적이고 똑똑한 방법으로 그것을 할 수 있습니다! 목록 이해력을 한 줄에 사용하면,

    maxIndexList = [i for i,j in enumerate(a) if j==max(a)] #here,i=index and j = value of that index
    

    내 모든 코드는 파이썬 3에 있습니다.

  16. ==============================

    16.데이터라는 목록에서 가장 큰 n 개의 숫자의 인덱스를 가져 오려면 Pandas sort_values를 사용할 수 있습니다.

    데이터라는 목록에서 가장 큰 n 개의 숫자의 인덱스를 가져 오려면 Pandas sort_values를 사용할 수 있습니다.

    pd.Series(data).sort_values(ascending=False).index[0:n]
    
  17. from https://stackoverflow.com/questions/3989016/how-to-find-all-positions-of-the-maximum-value-in-a-list by cc-by-sa and MIT license