Abrufen des Index des zurückgegebenen max- oder min-Elements mit max () / min () in einer Liste

Ich verwende Pythons maxund minFunktionen in Listen für einen Minimax-Algorithmus und benötige den Index des von max()oder zurückgegebenen Werts min(). Mit anderen Worten, ich muss wissen, welcher Zug den Maximalwert (beim Zug eines ersten Spielers) oder den Minimalwert (beim zweiten Spieler) ergab.

for i in range(9):
    newBoard = currentBoard.newBoardWithMove([i / 3, i % 3], player)

    if newBoard:
        temp = minMax(newBoard, depth + 1, not isMinLevel)  
        values.append(temp)

if isMinLevel:
    return min(values)
else:
    return max(values)

Ich muss in der Lage sein, den tatsächlichen Index des Min- oder Max-Werts zurückzugeben, nicht nur den Wert.

if isMinLevel:
    Rückgabewerte.index (min (Werte))
sonst:
    Rückgabewerte.index (max (Werte))

Angenommen, Sie haben eine Liste values = [3,6,1,5]und benötigen den Index des kleinsten Elements, dh index_min = 2in diesem Fall.

Vermeiden Sie die itemgetter()in den anderen Antworten dargestellte Lösung und verwenden Sie sie stattdessen

index_min = min(range(len(values)), key=values.__getitem__)

weil es weder benötigt import operatornoch verwendet werden enumeratemuss und immer schneller ist (Benchmark unten) als eine Lösung, die verwendet wird itemgetter().

Wenn Sie mit Numpy-Arrays zu tun haben oder es sich numpyals Abhängigkeit leisten können , sollten Sie auch die Verwendung in Betracht ziehen

import numpy as np
index_min = np.argmin(values)

Dies ist schneller als die erste Lösung, selbst wenn Sie sie auf eine reine Python-Liste anwenden, wenn:

• es ist größer als ein paar Elemente (ungefähr 2 ** 4 Elemente auf meiner Maschine)
• Sie können sich die Speicherkopie von einer reinen Liste in ein numpyArray leisten

wie dieser Benchmark zeigt:

Ich habe den Benchmark auf meinem Computer mit Python 2.7 für die beiden oben genannten Lösungen (blau: reines Python, erste Lösung) (rot, numpy-Lösung) und für die Standardlösung basierend auf itemgetter()(schwarz, Referenzlösung) ausgeführt. Der gleiche Benchmark mit Python 3.5 zeigte, dass die Methoden genau den gleichen wie der oben vorgestellte Fall von Python 2.7 vergleichen

Sie können den Min / Max-Index und den Wert gleichzeitig finden, wenn Sie die Elemente in der Liste auflisten, aber Min / Max für die ursprünglichen Werte der Liste ausführen. Wie so:

import operator
min_index, min_value = min(enumerate(values), key=operator.itemgetter(1))
max_index, max_value = max(enumerate(values), key=operator.itemgetter(1))

Auf diese Weise wird die Liste nur einmal für min (oder max) durchlaufen.

Wenn Sie den Index von max in einer Liste von Zahlen finden möchten (was Ihr Fall zu sein scheint), empfehle ich Ihnen, numpy zu verwenden:

import numpy as np
ind = np.argmax(mylist)

Möglicherweise wäre eine einfachere Lösung, das Array von Werten in ein Array von Werten, Indexpaaren, umzuwandeln und das Maximum / Min davon zu nehmen. Dies würde den größten / kleinsten Index ergeben, der das Maximum / Min hat (dh Paare werden verglichen, indem zuerst das erste Element verglichen wird und dann das zweite Element verglichen wird, wenn die ersten gleich sind). Beachten Sie, dass es nicht erforderlich ist, das Array tatsächlich zu erstellen, da Min / Max Generatoren als Eingabe zulassen.

values = [3,4,5]
(m,i) = max((v,i) for i,v in enumerate(values))
print (m,i) #(5, 2)

list=[1.1412, 4.3453, 5.8709, 0.1314]
list.index(min(list))

Gibt Ihnen den ersten Index des Minimums.

Ich denke, das Beste, was Sie tun können, ist, die Liste in a zu konvertieren numpy arrayund diese Funktion zu verwenden:

a = np.array(list)
idx = np.argmax(a)

Ich war auch daran interessiert und verglich einige der vorgeschlagenen Lösungen mit perfplot (einem meiner Lieblingsprojekte ).

Es stellt sich heraus, dass der Nummel Argmin ist ,

numpy.argmin(x)

ist die schnellste Methode für ausreichend große Listen, selbst bei der impliziten Konvertierung von der Eingabe listin a numpy.array.

Code zum Generieren des Plots:

import numpy
import operator
import perfplot


def min_enumerate(a):
    return min(enumerate(a), key=lambda x: x[1])[0]


def min_enumerate_itemgetter(a):
    min_index, min_value = min(enumerate(a), key=operator.itemgetter(1))
    return min_index


def getitem(a):
    return min(range(len(a)), key=a.__getitem__)


def np_argmin(a):
    return numpy.argmin(a)


perfplot.show(
    setup=lambda n: numpy.random.rand(n).tolist(),
    kernels=[
        min_enumerate,
        min_enumerate_itemgetter,
        getitem,
        np_argmin,
        ],
    n_range=[2**k for k in range(15)],
    logx=True,
    logy=True,
    )

Verwenden Sie ein Numpy-Array und die Funktion argmax ()

 a=np.array([1,2,3])
 b=np.argmax(a)
 print(b) #2

Versuchen Sie Folgendes, nachdem Sie die Maximalwerte erhalten haben:

max_val = max(list)
index_max = list.index(max_val)

Viel einfacher als viele Optionen.

Ich denke, die obige Antwort löst Ihr Problem, aber ich dachte, ich würde eine Methode teilen, die Ihnen das Minimum und alle Indizes gibt, in denen das Minimum erscheint.

minval = min(mylist)
ind = [i for i, v in enumerate(mylist) if v == minval]

Dies passiert die Liste zweimal, ist aber immer noch ziemlich schnell. Es ist jedoch etwas langsamer als das Finden des Index der ersten Begegnung des Minimums. Wenn Sie also nur eines der Minima benötigen, verwenden Sie die Lösung von Matt Anderson . Wenn Sie alle benötigen, verwenden Sie diese.

Verwenden Sie die Funktion numpy.where des Numpy-Moduls

import numpy as n
x = n.array((3,3,4,7,4,56,65,1))

Für den Index des Mindestwerts:

idx = n.where(x==x.min())[0]

Für den Index des Maximalwerts:

idx = n.where(x==x.max())[0]

In der Tat ist diese Funktion viel leistungsfähiger. Sie können alle Arten von Booleschen Operationen ausführen. Für einen Wertindex zwischen 3 und 60:

idx = n.where((x>3)&(x<60))[0]
idx
array([2, 3, 4, 5])
x[idx]
array([ 4,  7,  4, 56])

Dies ist einfach möglich mit dem eingebauten in enumerate()und max()Funktion und das optionale keyArgument der max()Funktion und einen einfachen Lambda - Ausdruck:

theList = [1, 5, 10]
maxIndex, maxValue = max(enumerate(theList), key=lambda v: v[1])
# => (2, 10)

In den Dokumenten max()heißt es, dass das keyArgument eine Funktion wie in der list.sort()Funktion erwartet . Siehe auch Sortieren .

Es funktioniert genauso für min(). Übrigens gibt es den ersten Max / Min-Wert zurück.

Angenommen, Sie haben eine Liste wie:

a = [9,8,7]

Die folgenden zwei Methoden sind ziemlich kompakte Methoden, um ein Tupel mit dem minimalen Element und seinem Index zu erhalten. Beide nehmen eine ähnliche Bearbeitungszeit. Ich mag die Zip-Methode besser, aber das ist mein Geschmack.

Zip-Methode

element, index = min(list(zip(a, range(len(a)))))

min(list(zip(a, range(len(a)))))
(7, 2)

timeit min(list(zip(a, range(len(a)))))
1.36 µs ± 107 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Methode aufzählen

index, element = min(list(enumerate(a)), key=lambda x:x[1])

min(list(enumerate(a)), key=lambda x:x[1])
(2, 7)

timeit min(list(enumerate(a)), key=lambda x:x[1])
1.45 µs ± 78.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Solange Sie wissen, wie man Lambda und das "Schlüssel" -Argument verwendet, ist eine einfache Lösung:

max_index = max( range( len(my_list) ), key = lambda index : my_list[ index ] )

So einfach ist das :

stuff = [2, 4, 8, 15, 11]

index = stuff.index(max(stuff))

Warum zuerst Indizes hinzufügen und dann umkehren? Die Funktion Enumerate () ist nur ein Sonderfall der Verwendung der Funktion zip (). Lassen Sie es uns angemessen verwenden:

my_indexed_list = zip(my_list, range(len(my_list)))

min_value, min_index = min(my_indexed_list)
max_value, max_index = max(my_indexed_list)

Nur eine kleine Ergänzung zu dem, was bereits gesagt wurde. values.index(min(values))scheint den kleinsten Index von min zurückzugeben. Folgendes erhält den größten Index:

    values.reverse()
    (values.index(min(values)) + len(values) - 1) % len(values)
    values.reverse()

Die letzte Zeile kann weggelassen werden, wenn der Nebeneffekt der Umkehrung keine Rolle spielt.

Durch alle Vorkommen iterieren

    indices = []
    i = -1
    for _ in range(values.count(min(values))):
      i = values[i + 1:].index(min(values)) + i + 1
      indices.append(i)

Um es kurz zu machen. Es ist wahrscheinlich eine bessere Idee, min(values), values.count(min)außerhalb der Schleife zwischenzuspeichern.

Eine einfache Möglichkeit, die Indizes mit minimalem Wert in einer Liste zu finden, wenn Sie keine zusätzlichen Module importieren möchten:

min_value = min(values)
indexes_with_min_value = [i for i in range(0,len(values)) if values[i] == min_value]

Dann wählen Sie zum Beispiel den ersten:

choosen = indexes_with_min_value[0]

Haben Sie nicht genügend Wiederholungen, um die vorhandene Antwort zu kommentieren.

Aber für https://stackoverflow.com/a/11825864/3920439 antworten

Dies funktioniert für Ganzzahlen, aber nicht für ein Array von Floats (zumindest in Python 3.6). Es wird ausgelöst TypeError: list indices must be integers or slices, not float

https://docs.python.org/3/library/functions.html#max

Wenn mehrere Elemente maximal sind, gibt die Funktion das erste gefundene zurück. Dies steht im Einklang mit anderen Werkzeugen zur Erhaltung der Sortierstabilität, wie zsorted(iterable, key=keyfunc, reverse=True)[0]

Um mehr als nur die ersten zu erhalten, verwenden Sie die Sortiermethode.

import operator

x = [2, 5, 7, 4, 8, 2, 6, 1, 7, 1, 8, 3, 4, 9, 3, 6, 5, 0, 9, 0]

min = False
max = True

min_val_index = sorted( list(zip(x, range(len(x)))), key = operator.itemgetter(0), reverse = min )

max_val_index = sorted( list(zip(x, range(len(x)))), key = operator.itemgetter(0), reverse = max )


min_val_index[0]
>(0, 17)

max_val_index[0]
>(9, 13)

import ittertools

max_val = max_val_index[0][0]

maxes = [n for n in itertools.takewhile(lambda x: x[0] == max_val, max_val_index)]

Was ist damit:

a=[1,55,2,36,35,34,98,0]
max_index=dict(zip(a,range(len(a))))[max(a)]

Es erstellt ein Wörterbuch aus den Elementen in aals Schlüssel und ihren Indizes als Werte und dict(zip(a,range(len(a))))[max(a)]gibt somit den Wert zurück, der dem Schlüssel entspricht, der max(a)der Index des Maximums in a ist. Ich bin ein Anfänger in Python, daher weiß ich nichts über die rechnerische Komplexität dieser Lösung.