NumPy 1.14 - numpy.choose()

numpy.choose




numpy

numpy.choose

numpy.choose(a, choices, out=None, mode='raise') [source]

एक सूचकांक सरणी से एक सरणी का निर्माण और से चुनने के लिए सरणियों का एक सेट।

सबसे पहले, यदि भ्रमित या अनिश्चित है, तो निश्चित रूप से उदाहरण देखें - अपनी पूरी व्यापकता में, यह फ़ंक्शन निम्न कोड विवरण (ndi = numpy.lib.index_tricks नीचे) से लग सकता है की तुलना में कम सरल है:

np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])

लेकिन यह कुछ सूक्ष्मताओं को छोड़ देता है। यहाँ एक पूरी तरह से सामान्य सारांश है:

पूर्णांक के "इंडेक्स" a ( a ) और n सरणियों ( choices ) के अनुक्रम को देखते हुए, a और प्रत्येक पसंद सरणी को पहले प्रसारित किया जाता है, आवश्यक रूप से, एक सामान्य आकार के सरणियों के लिए; इन बा और Bchoices को कॉल करना [i], i = 0,…, n-1 हमारे पास है, जरूरी है, Ba.shape == Bchoices[i].shape । प्रत्येक के लिए। फिर, आकृति Ba.shape साथ एक नई सरणी निम्नानुसार बनाई गई है:

  • अगर mode=raise (डिफ़ॉल्ट), तो, सबसे पहले, प्रत्येक तत्व (और इस प्रकार Ba ) की सीमा [0, n-1] में होनी चाहिए; अब, मान लीजिए कि i (उस श्रेणी में) (j0, j1, …, jm) में मान (j0, j1, …, jm) का मान है - फिर नए सरणी में उसी स्थिति में मान Bchoices[i] में मूल्य है Bchoices[i] उसी पर पद;
  • अगर mode=wrap , (और इस प्रकार Ba ) में मान किसी भी (हस्ताक्षरित) पूर्णांक हो सकते हैं; मॉड्यूलर अंकगणित का उपयोग उस सीमा के बाहर पूर्णांक को मैप करने के लिए किया जाता है [0, n-1] वापस उस सीमा में; और फिर नए सरणी का निर्माण ऊपर किया गया है;
  • अगर mode=clip , (और इस प्रकार Ba ) में मान किसी भी (हस्ताक्षरित) पूर्णांक हो सकते हैं; नकारात्मक पूर्णांक 0 से मैप किए जाते हैं; n-1 से अधिक मान n-1 पर मैप किए जाते हैं; और फिर नए सरणी का निर्माण ऊपर किया गया है।
पैरामीटर:

a : int सरणी

इस सरणी में पूर्णांक होना चाहिए [0, n-1] , जहां n पसंद की संख्या है, जब तक कि mode=wrap या mode=clip , जिसमें किसी भी पूर्णांक की अनुमति है।

विकल्प : सरणियों का क्रम

विकल्प सरणियाँ। a और सभी विकल्पों को एक ही आकार में प्रसारित किया जाना चाहिए। यदि choices अपने आप में एक सरणी है (अनुशंसित नहीं है), तो इसका बाहरी आयाम (यानी, पसंद के अनुसार एक है। शेष choices.shape[0] ) को "अनुक्रम" को परिभाषित करने के रूप में लिया जाता है।

बाहर : सरणी, वैकल्पिक

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

मोड : {'उठाना' (डिफ़ॉल्ट), 'रैप', 'क्लिप'}, वैकल्पिक

निर्दिष्ट करता है कि बाहर के संकेत कैसे [0, n-1] का इलाज किया जाएगा:

  • 'बढ़ाएँ': एक अपवाद उठाया जाता है
  • 'रैप': वैल्यू वैल्यू मॉड n हो जाता है
  • 'क्लिप': मान <0 को 0 पर मैप किया जाता है, मान> n-1 को n-1 से मैप किया जाता है
यह दिखाता है:

merged_array : सरणी

मर्ज किया गया परिणाम।

जन्म देती है:

ValueError: आकार बेमेल

अगर a और प्रत्येक पसंद सरणी सभी एक ही आकार के लिए प्रसारण योग्य नहीं हैं।

यह भी देखें

ndarray.choose
समकक्ष विधि

टिप्पणियाँ

गलत व्याख्या की संभावना को कम करने के लिए, भले ही निम्नलिखित "दुरुपयोग" नाममात्र का समर्थन किया हो, choices न तो होना चाहिए, न ही इस बारे में सोचा जाना चाहिए, एक एकल सरणी, यानी, बाहरी अनुक्रम जैसा कंटेनर या तो एक सूची या टपल होना चाहिए।

उदाहरण

>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
...   [20, 21, 22, 23], [30, 31, 32, 33]]
>>> np.choose([2, 3, 1, 0], choices
... # the first element of the result will be the first element of the
... # third (2+1) "array" in choices, namely, 20; the second element
... # will be the second element of the fourth (3+1) choice array, i.e.,
... # 31, etc.
... )
array([20, 31, 12,  3])
>>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
array([20, 31, 12,  3])
>>> # because there are 4 choice arrays
>>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
array([20,  1, 12,  3])
>>> # i.e., 0

एक उदाहरण उदाहरण दिखाता है कि प्रसारण कैसे चुनें:

>>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
>>> choices = [-10, 10]
>>> np.choose(a, choices)
array([[ 10, -10,  10],
       [-10,  10, -10],
       [ 10, -10,  10]])
>>> # With thanks to Anne Archibald
>>> a = np.array([0, 1]).reshape((2,1,1))
>>> c1 = np.array([1, 2, 3]).reshape((1,3,1))
>>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
>>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
array([[[ 1,  1,  1,  1,  1],
        [ 2,  2,  2,  2,  2],
        [ 3,  3,  3,  3,  3]],
       [[-1, -2, -3, -4, -5],
        [-1, -2, -3, -4, -5],
        [-1, -2, -3, -4, -5]]])