  # numpy.nanargmin () in Python

argmin | NumPy | Python Methods and Functions

numpy.nanargmin (array, axis = None): Returns the indices of the min element of the array on the specified axis, ignoring NaN.
Results cannot be trusted if the slice contains only NaN and Infs.
Parameters:

`  array:  Input array to work on  axis:  [int, optional] Along a specified axis like 0 or 1 `

Return:

` Array of indices into the array with same shape as array.shape. with the dimension along axis removed. `

Code 1:

 ` # Python program illustrating # nanargmin () work ``   import numpy as geek    # Working with 1D array array = [geek.nan, 4 , 2 , 3 , 1 ] print ( "INPUT ARRAY 1:" , array)   array2 = geek.array ([[geek.nan, 4 ], [ 1 , 3 ]])   # returns the indexes of the min element # for metrics that include NaN print ( "Indices of min in array1:" , geek.nanargmin (array ))   # Working with 2D array print ( "INPUT ARRAY 2:" , array2) print ( "Indices of min in array2:" , geek.nanargmin (array2))   print ( "Indices at axis 1 of array2:" , geek.nanargmin (array2, axis = 1 ) ) `

Output:

` INPUT ARRAY 1: [nan, 4, 2, 3, 1] Indices of min in array1: 4 INPUT ARRAY 2: [[nan 4.] [1. 3.]] Indices of min in array2: 2 Indices at axis 1 of array2: [1 0] `

Code 2: Comparison of argmin and nanargmin operation

 ` # Python program illustrating ` # nanargmin () work   ` import ` ` numpy as geek `   ` # Working with 2D array ` ` array ` ` = ` ` ([[` ` 8 ` `, ` ` 13 ` `, ` ` 5 ` `, ` ` 0 ], `` [geek.nan, geek. nan, 5 , 3 ],   [ 10 , 7 , 15 , 15 ], [ 3 , 11 , 4 , 12 ]]) print ( "INPUT ARRAY:" , array)   # returns min element indices # by metrics   "" "   [[8 13 5 0] [0 2 5 3]   [10 7 15 15] [3 11 4 12]] ^ ^ ^ ^ 0 2 4 0 - element   1 1 3 0 - indicators "" "    print ( "Indices of min using argmin:" , geek.argmin (array, axis = 0 )) print ( "Indices of min using nanargmin:: " , geek.nanargmin (a rray, axis = 0 )) `

Output:

` INPUT ARRAY: [[8 13 5 0] [0 2 5 3] [10 7 15 15] [3 11 4 12]] Indices of min element: [1 1 3 0] `

argmin.html> https://docs.scipy.org/doc/numpy -dev / reference / generated / numpy.nanargmin.html

Notes:
These codes will not work for online IDs. Please run them on your systems to see how they work

## numpy.nanargmin () in Python: StackOverflow Questions

``````import numpy as np
def find_nearest(array, value):
array = np.asarray(array)
idx = (np.abs(array - value)).argmin()
return array[idx]

array = np.random.random(10)
print(array)
# [ 0.21069679  0.61290182  0.63425412  0.84635244  0.91599191  0.00213826
#   0.17104965  0.56874386  0.57319379  0.28719469]

value = 0.5

print(find_nearest(array, value))
# 0.568743859261
``````

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(range(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

as this benchmark points out: 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