Wie finde ich alle Positionen des Maximalwertes in einer Liste?

Ich habe eine Liste:

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]

Das maximale Element ist 55 (zwei Elemente an Position 9 und 12).

Ich muss herausfinden, an welcher Position (en) sich der Maximalwert befindet. Bitte helfen Sie.

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

a.index(max(a))

zeigt Ihnen den Index der ersten Instanz des größten bewerteten Elements der Liste an a.

Die gewählte Antwort (und die meisten anderen) erfordern mindestens zwei Durchgänge durch die Liste.
Hier ist eine One-Pass-Lösung, die für längere Listen die bessere Wahl sein könnte.

Bearbeitet: Um die beiden von @John Machin aufgezeigten Mängel zu beheben. Für (2) habe ich versucht, die Tests basierend auf der geschätzten Wahrscheinlichkeit des Auftretens jeder Bedingung und den Schlussfolgerungen der Vorgänger zu optimieren. Es war ein wenig schwierig , die richtigen Initialisierungswerte für herauszufinden , max_valund max_indicesdie für alle möglichen Fälle gearbeitet, vor allem , wenn der max der erste Wert in der Liste zufällig - aber ich glaube , dass es jetzt der Fall ist.

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

Ich habe mir Folgendes ausgedacht und es funktioniert, wie Sie sehen können max, minund andere Funktionen über Listen wie diese:

Betrachten Sie also bitte die nächste Beispielliste, um die Position des Maximums in der Liste herauszufinden a:

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

Den Generator benutzen enumerate und ein Casting machen

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

An dieser Stelle können wir die Position von max mit extrahieren

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

Das Obige sagt uns, das Maximum ist in Position 4 und sein Wert ist 5.

Wie Sie sehen, können Sie im keyArgument das Maximum für jedes iterierbare Objekt ermitteln, indem Sie ein geeignetes Lambda definieren.

Ich hoffe, dass es dazu beiträgt.

PD: Wie @PaulOyster in einem Kommentar feststellte. Mit Python 3.xdem minund maxerlauben Sie ein neues Schlüsselwort default, das die Auslöseausnahme vermeidet, ValueErrorwenn das Argument eine leere Liste ist.max(enumerate(list), key=(lambda x:x[1]), default = -1)

Ich kann die von @martineau zitierte Leistung von @ SilentGhost nicht reproduzieren. Hier ist meine Anstrengung mit Vergleichen:

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

Ergebnisse eines verprügelten alten Laptops mit Python 2.7 unter Windows XP SP3:

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

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

So mache ich es normalerweise.

Sie können auch das numpy-Paket verwenden:

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

Dies gibt ein numpy-Array aller Indizes zurück, die den Maximalwert enthalten

Wenn Sie dies in eine Liste umwandeln möchten:

maximum_indices_list = maximum_indices.tolist()

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

Auch eine Lösung, die nur das erste Erscheinungsbild ergibt , kann erreicht werden durch numpy:

>>> import numpy as np
>>> a_np = np.array(a)
>>> np.argmax(a_np)
9

@shash hat dies an anderer Stelle beantwortet

Ein pythonischer Weg, um den Index des maximalen Listenelements zu finden, wäre

position = max(enumerate(a), key=lambda x: x[1])[0]

Welches macht man vorbei . Es ist jedoch langsamer als die Lösung von @Silent_Ghost und vor allem von @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

Hier ist der Maximalwert und die Indizes, unter denen er angezeigt wird:

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

Später: zur Zufriedenheit von @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]

Ähnliche Idee mit einem Listenverständnis, aber ohne Aufzählung

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

Nur eine Zeile:

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

Wenn Sie die Indizes der größten nZahlen in einer Liste mit dem Namen erhalten möchten data, können Sie Pandas verwenden sort_values:

pd.Series(data).sort_values(ascending=False).index[0:n]

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

Dieser Code ist nicht so ausgefeilt wie die zuvor veröffentlichten Antworten, funktioniert aber:

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

Die Liste im obigen Code würde alle Positionen der maximalen Anzahl in der Liste enthalten.

Sie können dies auf verschiedene Arten tun.

Der alte konventionelle Weg ist,

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

Eine andere Möglichkeit, ohne die Länge der Liste zu berechnen und den Maximalwert für eine Variable zu speichern,

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)

Wir können es auf pythonische und kluge Weise tun! Verwenden des Listenverständnisses nur in einer Zeile,

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

Alle meine Codes sind in Python 3.