NumPy 1.14 - numpy.vectorize()

numpy.vectorize




numpy

numpy.vectorize

class numpy.vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None) [source]

सामान्यीकृत फ़ंक्शन वर्ग।

एक वेक्टरकृत फ़ंक्शन को परिभाषित करें जो इनपुट के रूप में वस्तुओं या संख्यात्मक सरणियों का एक नेस्टेड अनुक्रम लेता है और आउटपुट के रूप में एक या एक से अधिक संख्या में टपील देता है। pyfunc गए फ़ंक्शन, अजगर मानचित्र फ़ंक्शन की तरह इनपुट सरणियों के क्रमिक tuples पर pyfunc मूल्यांकन करता है, सिवाय इसके कि यह संख्यात्मक के प्रसारण नियमों का उपयोग करता है।

vectorized के आउटपुट के डेटा प्रकार को इनपुट के पहले तत्व के साथ फ़ंक्शन को कॉल करके निर्धारित किया जाता है। otypes तर्क को निर्दिष्ट करके इससे बचा जा सकता है।

पैरामीटर:

pyfunc : callable

एक अजगर समारोह या विधि।

otypes : str या dtypes की सूची, वैकल्पिक

आउटपुट डेटा प्रकार। इसे या तो टाइपबाउंड वर्णों की एक स्ट्रिंग या डेटा प्रकार विनिर्देशक की सूची के रूप में निर्दिष्ट किया जाना चाहिए। प्रत्येक आउटपुट के लिए एक डेटा प्रकार निर्दिष्ट होना चाहिए।

डॉक्टर : str, वैकल्पिक

समारोह के लिए docstring। यदि None , तो pyfunc.__doc__

बाहर रखा गया : सेट, वैकल्पिक

स्थिति या कीवर्ड तर्क का प्रतिनिधित्व करने वाले तार या पूर्णांक का सेट, जिसके लिए फ़ंक्शन को वेक्टर नहीं किया जाएगा। इन्हें सीधे pyfunc पास किया जाएगा।

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

कैश : बूल, वैकल्पिक

यदि True , तो पहला फ़ंक्शन कॉल कैश करें जो कि आउटपुट की संख्या निर्धारित करता है यदि otypes प्रदान नहीं किया गया है।

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

हस्ताक्षर : स्ट्रिंग, वैकल्पिक

सामान्यीकृत सार्वभौमिक फ़ंक्शन हस्ताक्षर, जैसे, (m,n),(n)->(m) वेक्टराइज्ड मैट्रिक्स-वेक्टर गुणन के लिए। यदि प्रदान किया जाता है, तो pyfunc को इसी कोर आयामों के आकार द्वारा दिए गए आकृतियों के साथ सरणियों (और लौटने की उम्मीद) के साथ बुलाया जाएगा। डिफ़ॉल्ट रूप से, pyfunc को इनपुट और आउटपुट के रूप में स्केलर लेने के लिए माना जाता है।

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

यह दिखाता है:

वेक्टरकृत : कॉल करने योग्य

सदिश समारोह।

यह भी देखें

frompyfunc
एक मनमाना पायथन फ़ंक्शन लेता है और एक ufunc देता है

टिप्पणियाँ

vectorize फ़ंक्शन मुख्य रूप से सुविधा के लिए प्रदान किया जाता है, प्रदर्शन के लिए नहीं। कार्यान्वयन अनिवार्य रूप से लूप के लिए है।

यदि otypes निर्दिष्ट नहीं किया जाता है, तो पहले तर्क के साथ फ़ंक्शन के लिए कॉल का उपयोग आउटपुट की संख्या निर्धारित करने के लिए किया जाएगा। इस कॉल के परिणाम कैश हो जाएंगे यदि cache दो बार फ़ंक्शन को रोकने के लिए True है। हालांकि, कैश को लागू करने के लिए, मूल फ़ंक्शन को लपेटा जाना चाहिए जो बाद की कॉल को धीमा कर देगा, इसलिए केवल ऐसा करें यदि आपका फ़ंक्शन महंगा है।

नया कीवर्ड तर्क इंटरफ़ेस और excluded तर्क समर्थन प्रदर्शन को और खराब करते हैं।

संदर्भ

[R575575] NumPy संदर्भ, अनुभाग सामान्यीकृत यूनिवर्सल फंक्शन एपीआई

उदाहरण

>>> def myfunc(a, b):
...     "Return a-b if a>b, otherwise return a+b"
...     if a > b:
...         return a - b
...     else:
...         return a + b
>>> vfunc = np.vectorize(myfunc)
>>> vfunc([1, 2, 3, 4], 2)
array([3, 4, 1, 2])

डॉकस्ट्रिंग इनपुट फ़ंक्शन से वेक्टर करने के लिए लिया जाता है जब तक कि यह निर्दिष्ट न हो:

>>> vfunc.__doc__
'Return a-b if a>b, otherwise return a+b'
>>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')
>>> vfunc.__doc__
'Vectorized `myfunc`'

आउटपुट प्रकार इनपुट के पहले तत्व का मूल्यांकन करके निर्धारित किया जाता है, जब तक कि यह निर्दिष्ट न हो:

>>> out = vfunc([1, 2, 3, 4], 2)
>>> type(out[0])
<type 'numpy.int32'>
>>> vfunc = np.vectorize(myfunc, otypes=[float])
>>> out = vfunc([1, 2, 3, 4], 2)
>>> type(out[0])
<type 'numpy.float64'>

excluded तर्क का उपयोग कुछ तर्कों पर वेक्टरकरण को रोकने के लिए किया जा सकता है। यह एक निश्चित लंबाई के सरणी-जैसे तर्कों के लिए उपयोगी हो सकता है जैसे बहुपद के लिए गुणांक के रूप में polyval :

>>> def mypolyval(p, x):
...     _p = list(p)
...     res = _p.pop(0)
...     while _p:
...         res = res*x + _p.pop(0)
...     return res
>>> vpolyval = np.vectorize(mypolyval, excluded=['p'])
>>> vpolyval(p=[1, 2, 3], x=[0, 1])
array([3, 6])

उनकी स्थिति निर्दिष्ट करके स्थिति संबंधी तर्क भी शामिल किए जा सकते हैं:

>>> vpolyval.excluded.add(0)
>>> vpolyval([1, 2, 3], x=[0, 1])
array([3, 6])

signature तर्क उन वेक्टरिंग कार्यों की अनुमति देता है जो निश्चित लंबाई के गैर-स्केलर सरणियों पर कार्य करते हैं। उदाहरण के लिए, आप इसका उपयोग पियरसन सहसंबंध गुणांक और उसके पी-मान की एक सदिश गणना के लिए कर सकते हैं:

>>> import scipy.stats
>>> pearsonr = np.vectorize(scipy.stats.pearsonr,
...                         signature='(n),(n)->(),()')
>>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])
(array([ 1., -1.]), array([ 0.,  0.]))

या एक वेक्टर दृढ़ीकरण के लिए:

>>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')
>>> convolve(np.eye(4), [1, 2, 1])
array([[ 1.,  2.,  1.,  0.,  0.,  0.],
       [ 0.,  1.,  2.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  2.,  1.,  0.],
       [ 0.,  0.,  0.,  1.,  2.,  1.]])

तरीके

__call__ (* args, ** kwargs) pyfunc प्रसारण ( pyfunc ) के परिणामों के साथ वापसी सरणियों को pyfunc पर excluded और excluded नहीं किया excluded