अनुवादक की प्रस्तावना

फिर से नमस्कार! सुन्न के बारे में मन का अनुवाद करने पर लेखों की हमारी श्रृंखला जारी रखना। अच्छा पढ़ा है।

• भाग 1
• भाग २
• भाग ४
• मूल

तुलना संचालक और मूल्य परीक्षण

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

>>> a = np.array([1, 3, 0], float) >>> b = np.array([0, 3, 2], float) >>> a > b array([ True, False, False], dtype=bool) >>> a == b array([False, True, False], dtype=bool) >>> a <= b array([False, True, True], dtype=bool) 

तुलना परिणाम एक सरणी में संग्रहीत किया जा सकता है:

 >>> c = a > b >>> c array([ True, False, False], dtype=bool) 

Arrays की तुलना एक मान से की जा सकती है:

 >>> a = np.array([1, 3, 0], float) >>> a > 2 array([False, True, False], dtype=bool) 

किसी भी और सभी ऑपरेटरों को यह निर्धारित करने के लिए उपयोग किया जा सकता है कि क्या क्रमशः कम से कम एक या सभी तत्व सही हैं:

 >>> c = np.array([ True, False, False], bool) >>> any(c) True >>> all(c) False 

संयुक्त बूलियन अभिव्यक्तियों को एक तत्व-दर-तत्व आधार पर सरणियों पर लागू किया जा सकता है विशेष कार्यों का उपयोग तार्किक_और, तार्किक_ और तार्किक_नोट:

 >>> a = np.array([1, 3, 0], float) >>> np.logical_and(a > 0, a < 3) array([ True, False, False], dtype=bool) >>> b = np.array([True, False, True], bool) >>> np.logical_not(b) array([False, True, False], dtype=bool) >>> c = np.array([False, True, False], bool) >>> np.logical_or(b, c) array([ True, True, False], dtype=bool) 

जहां फ़ंक्शन दो तत्वों के बीच चयन करने के लिए बूलियन फ़िल्टर का उपयोग करके एक ही लंबाई के दो अन्य सरणियों से एक नया सरणी बनाता है। मूल वाक्यविन्यास: जहां (बुलार्रे,
ट्रियरियर, मिथ्याचार):

 >>> a = np.array([1, 3, 0], float) >>> np.where(a != 0, 1 / a, a) array([ 1. , 0.33333333, 0. ]) 

जहां फ़ंक्शन के साथ, सामूहिक तुलना भी लागू की जा सकती है:

 >>> np.where(a > 0, 3, 2) array([3, 3, 2]) 

कुछ फ़ंक्शन किसी सरणी में मानों का परीक्षण करना संभव बनाते हैं। नॉनज़ेरो फ़ंक्शन नॉनज़रो मानों के सूचकांकों का एक टपल देता है। टपल में तत्वों की संख्या सरणी में अक्षों की संख्या के बराबर है:

 >>> a = np.array([[0, 1], [3, 0]], float) >>> a.nonzero() (array([0, 1]), array([1, 0])) 

आप परिमितता और NaN (संख्या नहीं) के लिए मान भी देख सकते हैं:

 >>> a = np.array([1, np.NaN, np.Inf], float) >>> a array([ 1., NaN, Inf]) >>> np.isnan(a) array([False, True, False], dtype=bool) >>> np.isfinite(a) array([ True, False, False], dtype=bool) 

यद्यपि हमने NaN और अनंत को जोड़ने के लिए यहां खस्ता स्थिरांक का उपयोग किया है, वे मानक गणितीय संचालन को लागू करने का परिणाम हो सकते हैं।

सरणी तत्वों का चयन और हेरफेर करना

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

बुलियन सरणियों को फ़िल्टरिंग के लिए सरणियों के रूप में इस्तेमाल किया जा सकता है:

 >>> a = np.array([[6, 4], [5, 9]], float) >>> a >= 6 array([[ True, False], [False, True]], dtype=bool) >>> a[a >= 6] array([ 6., 9.]) 

यह ध्यान देने योग्य है कि जब हम बूलियन एरे> ए = 6 को एरे के एक्शन ऑपरेशन के लिए एक इंडेक्स के रूप में पास करते हैं, तो एरे लौटे सरणी केवल ट्रू वैल्यू को स्टोर करेगा। हम एक चर में फ़िल्टर करने के लिए एक सरणी भी लिख सकते हैं:

 >>> a = np.array([[6, 4], [5, 9]], float) >>> sel = (a >= 6) >>> a[sel] array([ 6., 9.]) 

बूलियन अभिव्यक्तियों का उपयोग करके अधिक परिष्कृत फ़िल्टरिंग प्राप्त की जा सकती है:

 >>> a[np.logical_and(a > 5, a < 9)] >>> array([ 6.]) 

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

 >>> a = np.array([2, 4, 6, 8], float) >>> b = np.array([0, 0, 1, 3, 2, 1], int) >>> a[b] array([ 2., 2., 4., 8., 6., 4.]) 

दूसरे शब्दों में, जब हम a से तत्वों को प्राप्त करने के लिए b का उपयोग करते हैं, तो हम इस क्रम में 0th, 0th, 1st, 3rd, 2nd और 1st elements लेते हैं। सूची का उपयोग फ़िल्टरिंग के लिए सरणियों के रूप में भी किया जा सकता है:

 >>> a = np.array([2, 4, 6, 8], float) >>> a[[0, 0, 1, 3, 2, 1]] array([ 2., 2., 4., 8., 6., 4.]) 

बहुआयामी सरणियों के लिए, हमें प्रत्येक अक्ष के लिए एक्सेस ऑपरेटर इंडेक्स ( नोट ट्रांसलेटर: हमारे मामले में, इंडेक्स एरेस हैं ) में कई एक आयामी पूर्णांक सरणियों को स्थानांतरित करना होगा। फिर प्रत्येक ऐरे निम्न क्रम से गुजरता है: पहला तत्व पंक्ति के सूचकांक से मेल खाता है, जो कि ए का पहला तत्व है बी, दूसरा तत्व कॉलम के इंडेक्स से मेल खाता है, जो एरे सी का पहला तत्व है, और इसी तरह। ( अनुवादक का ध्यान दें: पहला सरणी [2, 2] और दूसरा [1, 4], हमारे पास आउटपुट पर सूचकांकों [2, 1] और [2, 4] के तत्व हैं। उदाहरण:

 >>> a = np.array([[1, 4], [9, 16]], float) >>> b = np.array([0, 0, 1, 1, 0], int) >>> c = np.array([0, 1, 1, 1, 1], int) >>> a[b,c] array([ 1., 4., 16., 16., 4.]) 

पूर्णांक सरणियों के साथ लाने के लिए एक विशेष टेक फंक्शन उपलब्ध है। यह इंडेक्स पर टेक ऑपरेटर का उपयोग करने के समान है:

 >>> a = np.array([2, 4, 6, 8], float) >>> b = np.array([0, 0, 1, 3, 2, 1], int) >>> a.take(b) array([ 2., 2., 4., 8., 6., 4.]) 

टेक फ़ंक्शन अक्ष के साथ बहुआयामी सरणी का एक उपधारा लेने के लिए अक्ष तर्क भी प्रदान करता है। ( नोट अनुवादक: पंक्ति या स्तंभ (द्वि-आयामी सरणियों के लिए) )।

 >>> a = np.array([[0, 1], [2, 3]], float) >>> b = np.array([0, 0, 1], int) >>> a.take(b, axis=0) array([[ 0., 1.], [ 0., 1.], [ 2., 3.]]) >>> a.take(b, axis=1) array([[ 0., 0., 1.], [ 2., 2., 3.]]) 

टेक फ़ंक्शन के विपरीत, एक पुट फ़ंक्शन है, जो मूल सरणी से मान लेगा और उन्हें दूसरे पुट-सरणी में विशिष्ट सूचकांकों के लिए लिख देगा।

 >>> a = np.array([0, 1, 2, 3, 4, 5], float) >>> b = np.array([9, 8, 7], float) >>> a.put([0, 3], b) >>> a array([ 9., 1., 2., 8., 4., 5.]) 

ध्यान दें कि मूल सरणी b से 7 का उपयोग नहीं किया गया था, क्योंकि केवल 2 इंडेक्स [0, 3] इंगित किए गए हैं। यदि लंबाई मेल नहीं खाती है, तो आवश्यक होने पर मूल सरणी दोहराई जाएगी:

 >>> a = np.array([0, 1, 2, 3, 4, 5], float) >>> a.put([0, 3], 5) >>> a array([ 5., 1., 2., 5., 4., 5.]) 

वेक्टर और मैट्रिक्स गणित

NumPy वैक्टर और मैट्रेस के साथ काम करने के लिए कई कार्य प्रदान करता है। डॉट फ़ंक्शन वैक्टर के स्केलर उत्पाद को लौटाता है:

 >>> a = np.array([1, 2, 3], float) >>> b = np.array([0, 1, 1], float) >>> np.dot(a, b) 5.0 

डॉट फ़ंक्शन भी मैट्रिसेस को गुणा कर सकता है:

 >>> a = np.array([[0, 1], [2, 3]], float) >>> b = np.array([2, 3], float) >>> c = np.array([[1, 1], [4, 0]], float) >>> a array([[ 0., 1.], [ 2., 3.]]) >>> np.dot(b, a) array([ 6., 11.]) >>> np.dot(a, b) array([ 3., 13.]) >>> np.dot(a, c) array([[ 4., 0.], [ 14., 2.]]) >>> np.dot(c, a) array([[ 2., 4.], [ 0., 4.]]) 

आप मैट्रिस और वैक्टर के स्केलर, टेंसर और बाहरी उत्पाद भी प्राप्त कर सकते हैं। ध्यान दें कि वैक्टर के लिए आंतरिक और स्केलर उत्पाद मेल खाता है।

 >>> a = np.array([1, 4, 0], float) >>> b = np.array([2, 2, 1], float) >>> np.outer(a, b) array([[ 2., 2., 1.], [ 8., 8., 4.], [ 0., 0., 0.]]) >>> np.inner(a, b) 10.0 >>> np.cross(a, b) array([ 4., -1., -6.]) 

NumPy रैखिक बीजगणित के साथ काम करने के लिए अंतर्निहित कार्यों और विधियों का एक सेट भी प्रदान करता है। यह सब linalg उप-मॉड्यूल में पाया जा सकता है। ये मॉड्यूल पतित और गैर-पतित मेट्रिसेस के साथ भी संचालित किए जा सकते हैं। मैट्रिक्स का निर्धारक इस तरह से खोजा जाता है:

 >>> a = np.array([[4, 2, 0], [9, 3, 7], [1, 2, 1]], float) >>> a array([[ 4., 2., 0.], [ 9., 3., 7.], [ 1., 2., 1.]]) >>> np.linalg.det(a) -48. 

आप मैट्रिक्स के आइगेनवेक्टर और ईजेन्यूएल भी पा सकते हैं:

 >>> vals, vecs = np.linalg.eig(a) >>> vals array([ 9. , 2.44948974, -2.44948974]) >>> vecs array([[-0.3538921 , -0.56786837, 0.27843404], [-0.88473024, 0.44024287, -0.89787873], [-0.30333608, 0.69549388, 0.34101066]]) 

एक गैर-अध: पतन मैट्रिक्स निम्नानुसार पाया जा सकता है:

 >>> b = np.linalg.inv(a) >>> b array([[ 0.14814815, 0.07407407, -0.25925926], [ 0.2037037 , -0.14814815, 0.51851852], [-0.27777778, 0.11111111, 0.11111111]]) >>> np.dot(a, b) array([[ 1.00000000e+00, 5.55111512e-17, 2.22044605e-16], [ 0.00000000e+00, 1.00000000e+00, 5.55111512e-16], [ 1.11022302e-16, 0.00000000e+00, 1.00000000e+00]]) 

एक एकल अपघटन (एक गैर-वर्ग मैट्रिक्स के विकर्ण का एक एनालॉग) निम्नानुसार प्राप्त किया जा सकता है:

 >>> a = np.array([[1, 3,4], [5, 2, 3]], float) >>> U, s, Vh = np.linalg.svd(a) >>> U array([[-0.6113829 , -0.79133492], [-0.79133492, 0.6113829 ]]) >>> s array([ 7.46791327, 2.86884495]) >>> Vh array([[-0.61169129, -0.45753324, -0.64536587], [ 0.78971838, -0.40129005, -0.46401635], [-0.046676 , -0.79349205, 0.60678804]]) 

हम तीसरा भाग समाप्त करते हैं। गुड लक और जल्द ही मिलते हैं!