Obtendo o índice do item máximo ou mínimo retornado usando max () / min () em uma lista

Estou usando Python maxe minfunções em listas para um algoritmo minimax e preciso do índice do valor retornado por max()or min(). Em outras palavras, eu preciso saber qual jogada produziu o valor máximo (no turn do primeiro jogador) ou mínimo (segundo jogador).

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)

Eu preciso ser capaz de retornar o índice real do valor mínimo ou máximo, não apenas o valor.

se isMinLevel:
    return values.index (min (values))
outro:
    return values.index (max (values))

Diga que você tem uma lista values = [3,6,1,5]e precisa do índice do menor elemento, ou seja index_min = 2, neste caso.

Evite a solução itemgetter()apresentada nas outras respostas e use

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

porque não exige import operatornem deve ser usado enumerate, e é sempre mais rápido (referência abaixo) do que uma solução usando itemgetter().

Se você estiver lidando com matrizes numpy ou puder pagar numpycomo uma dependência, considere também usar

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

Isso será mais rápido que a primeira solução, mesmo se você aplicá-la a uma lista Python pura se:

• é maior que alguns elementos (cerca de 2 ** 4 elementos na minha máquina)
• você pode comprar a cópia da memória de uma lista pura para uma numpymatriz

como esta referência indica:

Executei o benchmark na minha máquina com python 2.7 para as duas soluções acima (azul: python puro, primeira solução) (solução vermelha e numpy) e para a solução padrão baseada em itemgetter()(solução preta de referência). A mesma referência do python 3.5 mostrou que os métodos comparam exatamente o mesmo do caso do python 2.7 apresentado acima

Você pode encontrar o índice e o valor mínimo / máximo ao mesmo tempo se enumerar os itens da lista, mas execute o mínimo / máximo nos valores originais da lista. Igual a:

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

Dessa forma, a lista será percorrida apenas uma vez por min (ou max).

Se você deseja encontrar o índice max dentro de uma lista de números (o que parece ser o seu caso), sugiro que você use numpy:

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

Possivelmente, uma solução mais simples seria transformar a matriz de valores em uma matriz de valores, pares de índices e tirar o máximo / min disso. Isso daria o maior / menor índice com max / min (ou seja, os pares são comparados comparando primeiro o primeiro elemento e, em seguida, comparando o segundo elemento se os primeiros forem iguais). Observe que não é realmente necessário criar a matriz, porque min / max permitem geradores como entrada.

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

Dará a você o primeiro índice do mínimo.

Eu acho que a melhor coisa a fazer é converter a lista em um numpy arraye usar esta função:

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

Eu também estava interessado nisso e comparei algumas das soluções sugeridas usando o perfplot (um projeto de estimação para mim).

Acontece que o argmin desse numpy ,

numpy.argmin(x)

é o método mais rápido para listas grandes o suficiente, mesmo com a conversão implícita da entrada listem a numpy.array.

Código para gerar o gráfico:

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

Use uma matriz numpy e a função argmax ()

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

Depois de obter os valores máximos, tente o seguinte:

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

Muito mais simples do que muitas opções.

Acho que a resposta acima resolve o seu problema, mas pensei em compartilhar um método que fornece o mínimo e todos os índices em que o mínimo aparece.

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

Isso passa na lista duas vezes, mas ainda é bastante rápido. No entanto, é um pouco mais lento do que encontrar o índice do primeiro encontro do mínimo. Portanto, se você precisar de apenas um dos mínimos, use a solução de Matt Anderson ; se precisar de todos, use isso.

Use a função do módulo numpy numpy.where

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

Para índice de valor mínimo:

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

Para índice de valor máximo:

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

De fato, essa função é muito mais poderosa. Você pode representar todos os tipos de operações booleanas para índice de valor entre 3 e 60:

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

Isso é simplesmente possível usando o built-in enumerate()and max()function e o keyargumento opcional da max()função e uma simples expressão lambda:

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

Nos documentos para max()ele diz que o keyargumento espera uma função como na list.sort()função. Consulte também o Guia de classificação .

Funciona da mesma maneira para min(). Entre, ele retorna o primeiro valor máximo / mínimo.

Digamos que você tenha uma lista como:

a = [9,8,7]

Os dois métodos a seguir são maneiras bastante compactas de obter uma tupla com o elemento mínimo e seu índice. Ambos têm uma abordagem semelhante tempo ao processo. Eu gosto mais do método zip, mas esse é o meu gosto.

método 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)

enumerar método

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)

Desde que você saiba como usar o lambda e o argumento "key", uma solução simples é:

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

Simples assim :

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

index = stuff.index(max(stuff))

Por que se preocupar em adicionar índices primeiro e depois revertê-los? A função Enumerate () é apenas um caso especial de uso da função zip (). Vamos usá-lo de maneira apropriada:

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)

Apenas uma pequena adição ao que já foi dito. values.index(min(values))parece retornar o menor índice de min. A seguir, obtém o maior índice:

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

A última linha pode ser deixada de fora se o efeito colateral da reversão no local não importar.

Para percorrer todas as ocorrências

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

Por uma questão de brevidade. Provavelmente, é uma idéia melhor armazenar em cache min(values), values.count(min)fora do loop.

Uma maneira simples de encontrar os índices com valor mínimo em uma lista, se você não deseja importar módulos adicionais:

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

Em seguida, escolha, por exemplo, o primeiro:

choosen = indexes_with_min_value[0]

Não tem representante alto o suficiente para comentar a resposta existente.

Mas para https://stackoverflow.com/a/11825864/3920439 answer

Isso funciona para números inteiros, mas não para matrizes flutuantes (pelo menos no python 3.6). TypeError: list indices must be integers or slices, not float

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

Se vários itens forem máximos, a função retornará o primeiro encontrado. Isso é consistente com outras ferramentas de preservação da estabilidade de classificação, comosorted(iterable, key=keyfunc, reverse=True)[0]

Para obter mais do que apenas o primeiro, use o método de classificação.

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

Que tal isso:

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

Ele cria um dicionário a partir dos itens em acomo chaves e seus índices como valores; assim, dict(zip(a,range(len(a))))[max(a)]retorna o valor que corresponde à chave max(a)que é o índice do máximo em a. Como sou iniciante em python, não conheço a complexidade computacional dessa solução.