सुन्न सरणी में निकटतम मूल्य का पता लगाएं


336

क्या किसी सरणी में निकटतम मान ज्ञात करने के लिए एक संख्यात्मक-थोनिक तरीका है, उदाहरण के लिए फ़ंक्शन ?

उदाहरण:

np.find_nearest( array, value )

जवाबों:


516
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

52
@ ईओएल: return np.abs(array-value).min()गलत जवाब देता है। यह आपको निरपेक्ष मूल्य दूरी का न्यूनतम देता है, और किसी तरह हमें वास्तविक सरणी मान को वापस करने की आवश्यकता होती है। हम जोड़ सकते हैं valueऔर करीब आ सकते हैं , लेकिन निरपेक्ष मूल्य चीजों में एक
खाई

9
@ ~ अनुतु तुम सही हो, मेरा बुरा। मैं आपके समाधान से बेहतर कुछ नहीं सोच सकता!
एरिक ओ लेबिगोट

24
लगता है कि वहाँ एक सुस्वादु निर्मित नहीं है जो ऐसा करता है।
dbliss

3
@jsmedmar द्वि घातुमान विधि (मेरे उत्तर के नीचे देखें) हे (लॉग (n)) है।
जोश अल्बर्ट

4
FutureWarning: 'argmin' is deprecated. Use 'idxmin' instead. The behavior of 'argmin' will be corrected to return the positional minimum in the future. Use 'series.values.argmin' to get the position of the minimum now.ऊपर दिए गए समाधान के साथ मेरे लिए काम के idxminबजाय का उपयोग करना argmin। (v3.6.4)
जोरिजेन्स्मिट

78

यदि आपकी सरणी सॉर्ट की गई है और बहुत बड़ी है, तो यह बहुत तेज़ समाधान है:

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]

यह बहुत बड़े सरणियों को मापता है। यदि आप मान नहीं सकते हैं कि सरणी पहले से ही क्रमबद्ध है, तो आप आसानी से उपरोक्त को संशोधित कर सकते हैं। यह छोटे सरणियों के लिए ओवरकिल है, लेकिन एक बार जब वे बड़े हो जाते हैं तो यह बहुत तेज होता है।


यह सबसे उचित समाधान की तरह लगता है। मुझे आश्चर्य है कि यह वैसे भी इतना धीमा क्यों है। सादा np.searchsortedमेरे परीक्षण सेट के बारे में 2 µ लेता है, पूरे समारोह में 10 µ के बारे में। इसके इस्तेमाल np.absसे और भी बुरा हो रहा है। अजगर वहाँ क्या कर रहा है कोई सुराग नहीं।
माइकल

2
@ मिचेल एकल मूल्यों के लिए, नेम्पी गणित की दिनचर्या दिनचर्या से धीमी होगी math, इस उत्तर को देखें ।
डेमित्रि

3
यदि आप एक बार (कुछ समायोजन के साथ) देखना चाहते हैं, तो यह सबसे अच्छा समाधान है। पूरी if/elseकरने की जरूरत हैidx = idx - (np.abs(value - array[idx-1]) < np.abs(value - array[idx])); return array[idx]
कोडरफोर्निफाइल

3
यह बहुत अच्छा है, लेकिन अगर सबसे बड़े तत्व valueसे बड़ा है तो यह काम नहीं करता है array। मैंने इसे अपने लिए काम ifकरने के if idx == len(array) or math.fabs(value - array[idx - 1]) < math.fabs(value - array[idx])लिए बयान बदल दिया !
निको

3
जब idx 0. है तो यह काम नहीं करता है। यदि पढ़ना चाहिए:if idx > 0 and (idx == len(array) or math.fabs(value - array[idx-1]) < math.fabs(value - array[idx])):
JPaget

52

मामूली संशोधन के साथ, ऊपर दिए गए उत्तर मनमाने ढंग से आयाम (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()]

6
"फ्लैट" बिट आवश्यक नहीं है। a[np.abs(a-a0).argmin)]ठीक काम करता है।
मैक्स शेरोन

2
दरअसल, यह अभी भी केवल एक आयाम के लिए काम करता है, क्योंकि argmin () प्रति कॉलम / आयाम में कई परिणाम देता है। इसके अलावा मेरे पास एक टाइपो था। यह काम करता है, कम से कम 2 आयामों के लिए a[np.sum(np.square(np.abs(a-a0)),1).argmin()]:।
मैक्स श्रोन

3
तो, यह उच्च आयामों के लिए काम नहीं करता है, और उत्तर को हटा दिया जाना चाहिए (या इसे प्रतिबिंबित करने के लिए संशोधित किया गया है)
ह्यूजेस फोंटनेल

11
कृपया एक उदाहरण प्रदान करें जहां प्रस्तावित उत्तर कोई काम नहीं करता है। यदि आप एक पाते हैं तो मैं अपना उत्तर संशोधित करूंगा। अगर आपको एक नहीं मिल रहा है तो क्या आप अपनी टिप्पणी हटा सकते हैं?
kwgoodman

18

उत्तर का सारांश : यदि किसी ने छांट लिया है, arrayतो द्विसंयोजक कोड (नीचे दिया गया) सबसे तेज़ प्रदर्शन करता है। बड़े सरणियों के लिए ~ 100-1000 गुना तेजी से, और छोटे सरणियों के लिए ~ 2-100 गुना तेजी से। इसे सुन्न करने की भी आवश्यकता नहीं है। यदि आपके पास एक अनसुलझा है, arrayतो यदि arrayबड़ा है, तो पहले एक ओ (एन लोगन) सॉर्ट और फिर बिसनेस का उपयोग करने पर विचार करना चाहिए, और यदि arrayछोटा है तो विधि 2 सबसे तेज़ लगती है।

पहले आपको स्पष्ट करना चाहिए कि निकटतम मूल्य से आपका क्या मतलब है । अक्सर एक अनुपस्थिति में अंतराल चाहता है, उदाहरण के लिए सरणी = [0,0.7,2.1], मूल्य = 1.95, उत्तर idx = 1 होगा। यह मामला है कि मुझे संदेह है कि आपको ज़रूरत है (अन्यथा आप अंतराल के बाद एक बार एक अनुवर्ती सशर्त विवरण के साथ बहुत आसानी से संशोधित किया जा सकता है)। मैं ध्यान दूंगा कि यह प्रदर्शन करने का इष्टतम तरीका द्विध्रुवता के साथ है (जो मैं पहले प्रदान करूंगा - ध्यान दें कि इसे बिल्कुल भी खस्ता होने की आवश्यकता नहीं है और खस्ता कार्यों का उपयोग करने की तुलना में तेज है क्योंकि वे निरर्थक संचालन करते हैं)। फिर मैं अन्य उपयोगकर्ताओं द्वारा यहां प्रस्तुत किए गए अन्य के मुकाबले एक समय की तुलना प्रदान करूंगा।

द्विभाजन:

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

एक बड़े सरणी के लिए द्विभाजन अगले सर्वश्रेष्ठ 180us और सबसे लंबे 1.21ms (~ 100 - 1000 गुना तेज) की तुलना में 4us देता है। छोटे सरणियों के लिए यह ~ 2-100 गुना तेज है।


2
आप मान रहे हैं कि सरणी क्रमबद्ध है। ऐसे कई कारण हैं कि कोई व्यक्ति सरणी को क्रमबद्ध नहीं करना चाहेगा: उदाहरण के लिए, यदि सरणी रेखा रेखा पर डेटा बिंदुओं का प्रतिनिधित्व करती है।
user1917407

7
अजगर मानक पुस्तकालय में पहले से ही द्विआधारी
फेलिक्स

जब आपने कहा, "यदि arrayछोटा है तो विधि 2 सबसे तेज़ लगती है।" कितने छोटे मतलब @JoshAlbert थे?
श्रीजयूस

2
यह निकटतम मान नहीं पाता है, यह अगले-निम्नतम मान पाता है।
20

@endolith यह केवल द्विशताब्दी के लिए मामला है।
होमरो एस्मेराल्डो

17

यहाँ वैक्टर की एक सरणी में निकटतम वेक्टर को खोजने के लिए एक विस्तार दिया गया है।

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

मुझे लगता है कि पायथन पुनरावृत्ति के माध्यम से मूल्यों को norm(..., axis=-1)निकालने से तेज होना चाहिए x,y। इसके अलावा, x,yयहाँ स्केलर हैं? तब norm(x+y)से एक बग है, उदाहरण के लिए, दूरी (+1, -1)
cfh

यह मेरे लिए काम करता हैidx = np.array([np.linalg.norm(x+y) for (x,y) in abs(array-value)]).argmin()
ezchx

9

यदि आप numpy का उपयोग नहीं करना चाहते हैं तो यह कर देगा:

def find_nearest(array, value):
    n = [abs(i-value) for i in array]
    idx = n.index(min(n))
    return array[idx]

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]

अच्छा जवाब, मैंने पहले कभी outerufunc की विधि का उपयोग नहीं किया है , मुझे लगता है कि मैं भविष्य में इसका अधिक उपयोग करूंगा। पहले समारोह को वापस आना चाहिए array[indices], वैसे।
विडजेट

1
यह समाधान पैमाना नहीं है। np.subtract.outerपूरे बाहरी-उत्पाद मैट्रिक्स को उत्पन्न करेगा जो वास्तव में धीमा है और स्मृति गहन है अगर arrayऔर / या valuesबहुत बड़ी है।
एन्थोनीबेल

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

यहाँ @ दिमित्री के समाधान का एक तेज़ वेक्टर संस्करण है, यदि आपके पास कई valuesखोज करने के लिए है ( valuesबहु-आयामी सरणी हो सकता है):

#`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]

मानक

> 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

यदि आपके पास सरणी में निरंतर नमूना है, तो यह और भी सरल हो जाता है: idx = np.searchsorted(array, values)फिर: idx[array[idx] - values>np.diff(array).mean()*0.5]-=1और अंत मेंreturn array[idx]
सर्गेई एंटोपोलस्की

7

बड़े सरणियों के लिए, @Demitri द्वारा दिया गया उत्कृष्ट (उत्कृष्ट) उत्तर वर्तमान में सबसे अच्छे के रूप में चिह्नित किए गए उत्तर से कहीं अधिक तेज है। मैंने निम्नलिखित दो तरीकों से उनके सटीक एल्गोरिदम को अनुकूलित किया है:

  1. नीचे दिया गया कार्य इनपुट ऐरे को क्रमबद्ध करता है या नहीं।

  2. नीचे दिया गया फ़ंक्शन निकटतम मान के अनुरूप इनपुट सरणी के सूचकांक को लौटाता है , जो कि कुछ अधिक सामान्य है।

ध्यान दें कि नीचे दिया गया फ़ंक्शन भी एक विशिष्ट एज केस को हैंडल करता है जो @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

1
यह इंगित करने योग्य है कि यह एक बेहतरीन उदाहरण है कि कैसे अनुकूलन कोड इसे बदसूरत और पढ़ने में कठिन बना देता है। @Unutbu द्वारा दिया गया उत्तर उन मामलों में अधिक पसंद किया जाना चाहिए जहां गति एक बड़ी चिंता का विषय नहीं है, क्योंकि यह कहीं अधिक पारदर्शी है।
aph

मैं @Michael द्वारा दिए गए उत्तर को नहीं देखता हूं। क्या यह एक त्रुटि है या मैं अंधा हूं?
फुचचू

नहीं, तुम अंधे नहीं हो, मैं सिर्फ अनपढ़ हूं ;-) यह @Demitri था जिसका जवाब मैं सोच रहा था। मेरी गलती। मैंने अभी अपनी पोस्ट ठीक की है। धन्यवाद!
aph

मुझे देमित्री और तुम्हारे साथ अलग-अलग उत्तर मिलते हैं। कोई विचार? x = np.array([2038, 1758, 1721, 1637, 2097, 2047, 2205, 1787, 2287, 1940, 2311, 2054, 2406, 1471, 1460])। के साथ find_nearest(x, 1739.5)(पहली मात्रा के निकटतम मूल्य), मुझे 1637(उचित) और 1(बग?) मिलता है।
पैट्रिकटी

3

यह अनटुब के उत्तर का एक वेक्टरकृत संस्करण है :

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)

2

मुझे लगता है कि सबसे अधिक पायथोनिक तरीका होगा:

 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)

यह मूल कोड है। आप चाहें तो इसे फंक्शन के रूप में इस्तेमाल कर सकते हैं


2

कुशल कोड लिखने के लिए जानकारी इकट्ठा करने के लिए सभी उत्तर फायदेमंद हैं। हालाँकि, मैंने विभिन्न मामलों के अनुकूलन के लिए एक छोटी पायथन स्क्रिप्ट लिखी है। यदि प्रदान की गई सरणी को क्रमबद्ध किया जाता है तो यह सबसे अच्छा मामला होगा। यदि कोई निर्दिष्ट मान के निकटतम बिंदु के सूचकांक को खोजता है, तो 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)

[६३]:% समय bisect.bisect_left (xlist, ०.३) सीपीयू समय: उपयोगकर्ता ० एन एस, एसआईएस: ० एन एस, कुल: ० एनएस दीवार समय: २२.२ %s

np.searchsorted(xar, 0.3, side="left")

[६४]:% समय np.searchsorted (xar, ०.३, साइड = "लेफ्ट") CPU समय: उपयोगकर्ता ० एनएस, एसआईएस: ० एनएस, कुल: ० एनएस दीवार समय: ९ µ.९%

randpts = np.random.rand(1000)
np.searchsorted(xar, randpts, side="left")

% समय np.searchsorted (xar, randpts, side = "left") CPU समय: उपयोगकर्ता 4 ms, sys: 0 ns, कुल: 4 ms दीवार समय: 1.2 ms

यदि हम गुणन नियम का पालन करते हैं, तो numpy ~ 100 ms लेना चाहिए जिसका अर्थ है ~ 83X तेज।


1

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

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

1
नमस्ते, ढेर अतिप्रवाह में आपका स्वागत है। एक अच्छा उत्तर लिखने का तरीका देखें । प्रश्न के संदर्भ में आपने जो किया उसका संक्षिप्त विवरण देने का प्रयास करें!
ट्रिस्टो

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.