Uzyskiwanie indeksu zwróconej pozycji maks. Lub min. Za pomocą max () / min () na liście

Używam Pythona maxi minfunkcji na listach dla algorytmu minimax i potrzebuję indeksu wartości zwróconej przez max()lub min(). Innymi słowy, muszę wiedzieć, który ruch wytworzył wartość maksymalną (podczas tury pierwszego gracza) lub wartość minimalną (drugiego gracza).

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)

Muszę być w stanie zwrócić rzeczywisty indeks wartości minimalnej lub maksymalnej, a nie tylko wartość.

if isMinLevel:
    zwracane wartości. indeks (min (wartości))
jeszcze:
    zwracane wartości. indeks (maks. (wartości))

Powiedz, że masz listę values = [3,6,1,5]i potrzebujesz indeksu najmniejszego elementu, czyli index_min = 2w tym przypadku.

Unikaj rozwiązania itemgetter()przedstawionego w innych odpowiedziach i użyj zamiast tego

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

ponieważ nie wymaga import operatorani nie używa enumerate, i zawsze jest szybszy (benchmark poniżej) niż rozwiązanie itemgetter().

Jeśli masz do czynienia z tablicami numpy lub możesz sobie pozwolić numpy na zależność, rozważ również użycie

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

Będzie to szybsze niż pierwsze rozwiązanie, nawet jeśli zastosujesz go do czystej listy Python, jeśli:

• jest większy niż kilka elementów (około 2 ** 4 elementy na moim komputerze)
• możesz sobie pozwolić na kopię pamięci z czystej listy do numpytablicy

jak wskazuje ten punkt odniesienia:

Uruchomiłem test porównawczy na moim komputerze z Pythonem 2.7 dla dwóch powyższych rozwiązań (niebieski: czysty python, pierwsze rozwiązanie) (czerwony, numpy) i dla standardowego rozwiązania opartego na itemgetter()(czarny, rozwiązanie referencyjne). Ten sam test porównawczy z python 3.5 pokazał, że metody porównują dokładnie to samo z powyższym przypadkiem python 2.7

Możesz znaleźć indeks i wartość min / max w tym samym czasie, jeśli wyliczysz pozycje na liście, ale wykonasz min / max na oryginalnych wartościach listy. Tak jak:

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

W ten sposób lista będzie przeglądana tylko raz przez min (lub max).

Jeśli chcesz znaleźć indeks maksymalny na liście liczb (co wydaje się twoim przypadkiem), sugeruję użycie numpy:

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

Być może prostszym rozwiązaniem byłoby przekształcenie tablicy wartości w tablicę wartości, pary indeksów i przyjęcie jej maksimum / min. Dałoby to największy / najmniejszy indeks, który ma maksimum / min (tzn. Pary są porównywane najpierw przez porównanie pierwszego elementu, a następnie porównanie drugiego elementu, jeśli pierwsze są takie same). Zauważ, że nie jest konieczne tworzenie tablicy, ponieważ min / max zezwalają na generatory jako dane wejściowe.

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

Otrzymasz pierwszy indeks minimum.

Myślę, że najlepiej jest przekonwertować listę na numpy arrayi użyć tej funkcji:

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

Byłem również tym zainteresowany i porównałem niektóre z sugerowanych rozwiązań za pomocą perfplot ( projektu dla zwierząt domowych).

Okazuje się, że argmin tego numpy ,

numpy.argmin(x)

jest najszybszą metodą dla wystarczająco dużych list, nawet z niejawną konwersją z danych wejściowych listna a numpy.array.

Kod do generowania wykresu:

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

Użyj tablicy numpy i funkcji argmax ()

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

Po uzyskaniu maksymalnych wartości spróbuj wykonać następujące czynności:

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

Znacznie prostsze niż wiele opcji.

Myślę, że powyższa odpowiedź rozwiązuje twój problem, ale pomyślałem, że podzielę się metodą, która daje ci minimum i wszystkie wskaźniki, w których pojawia się minimum.

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

To mija listę dwa razy, ale wciąż jest dość szybkie. Jest jednak nieco wolniejszy niż znalezienie wskaźnika pierwszego spotkania minimum. Więc jeśli potrzebujesz tylko jednego minimum, skorzystaj z rozwiązania Matta Andersona , jeśli potrzebujesz ich wszystkich, skorzystaj z tego.

Użyj funkcji numpy modułu numpy.where

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

Dla indeksu wartości minimalnej:

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

Dla indeksu wartości maksymalnej:

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

W rzeczywistości ta funkcja jest znacznie potężniejsza. Możesz tworzyć wszelkiego rodzaju operacje boolowskie. Dla indeksu wartości od 3 do 60:

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

To jest po prostu możliwe przy użyciu wbudowanych enumerate()i max()funkcji i opcjonalnego keyargumentu max()funkcji i prostego wyrażenia lambda:

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

W dokumentacji max()napisano, że keyargument oczekuje funkcji takiej jak w list.sort()funkcji. Zobacz także Sortowanie .

Działa to samo dla min(). Btw zwraca pierwszą wartość maks./min.

Powiedz, że masz listę, taką jak:

a = [9,8,7]

Poniższe dwie metody to dość kompaktowe sposoby uzyskania krotki z minimalnym elementem i jego indeksem. Oba mają podobne czas do przetworzenia. Bardziej podoba mi się metoda zip, ale taki jest mój gust.

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

wyliczyć metodę

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)

Tak długo, jak wiesz, jak używać lambda i argumentu „klucz”, proste rozwiązanie to:

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

Proste :

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

index = stuff.index(max(stuff))

Po co zawracać sobie głowę dodawaniem indeksów, a następnie ich odwracaniem? Funkcja Enumerate () jest tylko specjalnym przypadkiem użycia funkcji zip (). Użyjmy go w odpowiedni sposób:

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)

Tylko drobny dodatek do tego, co już powiedziano. values.index(min(values))wydaje się zwracać najmniejszy indeks min. Największy indeks otrzymuje następujący:

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

Ostatni wiersz można pominąć, jeśli efekt uboczny cofnięcia w miejscu nie ma znaczenia.

Aby iterować przez wszystkie wystąpienia

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

Ze względu na zwięzłość. Prawdopodobnie lepszym pomysłem jest buforowanie min(values), values.count(min)poza pętlą.

Prosty sposób na znalezienie indeksów o minimalnej wartości na liście, jeśli nie chcesz importować dodatkowych modułów:

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

Następnie wybierz na przykład pierwszy:

choosen = indexes_with_min_value[0]

Nie masz wystarczająco wysokiego przedstawiciela, aby skomentować istniejącą odpowiedź.

Ale dla https://stackoverflow.com/a/11825864/3920439 odpowiedź

Działa to dla liczb całkowitych, ale nie działa dla tablicy liczb zmiennoprzecinkowych (przynajmniej w Pythonie 3.6) TypeError: list indices must be integers or slices, not float

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

Jeśli maksymalna liczba elementów jest maksymalna, funkcja zwraca pierwszy napotkany. Jest to zgodne z innymi narzędziami zabezpieczającymi stabilność sortowania, takimi jaksorted(iterable, key=keyfunc, reverse=True)[0]

Aby uzyskać więcej niż tylko pierwszą, użyj metody sortowania.

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

A co z tym:

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

It creates a dictionary from the items in a as keys and their indexes as values, thus dict(zip(a,range(len(a))))[max(a)] returns the value that corresponds to the key max(a) which is the index of the maximum in a. I'm a beginner in python so I don't know about the computational complexity of this solution.