NumPy 1.14 - numpy.take()

numpy.take




numpy

numpy.take

numpy.take(a, indices, axis=None, out=None, mode='raise') [source]

एक अक्ष के साथ एक सरणी से तत्व लें।

जब अक्ष कोई भी नहीं होता है, तो यह फ़ंक्शन "फैंसी" अनुक्रमण (सरणियों का उपयोग करते हुए अनुक्रमणिका) के रूप में एक ही काम करता है; हालाँकि, यदि आप किसी दिए गए अक्ष के साथ तत्वों की आवश्यकता है तो इसका उपयोग करना आसान हो सकता है। np.take(arr, indices, axis=3) रूप में एक कॉल np.take(arr, indices, axis=3) बराबर है arr[:,:,:,indices,...]

फैंसी इंडेक्सिंग के बिना समझाया गया, यह ndindex के निम्न उपयोग के ndindex , जो ii प्रत्येक, jj और kk को सूचकांकों के समूह में सेट करता है:

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
Nj = indices.shape
for ii in ndindex(Ni):
    for jj in ndindex(Nj):
        for kk in ndindex(Nk):
            out[ii + jj + kk] = a[ii + (indices[jj],) + kk]
पैरामीटर:

a : array_like (नी…, M, Nk…)

स्रोत सरणी।

सूचकांक : array_like (Nj…)

मूल्यों के सूचकांकों को निकालने के लिए।

संस्करण 1.8.0 में नया।

सूचकांकों के लिए स्केलर की भी अनुमति दें।

अक्ष : int, वैकल्पिक

वह अक्ष जिस पर मानों का चयन करना है। डिफ़ॉल्ट रूप से, चपटा इनपुट सरणी का उपयोग किया जाता है।

बाहर : ndarray, वैकल्पिक (नी…, एनजे…, एनके…)

यदि प्रदान किया जाता है, तो परिणाम इस सरणी में रखा जाएगा। यह उचित आकार और dtype का होना चाहिए।

मोड : {'उठाना', 'रैप', 'क्लिप'}, वैकल्पिक

निर्दिष्ट करता है कि बाहर के सूचकांकों का व्यवहार कैसे होगा।

  • 'बढ़ाएँ' - एक त्रुटि बढ़ाएँ (डिफ़ॉल्ट)
  • 'लपेटो' - चारों ओर लपेटो
  • 'क्लिप' - श्रेणी के लिए क्लिप

'क्लिप' मोड का अर्थ है कि सभी सूचक जो बहुत बड़े हैं, उन्हें उस अक्ष के अंतिम तत्व को संबोधित करने वाले सूचकांक द्वारा प्रतिस्थापित किया जाता है। ध्यान दें कि यह नकारात्मक संख्याओं के साथ अनुक्रमण को अक्षम करता है।

यह दिखाता है:

बाहर : ndarray (नी…, एनजे…, एनके…)

लौटे सरणी में एक ही प्रकार a

यह भी देखें

compress
बुलियन मास्क का उपयोग करने वाले तत्व लें
ndarray.take
समकक्ष विधि

टिप्पणियाँ

ऊपर दिए गए विवरण में आंतरिक लूप को समाप्त करके, सरल स्लाइस ऑब्जेक्ट बनाने के लिए s_ का उपयोग करके, प्रत्येक 1-डी स्लाइस पर फैंसी इंडेक्सिंग लागू करने के संदर्भ में take जा सकता है:

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nj):
        out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices]

इस कारण से, यह apply_along_axis के निम्नलिखित उपयोग के बराबर (लेकिन इससे भी तेज) है:

out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a)

उदाहरण

>>> a = [4, 3, 5, 7, 6, 8]
>>> indices = [0, 1, 4]
>>> np.take(a, indices)
array([4, 3, 6])

इस उदाहरण में यदि a ndarray है, तो "फैंसी" अनुक्रमण का उपयोग किया जा सकता है।

>>> a = np.array(a)
>>> a[indices]
array([4, 3, 6])

यदि indices एक आयामी नहीं है, तो आउटपुट में भी ये आयाम हैं।

>>> np.take(a, [[0, 1], [2, 3]])
array([[4, 3],
       [5, 7]])