是否存在numpy-thonic方式，例如函数，在数组中找到最近值？
示例：
np.find_nearest( array, value )
答案 0 :(得分：434)
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
答案 1 :(得分：64)
IF 您的数组已排序且非常大，这是一个更快的解决方案：
def find_nearest(array,value):
idx = np.searchsorted(array, value, side="left")
if idx > 0 and (idx == len(array) or math.fabs(value - array[idx-1]) < math.fabs(value - array[idx])):
return array[idx-1]
else:
return array[idx]
这可以扩展到非常大的数组。如果您不能假设数组已经排序，则可以轻松修改上述内容以在方法中进行排序。这对于小型阵列来说太过分了，但是一旦它们变大，这就会快得多。
答案 2 :(得分：42)
稍作修改，上面的答案适用于任意维度的数组（1d，2d，3d，...）：
def find_nearest(a, a0):
"Element in nd array `a` closest to the scalar value `a0`"
idx = np.abs(a - a0).argmin()
return a.flat[idx]
或者，写成一行：
a.flat[np.abs(a - a0).argmin()]
答案 3 :(得分：17)
答案摘要：如果有一个排序array，则二分代码（如下所示）执行速度最快。大型阵列的速度提高约100-1000倍，小型阵列的速度提高约2-100倍。它也不需要numpy。
如果你有一个未排序的array，那么如果array很大，那么首先应该考虑使用O（n logn）排序然后进行二分，如果array很小，那么方法2似乎是最快的。
首先，您应该用最接近的值来澄清您的意思。通常人们想要横坐标中的间隔，例如， array = [0,0.7,2.1]，value = 1.95，answer为idx = 1。这是我怀疑你需要的情况（否则，一旦找到间隔，可以使用后续条件语句很容易地修改以下内容）。我会注意到执行此操作的最佳方式是二分（我将首先提供 - 注意它根本不需要numpy并且比使用numpy函数更快，因为它们执行冗余操作）。然后，我将提供与其他用户在此处提供的其他内容的时序比较。
二分：
def bisection(array,value):
'''Given an ``array`` , and given a ``value`` , returns an index j such that ``value`` is between array[j]
and array[j+1]. ``array`` must be monotonic increasing. j=-1 or j=len(array) is returned
to indicate that ``value`` is out of range below and above respectively.'''
n = len(array)
if (value < array[0]):
return -1
elif (value > array[n-1]):
return n
jl = 0# Initialize lower
ju = n-1# and upper limits.
while (ju-jl > 1):# If we are not yet done,
jm=(ju+jl) >> 1# compute a midpoint with a bitshift
if (value >= array[jm]):
jl=jm# and replace either the lower limit
else:
ju=jm# or the upper limit, as appropriate.
# Repeat until the test condition is satisfied.
if (value == array[0]):# edge cases at bottom
return 0
elif (value == array[n-1]):# and top
return n-1
else:
return jl
现在我将从其他答案中定义代码，它们各自返回一个索引：
import math
import numpy as np
def find_nearest1(array,value):
idx,val = min(enumerate(array), key=lambda x: abs(x[1]-value))
return idx
def find_nearest2(array, values):
indices = np.abs(np.subtract.outer(array, values)).argmin(0)
return indices
def find_nearest3(array, values):
values = np.atleast_1d(values)
indices = np.abs(np.int64(np.subtract.outer(array, values))).argmin(0)
out = array[indices]
return indices
def find_nearest4(array,value):
idx = (np.abs(array-value)).argmin()
return idx
def find_nearest5(array, value):
idx_sorted = np.argsort(array)
sorted_array = np.array(array[idx_sorted])
idx = np.searchsorted(sorted_array, value, side="left")
if idx >= len(array):
idx_nearest = idx_sorted[len(array)-1]
elif idx == 0:
idx_nearest = idx_sorted[0]
else:
if abs(value - sorted_array[idx-1]) < abs(value - sorted_array[idx]):
idx_nearest = idx_sorted[idx-1]
else:
idx_nearest = idx_sorted[idx]
return idx_nearest
def find_nearest6(array,value):
xi = np.argmin(np.abs(np.ceil(array[None].T - value)),axis=0)
return xi
现在我要给代码计时： 注意方法1,2,4,5没有正确给出间隔。方法1,2,4舍入到阵列中的最近点（例如，> = 1.5 - > 2），并且方法5总是向上舍入（例如1.45 - > 2）。只有方法3和6，当然还有二分法才能正确地给出间隔。
array = np.arange(100000)
val = array[50000]+0.55
print( bisection(array,val))
%timeit bisection(array,val)
print( find_nearest1(array,val))
%timeit find_nearest1(array,val)
print( find_nearest2(array,val))
%timeit find_nearest2(array,val)
print( find_nearest3(array,val))
%timeit find_nearest3(array,val)
print( find_nearest4(array,val))
%timeit find_nearest4(array,val)
print( find_nearest5(array,val))
%timeit find_nearest5(array,val)
print( find_nearest6(array,val))
%timeit find_nearest6(array,val)
(50000, 50000)
100000 loops, best of 3: 4.4 µs per loop
50001
1 loop, best of 3: 180 ms per loop
50001
1000 loops, best of 3: 267 µs per loop
[50000]
1000 loops, best of 3: 390 µs per loop
50001
1000 loops, best of 3: 259 µs per loop
50001
1000 loops, best of 3: 1.21 ms per loop
[50000]
1000 loops, best of 3: 746 µs per loop
对于大阵列，二分法给出4us与下一个最佳180us相比，最长1.21ms（快~100-1000倍）。对于较小的阵列，它的速度要快〜2-100倍。
答案 4 :(得分：16)
这是一个扩展，用于在向量数组中找到最近的向量。
import numpy as np
def find_nearest_vector(array, value):
idx = np.array([np.linalg.norm(x+y) for (x,y) in array-value]).argmin()
return array[idx]
A = np.random.random((10,2))*100
""" A = array([[ 34.19762933, 43.14534123],
[ 48.79558706, 47.79243283],
[ 38.42774411, 84.87155478],
[ 63.64371943, 50.7722317 ],
[ 73.56362857, 27.87895698],
[ 96.67790593, 77.76150486],
[ 68.86202147, 21.38735169],
[ 5.21796467, 59.17051276],
[ 82.92389467, 99.90387851],
[ 6.76626539, 30.50661753]])"""
pt = [6, 30]
print find_nearest_vector(A,pt)
# array([ 6.76626539, 30.50661753])
答案 5 :(得分：9)
这是一个处理非标量“值”数组的版本：
import numpy as np
def find_nearest(array, values):
indices = np.abs(np.subtract.outer(array, values)).argmin(0)
return array[indices]
如果输入是标量，则返回数值类型的版本（例如int，float）：
def find_nearest(array, values):
values = np.atleast_1d(values)
indices = np.abs(np.subtract.outer(array, values)).argmin(0)
out = array[indices]
return out if len(out) > 1 else out[0]
答案 6 :(得分：9)
如果您不想使用numpy，可以这样做：
def find_nearest(array, value):
n = [abs(i-value) for i in array]
idx = n.index(min(n))
return array[idx]
答案 7 :(得分：8)
这是@Ari Onasafari的scipy版本，回答“ 在矢量数组中找到最近的矢量 ”
In [1]: from scipy import spatial
In [2]: import numpy as np
In [3]: A = np.random.random((10,2))*100
In [4]: A
Out[4]:
array([[ 68.83402637, 38.07632221],
[ 76.84704074, 24.9395109 ],
[ 16.26715795, 98.52763827],
[ 70.99411985, 67.31740151],
[ 71.72452181, 24.13516764],
[ 17.22707611, 20.65425362],
[ 43.85122458, 21.50624882],
[ 76.71987125, 44.95031274],
[ 63.77341073, 78.87417774],
[ 8.45828909, 30.18426696]])
In [5]: pt = [6, 30] # <-- the point to find
In [6]: A[spatial.KDTree(A).query(pt)[1]] # <-- the nearest point
Out[6]: array([ 8.45828909, 30.18426696])
#how it works!
In [7]: distance,index = spatial.KDTree(A).query(pt)
In [8]: distance # <-- The distances to the nearest neighbors
Out[8]: 2.4651855048258393
In [9]: index # <-- The locations of the neighbors
Out[9]: 9
#then
In [10]: A[index]
Out[10]: array([ 8.45828909, 30.18426696])
答案 8 :(得分：7)
对于大型阵列，@ Demitri给出的（优秀）答案远远快于目前标记为最佳的答案。我已经通过以下两种方式调整了他的确切算法：
无论输入数组是否已排序，下面的函数都有效。
下面的函数返回与最接近的值对应的输入数组的索引，这更为一般。
请注意，下面的函数还处理特定的边缘情况，这会导致@Demitri编写的原始函数中的错误。否则，我的算法与他的算法相同。
def find_idx_nearest_val(array, value):
idx_sorted = np.argsort(array)
sorted_array = np.array(array[idx_sorted])
idx = np.searchsorted(sorted_array, value, side="left")
if idx >= len(array):
idx_nearest = idx_sorted[len(array)-1]
elif idx == 0:
idx_nearest = idx_sorted[0]
else:
if abs(value - sorted_array[idx-1]) < abs(value - sorted_array[idx]):
idx_nearest = idx_sorted[idx-1]
else:
idx_nearest = idx_sorted[idx]
return idx_nearest
答案 9 :(得分：3)
如果您有许多values要搜索（values可以是多维数组），这是@ Dimitri解决方案的快速矢量化版本：
#`values` should be sorted
def get_closest(array, values):
#make sure array is a numpy array
array = np.array(array)
# get insert positions
idxs = np.searchsorted(array, values, side="left")
# find indexes where previous index is closer
prev_idx_is_less = ((idxs == len(array))|(np.fabs(values - array[np.maximum(idxs-1, 0)]) < np.fabs(values - array[np.minimum(idxs, len(array)-1)])))
idxs[prev_idx_is_less] -= 1
return array[idxs]
<强>基准
＆GT;比使用@ Demitri解决方案的for循环快100倍
>>> %timeit ar=get_closest(np.linspace(1, 1000, 100), np.random.randint(0, 1050, (1000, 1000)))
139 ms ± 4.04 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
>>> %timeit ar=[find_nearest(np.linspace(1, 1000, 100), value) for value in np.random.randint(0, 1050, 1000*1000)]
took 21.4 seconds
答案 10 :(得分：3)
这是unutbu's answer的矢量版本：
def find_nearest(array, values):
array = np.asarray(array)
# the last dim must be 1 to broadcast in (array - values) below.
values = np.expand_dims(values, axis=-1)
indices = np.abs(array - values).argmin(axis=-1)
return array[indices]
image = plt.imread('example_3_band_image.jpg')
print(image.shape) # should be (nrows, ncols, 3)
quantiles = np.linspace(0, 255, num=2 ** 2, dtype=np.uint8)
quantiled_image = find_nearest(quantiles, image)
print(quantiled_image.shape) # should be (nrows, ncols, 3)
答案 11 :(得分：1)
我认为最狡猾的方式是：
num = 65 # Input number
array = n.random.random((10))*100 # Given array
nearest_idx = n.where(abs(array-num)==abs(array-num).min())[0] # If you want the index of the element of array (array) nearest to the the given number (num)
nearest_val = array[abs(array-num)==abs(array-num).min()] # If you directly want the element of array (array) nearest to the given number (num)
这是基本代码。如果需要，可以将其用作函数
答案 12 :(得分：1)
所有答案都有利于收集信息以编写有效的代码。但是，我编写了一个小的Python脚本来针对各种情况进行优化。如果提供的数组已排序，那将是最好的情况。如果搜索指定值的最近点的索引，则bisect模块是最有效的时间。当一个搜索索引对应一个数组时，numpy searchsorted最有效。
import numpy as np
import bisect
xarr = np.random.rand(int(1e7))
srt_ind = xarr.argsort()
xar = xarr.copy()[srt_ind]
xlist = xar.tolist()
bisect.bisect_left(xlist, 0.3)
在[63]中：％time bisect.bisect_left（xlist，0.3） CPU时间：用户0 ns，sys：0 ns，总计：0 ns 壁时间：22.2μs
np.searchsorted(xar, 0.3, side="left")
在[64]中：％time np.searchsorted（xar，0.3，side =“left”） CPU时间：用户0 ns，sys：0 ns，总计：0 ns 壁挂时间：98.9μs
randpts = np.random.rand(1000)
np.searchsorted(xar, randpts, side="left")
％time np.searchsorted（xar，randpts，side =“left”） CPU时间：用户4 ms，sys：0 ns，总计：4 ms 壁挂时间：1.2毫秒
如果我们遵循乘法规则，那么numpy应该需要~100 ms，这意味着快〜83倍。
答案 13 :(得分：0)
import numpy as np
def find_nearest(array, value):
array = np.array(array)
z=np.abs(array-value)
y= np.where(z == z.min())
m=np.array(y)
x=m[0,0]
y=m[1,0]
near_value=array[x,y]
return near_value
array =np.array([[60,200,30],[3,30,50],[20,1,-50],[20,-500,11]])
print(array)
value = 0
print(find_nearest(array, value))
答案 14 :(得分：0)
可能对ndarrays有帮助：
def find_nearest(X, value):
return X[np.unravel_index(np.argmin(np.abs(X - value)), X.shape)]
答案 15 :(得分：0)
对于2d数组，确定最近元素的i，j位置：
import numpy as np
def find_nearest(a, a0):
idx = (np.abs(a - a0)).argmin()
w = a.shape[1]
i = idx // w
j = idx - i * w
return a[i,j], i, j
答案 16 :(得分：0)
这是一个适用于 2D 数组的版本，如果用户拥有它，则使用 scipy 的 cdist 函数，如果用户没有，则使用更简单的距离计算。
默认情况下，输出是与您输入的值最接近的索引，但您可以使用 output 关键字将其更改为 'index'、'value' 或'both'，其中 'value' 输出 array[index]，'both' 输出 index, array[index]。
对于非常大的数组，您可能需要使用 kind='euclidean'，因为默认的 scipy cdist 函数可能会耗尽内存。
这可能不是绝对最快的解决方案，但已经很接近了。
def find_nearest_2d(array, value, kind='cdist', output='index'):
# 'array' must be a 2D array
# 'value' must be a 1D array with 2 elements
# 'kind' defines what method to use to calculate the distances. Can choose one
# of 'cdist' (default) or 'euclidean'. Choose 'euclidean' for very large
# arrays. Otherwise, cdist is much faster.
# 'output' defines what the output should be. Can be 'index' (default) to return
# the index of the array that is closest to the value, 'value' to return the
# value that is closest, or 'both' to return index,value
import numpy as np
if kind == 'cdist':
try: from scipy.spatial.distance import cdist
except ImportError:
print("Warning (find_nearest_2d): Could not import cdist. Reverting to simpler distance calculation")
kind = 'euclidean'
index = np.where(array == value)[0] # Make sure the value isn't in the array
if index.size == 0:
if kind == 'cdist': index = np.argmin(cdist([value],array)[0])
elif kind == 'euclidean': index = np.argmin(np.sum((np.array(array)-np.array(value))**2.,axis=1))
else: raise ValueError("Keyword 'kind' must be one of 'cdist' or 'euclidean'")
if output == 'index': return index
elif output == 'value': return array[index]
elif output == 'both': return index,array[index]
else: raise ValueError("Keyword 'output' must be one of 'index', 'value', or 'both'")
答案 17 :(得分：0)
对于那些搜索多个最近的人，修改接受的答案：
import numpy as np
def find_nearest(array, value, k):
array = np.asarray(array)
idx = np.argsort(abs(array - value))[:k]
return array[idx]