Mendapatkan indeks item maks atau min yang dikembalikan menggunakan maks () / min () pada daftar

Saya menggunakan Python maxdan minfungsi pada daftar untuk algoritma minimax, dan saya perlu indeks dari nilai yang dikembalikan oleh max()atau min(). Dengan kata lain, saya perlu tahu langkah mana yang menghasilkan nilai maks (pada giliran pemain pertama) atau min (pemain kedua).

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)

Saya harus dapat mengembalikan indeks aktual nilai min atau maks, bukan hanya nilai.

ifMinLevel:
    return values.index (min (nilai))
lain:
    return values.index (maks (nilai))

Katakan bahwa Anda memiliki daftar values = [3,6,1,5], dan perlu indeks elemen terkecil, yaitu index_min = 2dalam hal ini.

Hindari solusi dengan itemgetter()disajikan dalam jawaban lain, dan gunakan sebaliknya

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

karena tidak perlu import operatoratau tidak digunakan enumerate, dan selalu lebih cepat (patokan di bawah) daripada menggunakan solusi itemgetter().

Jika Anda berurusan dengan array numpy atau mampu numpysebagai ketergantungan, pertimbangkan juga untuk menggunakannya

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

Ini akan lebih cepat daripada solusi pertama bahkan jika Anda menerapkannya ke daftar Python murni jika:

• ini lebih besar dari beberapa elemen (sekitar 2 ** 4 elemen pada mesin saya)
• Anda dapat membeli salinan memori dari daftar murni ke numpyarray

seperti yang ditunjukkan oleh tolok ukur ini:

Saya telah menjalankan benchmark pada mesin saya dengan python 2.7 untuk dua solusi di atas (biru: python murni, solusi pertama) (merah, solusi numpy) dan untuk solusi standar berdasarkan itemgetter()(hitam, solusi referensi). Patokan yang sama dengan python 3.5 menunjukkan bahwa metode membandingkan persis sama dari kasus python 2.7 yang disajikan di atas

Anda dapat menemukan indeks min / maks dan nilai pada saat yang sama jika Anda menghitung item dalam daftar, tetapi melakukan min / maks pada nilai-nilai asli daftar. Seperti itu:

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

Dengan cara ini daftar hanya akan dilintasi satu kali untuk min (atau maks).

Jika Anda ingin menemukan indeks max dalam daftar angka (yang tampaknya seperti kasus Anda), maka saya sarankan Anda menggunakan numpy:

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

Mungkin solusi yang lebih sederhana adalah mengubah array nilai menjadi array nilai, pasangan indeks, dan mengambil maks / min dari itu. Ini akan memberikan indeks terbesar / terkecil yang memiliki max / min (yaitu pasangan dibandingkan dengan terlebih dahulu membandingkan elemen pertama, dan kemudian membandingkan elemen kedua jika yang pertama adalah sama). Perhatikan bahwa tidak perlu untuk benar-benar membuat array, karena min / max memungkinkan generator sebagai input.

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

Akan memberi Anda indeks minimum pertama.

Saya pikir hal terbaik untuk dilakukan adalah mengonversi daftar menjadi a numpy arraydan menggunakan fungsi ini:

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

Saya juga tertarik dengan ini dan membandingkan beberapa solusi yang disarankan menggunakan perfplot (proyek kesayangan saya).

Ternyata argmin numpy itu ,

numpy.argmin(x)

adalah metode tercepat untuk daftar yang cukup besar, bahkan dengan konversi implisit dari input listke a numpy.array.

Kode untuk menghasilkan plot:

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

Gunakan array numpy dan fungsi argmax ()

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

Setelah Anda mendapatkan nilai maksimum, coba ini:

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

Jauh lebih sederhana daripada banyak opsi.

Saya pikir jawaban di atas menyelesaikan masalah Anda, tetapi saya pikir saya akan membagikan metode yang memberi Anda minimum dan semua indeks minimum muncul.

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

Ini melewati daftar dua kali tetapi masih cukup cepat. Namun itu sedikit lebih lambat daripada menemukan indeks pertemuan pertama minimum. Jadi, jika Anda hanya membutuhkan satu dari minimum, gunakan solusi Matt Anderson , jika Anda membutuhkan semuanya, gunakan ini.

Gunakan fungsi modul numpy numpy.where

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

Untuk indeks nilai minimum:

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

Untuk indeks nilai maksimum:

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

Bahkan, fungsi ini jauh lebih kuat. Anda dapat mengajukan semua jenis operasi boolean Untuk indeks nilai antara 3 dan 60:

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

Ini sangat mungkin menggunakan built-in enumerate()dan max()fungsi serta keyargumen opsional max()fungsi dan ekspresi lambda sederhana:

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

Dalam dokumen untuk max()itu dikatakan bahwa keyargumen mengharapkan fungsi seperti dalam list.sort()fungsi. Lihat juga Cara Menyortir .

Ini berfungsi sama untuk min(). Btw mengembalikan nilai max / min pertama.

Katakanlah Anda memiliki daftar seperti:

a = [9,8,7]

Dua metode berikut adalah cara yang cukup ringkas untuk mendapatkan tuple dengan elemen minimum dan indeksnya. Keduanya membutuhkan waktu yang sama untuk diproses. Saya lebih suka metode zip, tapi itu selera saya.

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

menghitung metode

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)

Selama Anda tahu cara menggunakan lambda dan argumen "kunci", solusi sederhana adalah:

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

Sederhana seperti itu :

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

index = stuff.index(max(stuff))

Mengapa repot-repot menambahkan indeks terlebih dahulu dan kemudian membalikkannya? Enumerate () function hanyalah kasus khusus dari penggunaan fungsi zip (). Mari kita gunakan dengan cara yang tepat:

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)

Hanya tambahan kecil dari apa yang telah dikatakan. values.index(min(values))tampaknya mengembalikan indeks min terkecil. Berikut ini mendapatkan indeks terbesar:

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

Baris terakhir dapat ditinggalkan jika efek samping dari pembalikan di tempat tidak masalah.

Untuk mengulangi semua kejadian

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

Demi singkatnya. Mungkin ide yang lebih baik untuk melakukan cache di min(values), values.count(min)luar loop.

Cara mudah untuk menemukan indeks dengan nilai minimal dalam daftar jika Anda tidak ingin mengimpor modul tambahan:

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

Kemudian pilih misalnya yang pertama:

choosen = indexes_with_min_value[0]

Jangan punya rep yang cukup tinggi untuk mengomentari jawaban yang ada.

Tetapi untuk https://stackoverflow.com/a/11825864/3920439 jawabannya

Ini berfungsi untuk bilangan bulat, tetapi tidak berfungsi untuk array float (setidaknya dalam python 3.6) Ini akan naik TypeError: list indices must be integers or slices, not float

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

Jika beberapa item maksimal, fungsi mengembalikan item pertama yang ditemui. Ini konsisten dengan alat pengawet semacam stabilitas sepertisorted(iterable, key=keyfunc, reverse=True)[0]

Untuk mendapatkan lebih dari sekedar yang pertama, gunakan metode sortir.

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

Bagaimana dengan ini:

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

Itu membuat kamus dari item dalam asebagai kunci dan indeks mereka sebagai nilai, sehingga dict(zip(a,range(len(a))))[max(a)]mengembalikan nilai yang sesuai dengan kunci max(a)yang merupakan indeks maksimum dalam. Saya seorang pemula dalam python jadi saya tidak tahu tentang kompleksitas komputasi dari solusi ini.