Obtenir l'index de l'élément max ou min retourné en utilisant max () / min () sur une liste

J'utilise Python maxet les minfonctions sur les listes pour un algorithme minimax, et j'ai besoin de l'index de la valeur retournée par max()ou min(). En d'autres termes, j'ai besoin de savoir quel mouvement a produit la valeur max (au tour d'un premier joueur) ou min (deuxième joueur).

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)

J'ai besoin de pouvoir renvoyer l'index réel de la valeur min ou max, pas seulement la valeur.

si isMinLevel:
    return values.index (min (valeurs))
autre:
    return values.index (max (valeurs))

Disons que vous avez une liste values = [3,6,1,5]et que vous avez besoin de l'index du plus petit élément, c'est- index_min = 2à- dire dans ce cas.

Évitez la solution itemgetter()présentée dans les autres réponses et utilisez plutôt

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

car il ne demande import operatorni à utiliser enumerate, et il est toujours plus rapide (benchmark ci-dessous) qu'une solution utilisant itemgetter().

Si vous avez affaire à des tableaux numpy ou si vous pouvez vous permettre numpyune dépendance, envisagez également d'utiliser

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

Ce sera plus rapide que la première solution même si vous l'appliquez à une liste Python pure si:

• il est plus grand que quelques éléments (environ 2 ** 4 éléments sur ma machine)
• vous pouvez vous permettre la copie de la mémoire d'une liste pure vers un numpytableau

comme l'indique cette référence:

J'ai exécuté le benchmark sur ma machine avec python 2.7 pour les deux solutions ci-dessus (bleu: python pur, première solution) (rouge, solution numpy) et pour la solution standard basée sur itemgetter()(noir, solution de référence). Le même benchmark avec python 3.5 a montré que les méthodes comparent exactement la même chose que le cas python 2.7 présenté ci-dessus

Vous pouvez trouver l'index et la valeur min / max en même temps si vous énumérez les éléments de la liste, mais effectuez min / max sur les valeurs d'origine de la liste. Ainsi:

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

De cette façon, la liste ne sera parcourue qu'une seule fois pendant min (ou max).

Si vous voulez trouver l'index de max dans une liste de nombres (ce qui semble être votre cas), je vous suggère d'utiliser numpy:

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

Une solution plus simple serait peut-être de transformer le tableau de valeurs en un tableau de valeurs, des paires d'index, et d'en prendre le maximum / min. Cela donnerait l'indice le plus grand / le plus petit qui a le max / min (c'est-à-dire que les paires sont comparées en comparant d'abord le premier élément, puis en comparant le deuxième élément si les premiers sont les mêmes). Notez qu'il n'est pas nécessaire de créer réellement le tableau, car min / max autorisent les générateurs en entrée.

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

Vous donnera le premier indice du minimum.

Je pense que la meilleure chose à faire est de convertir la liste en a numpy arrayet d'utiliser cette fonction:

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

J'étais également intéressé par cela et j'ai comparé certaines des solutions suggérées en utilisant perfplot (un de mes projets ).

Il s'avère que l' argmin de ce numpy ,

numpy.argmin(x)

est la méthode la plus rapide pour des listes suffisamment grandes, même avec la conversion implicite de l'entrée listen a numpy.array.

Code de génération du tracé:

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

Utilisez un tableau numpy et la fonction argmax ()

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

Après avoir obtenu les valeurs maximales, essayez ceci:

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

Beaucoup plus simple que beaucoup d'options.

Je pense que la réponse ci-dessus résout votre problème, mais je pensais partager une méthode qui vous donne le minimum et tous les indices dans lesquels le minimum apparaît.

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

Cela passe la liste deux fois mais est encore assez rapide. Il est cependant légèrement plus lent que de trouver l'indice de la première rencontre du minimum. Donc, si vous avez besoin d'un seul des minima, utilisez la solution de Matt Anderson , si vous en avez tous besoin, utilisez-la.

Utilisez la fonction numpy du module numpy.where

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

Pour l'indice de valeur minimale:

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

Pour l'indice de valeur maximale:

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

En fait, cette fonction est beaucoup plus puissante. Vous pouvez poser toutes sortes d'opérations booléennes Pour un indice de valeur entre 3 et 60:

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

Ceci est tout simplement possible en utilisant le haut- enumerate()et la max()fonction et l'option keyargument de la max()fonction et une simple expression lambda:

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

Dans les documents car max()il dit que l' keyargument attend une fonction comme dans la list.sort()fonction. Voir également le guide de tri .

Il en va de même pour min(). Btw, il renvoie la première valeur max / min.

Supposons que vous ayez une liste telle que:

a = [9,8,7]

Les deux méthodes suivantes sont des moyens assez compacts pour obtenir un tuple avec l'élément minimum et son index. Les deux prennent un temps similaire à traiter. Je préfère la méthode zip, mais c'est mon goût.

méthode zip

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)

énumérer la méthode

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)

Tant que vous savez utiliser lambda et l'argument "clé", une solution simple est:

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

Aussi simple que cela :

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

index = stuff.index(max(stuff))

Pourquoi s'embêter à ajouter des indices d'abord puis à les inverser? La fonction Enumerate () n'est qu'un cas particulier d'utilisation de la fonction zip (). Utilisons-le de manière appropriée:

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)

Juste un ajout mineur à ce qui a déjà été dit. values.index(min(values))semble renvoyer le plus petit indice de min. Ce qui suit obtient le plus grand indice:

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

La dernière ligne peut être laissée de côté si l'effet secondaire de l'inversion en place n'a pas d'importance.

Pour parcourir toutes les occurrences

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

Pour des raisons de brièveté. Il est probablement préférable de mettre en cache en min(values), values.count(min)dehors de la boucle.

Un moyen simple de trouver les index avec une valeur minimale dans une liste si vous ne voulez pas importer de modules supplémentaires:

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

Choisissez ensuite par exemple le premier:

choosen = indexes_with_min_value[0]

N'ont pas assez de représentants pour commenter la réponse existante.

Mais pour https://stackoverflow.com/a/11825864/3920439 réponse

Cela fonctionne pour les entiers, mais ne fonctionne pas pour les tableaux de flottants (au moins en python 3.6) TypeError: list indices must be integers or slices, not float

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

Si plusieurs éléments sont maximaux, la fonction renvoie le premier rencontré. Ceci est cohérent avec d'autres outils préservant la stabilité du tri tels quesorted(iterable, key=keyfunc, reverse=True)[0]

Pour obtenir plus que la première, utilisez la méthode de tri.

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

Et ça:

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

Il crée un dictionnaire à partir des éléments en atant que clés et de leurs index en tant que valeurs, dict(zip(a,range(len(a))))[max(a)]renvoie ainsi la valeur qui correspond à la clé max(a)qui est l'index du maximum dans a. Je suis un débutant en python donc je ne connais pas la complexité de calcul de cette solution.