I'm using Python's `max`

and `min`

functions on lists for a minimax algorithm, and I need the index of the value returned by `max()`

or `min()`

. In other words, I need to know which move produced the max (at a first player's turn) or min (second player) value.

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

I need to be able to return the actual index of the min or max value, not just the value.

if isMinLevel: return values.index(min(values)) else: return values.index(max(values))

Say that you have a list `values = [3,6,1,5]`

, and need the index of the smallest element, i.e. `index_min = 2`

in this case.

Avoid the solution with `itemgetter()`

presented in the other answers, and use instead

```
index_min = min(xrange(len(values)), key=values.__getitem__)
```

because it doesn't require to `import operator`

nor to use `enumerate`

, and it is always faster(benchmark below) than a solution using `itemgetter()`

.

If you are dealing with numpy arrays or can afford `numpy`

as a dependency, consider also using

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

This will be faster than the first solution even if you apply it to a pure Python list if:

- it is larger than a few elements (about 2**4 elements on my machine)
- you can afford the memory copy from a pure list to a
`numpy`

array

I have run the benchmark on my machine with python 2.7 for the two solutions above (blue: pure python, first solution) (red, numpy solution) and for the standard solution based on `itemgetter()`

(black, reference solution).
The same benchmark with python 3.5 showed that the methods compare exactly the same of the python 2.7 case presented above

Licensed under: CC-BY-SA with attribution

Not affiliated with: Stack Overflow