รับดัชนีของรายการ max หรือ mined คืนโดยใช้ max () / min () ในรายการ

ฉันใช้งูใหญ่maxและminฟังก์ชั่นในรายการสำหรับขั้นตอนวิธีการ Minimax และฉันต้องดัชนีของค่าที่ส่งกลับโดยหรือmax() min()กล่าวอีกนัยหนึ่งฉันต้องรู้ว่าการเคลื่อนไหวใดที่ทำให้เกิดค่าสูงสุด (ตามเทิร์นของผู้เล่นคนแรก) หรือค่า min (ผู้เล่นคนที่สอง)

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)

ฉันต้องสามารถส่งคืนดัชนีจริงของค่า min หรือ max ไม่ใช่ค่า

ถ้า isMinLevel:
    return values.index (นาที (ค่า))
อื่น:
    ส่งคืนค่าดัชนี (สูงสุด (ค่า))

สมมติว่าคุณมีรายการvalues = [3,6,1,5]และต้องการดัชนีขององค์ประกอบที่เล็กที่สุดเช่นindex_min = 2ในกรณีนี้

หลีกเลี่ยงการแก้ปัญหาด้วยitemgetter()การนำเสนอในคำตอบอื่น ๆ และใช้แทน

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

เพราะมันไม่จำเป็นต้องที่จะimport operatorไม่ให้การใช้งานenumerateและมันก็มักจะได้เร็วขึ้น (มาตรฐานด้านล่าง) itemgetter()มากกว่าการแก้ปัญหาโดยใช้

หากคุณกำลังจัดการกับอาร์เรย์ numpy หรือสามารถจ่ายnumpyเป็นอ้างอิงให้พิจารณาใช้

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

สิ่งนี้จะเร็วกว่าโซลูชันแรกแม้ว่าคุณจะใช้กับรายการ Python อย่างสมบูรณ์หาก:

• มันมีขนาดใหญ่กว่าองค์ประกอบสองสามชิ้น (ประมาณ 2 ** 4 องค์ประกอบในเครื่องของฉัน)
• คุณสามารถจ่ายสำเนาหน่วยความจำจากรายการบริสุทธิ์ไปยังnumpyอาร์เรย์

ตามมาตรฐานนี้ชี้ให้เห็น:

ฉันใช้มาตรฐานในเครื่องของฉันด้วย python 2.7 สำหรับโซลูชันทั้งสองข้างต้น (สีน้ำเงิน: pure python, โซลูชันแรก) (สีแดง, โซลูชัน numpy) และสำหรับโซลูชันมาตรฐานที่อ้างอิงจากitemgetter()(โซลูชันสีดำอ้างอิง) เกณฑ์มาตรฐานเดียวกันกับ python 3.5 แสดงให้เห็นว่าวิธีการเปรียบเทียบที่เหมือนกันของกรณี python 2.7 ที่นำเสนอข้างต้น

คุณสามารถค้นหาดัชนีขั้นต่ำ / สูงสุดและค่าในเวลาเดียวกันหากคุณระบุรายการในรายการ แต่ดำเนินการขั้นต่ำ / สูงสุดในค่าเริ่มต้นของรายการ ชอบมาก

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

วิธีนี้รายการจะถูกสำรวจภายในหนึ่งครั้งสำหรับ min (หรือสูงสุด)

หากคุณต้องการหาดัชนี max ภายในรายการตัวเลข (ซึ่งดูเหมือนว่าเป็นกรณีของคุณ) ฉันขอแนะนำให้คุณใช้ numpy:

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

อาจเป็นวิธีที่ง่ายกว่าในการเปลี่ยนอาเรย์ของค่าให้เป็นอาเรย์ของค่าดัชนีคู่และรับค่าสูงสุด / นาที สิ่งนี้จะให้ดัชนีที่ใหญ่ที่สุด / เล็กที่สุดที่มีค่าสูงสุด / นาที (เช่นคู่จะถูกเปรียบเทียบโดยการเปรียบเทียบองค์ประกอบแรกก่อนจากนั้นเปรียบเทียบองค์ประกอบที่สองหากองค์ประกอบแรกเหมือนกัน) โปรดทราบว่าไม่จำเป็นต้องสร้างอาร์เรย์จริงเพราะ min / max อนุญาตให้เครื่องกำเนิดเป็นอินพุต

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

จะให้ดัชนีขั้นต่ำครั้งแรกแก่คุณ

ฉันคิดว่าสิ่งที่ดีที่สุดที่ต้องทำคือแปลงรายการเป็น a numpy arrayและใช้ฟังก์ชันนี้:

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

ฉันสนใจสิ่งนี้และเปรียบเทียบโซลูชันที่แนะนำโดยใช้perfplot (โครงการสัตว์เลี้ยงของฉัน)

ปรากฎว่าargmin ของ numpy ,

numpy.argmin(x)

เป็นวิธีที่เร็วที่สุดสำหรับรายการขนาดใหญ่พอที่แม้จะมีการแปลงนัยจากการป้อนข้อมูลไปยังlistnumpy.array

รหัสสำหรับการสร้างพล็อต:

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

ใช้อาร์เรย์ numpy และฟังก์ชัน argmax ()

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

หลังจากที่คุณได้รับค่าสูงสุดลองสิ่งนี้:

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

ง่ายกว่าตัวเลือกมากมาย

ฉันคิดว่าคำตอบข้างต้นแก้ปัญหาของคุณได้ แต่ฉันคิดว่าฉันจะแบ่งปันวิธีการที่จะช่วยให้คุณมีดัชนีขั้นต่ำและดัชนีขั้นต่ำทั้งหมดจะปรากฏขึ้น

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

รายการนี้ผ่านสองครั้ง แต่ก็ยังค่อนข้างเร็ว อย่างไรก็ตามมันช้ากว่าการค้นหาดัชนีของการเผชิญหน้าครั้งแรกเล็กน้อย ดังนั้นหากคุณต้องการเพียงหนึ่งในขั้นต่ำสุดให้ใช้วิธีแก้ปัญหาของMatt Andersonหากคุณต้องการทุกอย่างใช้สิ่งนี้

ใช้ฟังก์ชั่นโมดูล numpy ที่ใดก็ได้

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

สำหรับดัชนีค่าต่ำสุด:

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

สำหรับดัชนีมูลค่าสูงสุด:

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

ในความเป็นจริงฟังก์ชั่นนี้มีประสิทธิภาพมากขึ้น คุณสามารถสร้างการดำเนินการบูลีนทุกชนิดสำหรับดัชนีที่มีค่าระหว่าง 3 ถึง 60:

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

นี่เป็นไปได้เพียงแค่ใช้ในตัวenumerate()และmax()ฟังก์ชั่นและkeyอาร์กิวเมนต์ที่เป็นตัวเลือกของmax()ฟังก์ชั่นและการแสดงออกแลมบ์ดาที่เรียบง่าย:

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

ในเอกสารmax()มันบอกว่าkeyอาร์กิวเมนต์คาดหวังว่าฟังก์ชั่นเช่นเดียวกับในlist.sort()ฟังก์ชั่น ยังเห็นการเรียงลำดับวิธีการ

min()มันทำงานได้เหมือนกันสำหรับ Btw จะส่งคืนค่าสูงสุด / นาทีแรก

สมมติว่าคุณมีรายการเช่น:

a = [9,8,7]

สองวิธีต่อไปนี้เป็นวิธีที่กะทัดรัดในการรับ tuple พร้อมกับองค์ประกอบขั้นต่ำและดัชนี ทั้งสองใช้เวลาที่คล้ายกันเวลาที่จะดำเนินการ ฉันชอบวิธี zip มากกว่า แต่นั่นคือรสนิยมของฉัน

วิธีการ 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)

วิธีการแจกแจง

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)

ตราบใดที่คุณรู้วิธีใช้แลมบ์ดาและอาร์กิวเมนต์ "คีย์" โซลูชันที่ง่าย ๆ ก็คือ:

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

ง่ายเหมือนที่:

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

index = stuff.index(max(stuff))

ทำไมต้องเพิ่มดัชนีก่อนแล้วจึงย้อนกลับ ฟังก์ชัน Enumerate () เป็นเพียงกรณีพิเศษของการใช้ฟังก์ชัน zip () มาใช้ในวิธีที่เหมาะสม:

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)

เพียงแค่เพิ่มเล็กน้อยในสิ่งที่พูดไปแล้ว values.index(min(values))ดูเหมือนว่าจะส่งคืนดัชนีที่เล็กที่สุดของนาที ต่อไปนี้ได้รับดัชนีที่ใหญ่ที่สุด:

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

บรรทัดสุดท้ายสามารถทิ้งไว้ได้หากผลข้างเคียงของการย้อนกลับเข้าที่ไม่สำคัญ

เพื่อย้ำผ่านสิ่งที่เกิดขึ้นทั้งหมด

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

เพื่อความกระชับ อาจเป็นความคิดที่ดีกว่าในการแคชmin(values), values.count(min)นอกลูป

วิธีง่ายๆในการค้นหาดัชนีที่มีค่าน้อยที่สุดในรายการหากคุณไม่ต้องการนำเข้าโมดูลเพิ่มเติม:

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

จากนั้นเลือกตัวอย่างอันแรก:

choosen = indexes_with_min_value[0]

อย่ามีตัวแทนมากพอที่จะแสดงความคิดเห็นคำตอบที่มีอยู่

แต่สำหรับhttps://stackoverflow.com/a/11825864/3920439คำตอบ

สิ่งนี้ใช้ได้กับจำนวนเต็ม แต่ไม่สามารถใช้ได้กับอาร์เรย์ของลอย (อย่างน้อยใน python 3.6) มันจะเพิ่มขึ้น TypeError: list indices must be integers or slices, not float

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

หากมีหลายรายการมากที่สุดฟังก์ชันจะคืนค่ารายการแรกที่พบ สิ่งนี้สอดคล้องกับเครื่องมือรักษาความมั่นคงในการเรียงลำดับอื่น ๆ เช่นsorted(iterable, key=keyfunc, reverse=True)[0]

เพื่อให้ได้มากกว่าเพียงแค่ใช้วิธีการเรียงลำดับแรก

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=[1,55,2,36,35,34,98,0]
max_index=dict(zip(a,range(len(a))))[max(a)]

มันสร้างพจนานุกรมจากรายการในaฐานะที่เป็นกุญแจและดัชนีของพวกเขาเป็นค่าจึงdict(zip(a,range(len(a))))[max(a)]ส่งกลับค่าที่สอดคล้องกับกุญแจmax(a)ซึ่งเป็นดัชนีของสูงสุดใน ฉันเป็นผู้เริ่มต้นในงูใหญ่ดังนั้นฉันไม่รู้เกี่ยวกับความซับซ้อนในการคำนวณของโซลูชันนี้