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

सभी को नमस्कार, यहाँ हम अंतिम भाग में आते हैं। अच्छा पढ़ लो!
नेविगेशन:

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

मठ बहुपद

NumPy बहुपद के साथ काम करने के लिए तरीके प्रदान करता है। जड़ों की सूची पास करके, आप समीकरण के गुणांक प्राप्त कर सकते हैं:

>>> np.poly([-1, 1, 1, 10]) array([ 1, -11, 9, 11, -10]) 

यहां, सरणी समीकरण के अनुरूप गुणांक लौटाती है: $$$x ^ 4 - 11x ^ 3 + 9x ^ 2 + 11x - 10$।
रिवर्स ऑपरेशन भी किया जा सकता है: गुणांक की सूची से गुजरते हुए, रूट फ़ंक्शन बहुपद की सभी जड़ों को लौटा देगा:

 >>> np.roots([1, 4, -2, 3]) array([-4.57974010+0.j , 0.28987005+0.75566815j, 0.28987005-0.75566815j]) 

ध्यान दें कि इस समीकरण में $$$x ^ 3 + 4x ^ 2 - 2x + 3$दो जड़ें काल्पनिक हैं।
बहुपद गुणांक को एकीकृत किया जा सकता है। आइए एकीकरण पर विचार करें $$$x ^ 3 + x ^ 2 + x + 1$में $$$x ^ 4/4 + x ^ 3/3 + x ^ 2/2 + x + C$। आमतौर पर निरंतर C शून्य है:

 >>> np.polyint([1, 1, 1, 1]) array([ 0.25 , 0.33333333, 0.5 , 1. , 0. ]) 

इसी तरह, डेरिवेटिव लिया जा सकता है:

 >>> np.polyder([1./4., 1./3., 1./2., 1., 0.]) array([ 1., 1., 1., 1.]) 

पॉलीएड, पॉलीसब, पॉलीमुल और पॉलीडिव भी कार्य क्रमशः बहुपद गुणांक के योग, घटाव, गुणन और विभाजन का समर्थन करते हैं।
बहुपद समारोह बहुपद में दिए गए मान को प्रतिस्थापित करता है। एक बहुपद पर विचार करें $$$x ^ 3 - 2x ^ 2 + 2$x = 4 पर:

 >>> np.polyval([1, -2, 0, 2], 4) 34 

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

 >>> x = [1, 2, 3, 4, 5, 6, 7, 8] >>> y = [0, 2, 1, 3, 7, 10, 11, 19] >>> np.polyfit(x, y, 2) array([ 0.375 , -0.88690476, 1.05357143]) 

लौटी हुई सरणी बहुपद गुणांक की एक सूची है। SciPy में अधिक परिष्कृत प्रक्षेप कार्य देखे जा सकते हैं।

आंकड़े

माध्य, var और std फ़ंक्शन के अतिरिक्त, NumPy सरणियों में आँकड़ों के साथ काम करने के लिए कुछ और तरीके प्रदान करता है।
मंझला इस तरह मिल सकता है:

 >>> a = np.array([1, 4, 3, 8, 9, 2, 3], float) >>> np.median(a) 3.0 

कुछ चर के लिए सहसंबंध गुणांक कई बार मनाया जाता है और इसे प्रपत्र के सरणियों से पाया जा सकता है: [[X1, x2, ...], [y1, y2, ...], [z1, z2, ...], ।। ।], जहां x, y, z अलग-अलग क्वांटम वेधशाला हैं और संख्या "टिप्पणियों" की संख्या को दर्शाती है:

 >>> a = np.array([[1, 2, 1, 3], [5, 3, 1, 8]], float) >>> c = np.corrcoef(a) >>> c array([[ 1. , 0.72870505], [ 0.72870505, 1. ]]) 

हमारे पास एक लौटे सरणी c [i, j] है जो i-th और j-th क्वांटम वेधशालाओं के लिए सहसंबंध गुणांक को संग्रहीत करता है।
इसी तरह, कोविर्सियस पल पाया जा सकता है:

 >>> np.cov(a) array([[ 0.91666667, 2.08333333], [ 2.08333333, 8.91666667]]) 

रैंडम नंबर

हर सिमुलेशन का एक महत्वपूर्ण हिस्सा यादृच्छिक संख्या उत्पन्न करने की क्षमता है। ऐसा करने के लिए, हम यादृच्छिक उप-मॉड्यूल में NumPy में अंतर्निहित छद्म यादृच्छिक संख्या जनरेटर का उपयोग करते हैं। संख्याएँ छद्म यादृच्छिक होती हैं, इस अर्थ में कि वे नियतात्मक रूप से बीज संख्या से उत्पन्न होती हैं, लेकिन यादृच्छिक रूप से सांख्यिकीय समानता में बिखरी होती हैं। NumPy उत्पन्न करने के लिए Mersenne Twister नामक एक विशेष एल्गोरिथ्म का उपयोग करता है।
आप यादृच्छिक संख्याओं के अनुक्रम के निर्माण तत्व को निम्नानुसार निर्दिष्ट कर सकते हैं:

 >>> np.random.seed(293423) 

बीज एक पूर्णांक है। प्रत्येक प्रोग्राम जो एक ही बीज से शुरू होता है वह हर बार संख्याओं का एक ही क्रम उत्पन्न करेगा। यह डिबगिंग के लिए उपयोगी हो सकता है, लेकिन सामान्य तौर पर हमें बीज को सेट करने की आवश्यकता नहीं होती है, वास्तव में, जब हम कई बार कार्यक्रम चलाते हैं, तो हम हर बार संख्याओं का एक अलग क्रम प्राप्त करना चाहते हैं। यदि इस कमांड को निष्पादित नहीं किया जाता है, तो NumPy स्वचालित रूप से एक यादृच्छिक बीज (समय के आधार पर) का चयन करता है, जो कि प्रोग्राम शुरू होने पर हर बार अलग होता है।
आधे-अंतराल [0.0, 1.0) से यादृच्छिक संख्याओं की एक सरणी निम्नानुसार उत्पन्न की जा सकती है:

 >>> np.random.rand(5) array([ 0.40783762, 0.7550402 , 0.00919317, 0.01713451, 0.95299583]) 

रैंड फ़ंक्शन का उपयोग दो-आयामी सरणियों को उत्पन्न करने के लिए किया जा सकता है, या रिहाप फ़ंक्शन का उपयोग किया जा सकता है:

 >>> np.random.rand(2,3) array([[ 0.50431753, 0.48272463, 0.45811345], [ 0.18209476, 0.48631022, 0.49590404]]) >>> np.random.rand(6).reshape((2,3)) array([[ 0.72915152, 0.59423848, 0.25644881], [ 0.75965311, 0.52151819, 0.60084796]]) 

अंतराल पर एक यादृच्छिक संख्या उत्पन्न करने के लिए [0.0, 1.0):

 >>> np.random.random() 0.70110427435769551 

श्रेणी [न्यूनतम, अधिकतम) में एक यादृच्छिक पूर्णांक उत्पन्न करने के लिए, रैंडिंट (न्यूनतम, अधिकतम) फ़ंक्शन का उपयोग करें:

 >>> np.random.randint(5, 10) 9 

हमारे प्रत्येक उदाहरण में, हमने एक समान वर्दी वितरण से संख्याएं उत्पन्न कीं। NumPy में अन्य वितरणों के लिए जनरेटर भी शामिल हैं, जैसे: बीटा, द्विपद, ची-वर्ग, डिरिचलेट, घातांक, फिशर, गामा, ज्यामितीय, गम्बल, हाइपरमेट्रिक, लाप्लास, लॉजिस्टिक, लॉगरिनामल, लॉगरिदमिक, बहुराष्ट्रीय, बहुआयामी सामान्य, नकारात्मक द्विपद, अनिद्रा ची-स्क्वायर, ऑफ-सेंटर फिशर, नॉर्मल (गॉस), पेरेटो, पॉइसन, पॉवर, रेले, कॉची, स्टूडेंट, त्रिकोणीय, वॉन मिज़, वाल्ड, वेइबुल और जिपफ। आइए दो उदाहरणों को देखें।
Λ = 6.0 पर असतत पॉइसन वितरण से उत्पन्न करने के लिए,

 >>> np.random.poisson(6.0) 5 

Μ = 1.5 के औसत मूल्य और मानक विचलन average = 4.0 के साथ सामान्य वितरण (गाऊसी) से एक संख्या उत्पन्न करने के लिए:

 >>> np.random.normal(1.5, 4.0) 0.83636555041094318 

तर्कों को निर्दिष्ट किए बिना, सामान्य वितरण (μ = 0,) = 1) से एक संख्या प्राप्त करने के लिए:

 >>> np.random.normal() 0.27548716940682932 

कई मान उत्पन्न करने के लिए, आकार तर्क का उपयोग करें:

 >>> np.random.normal(size=5) array([-1.67215088, 0.65813053, -0.70150614, 0.91452499, 0.71440557]) 

यादृच्छिक संख्या उत्पन्न करने के लिए मॉड्यूल का उपयोग किसी सूची में मानों को यादृच्छिक रूप से वितरित करने के लिए भी किया जा सकता है। यदि हम किसी सूची में मानों को बेतरतीब ढंग से वितरित करना चाहते हैं तो यह उपयोगी हो सकता है:

 >>> l = range(10) >>> l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> np.random.shuffle(l) >>> l [4, 9, 5, 0, 2, 7, 6, 8, 1, 3] 

ध्यान दें कि फेरबदल फ़ंक्शन एक मौजूदा सरणी को संशोधित करता है और एक नया वापस नहीं करता है।

कुछ अतिरिक्त जानकारी

NumPy में कई और विशेषताएं शामिल हैं जिनका हमने यहां उल्लेख नहीं किया है। विशेष रूप से, ये असतत फूरियर रूपांतरण के साथ काम करने के लिए कार्य करते हैं, रैखिक बीजगणित में अधिक जटिल संचालन, आकार / आयाम / प्रकार के लिए परीक्षण सरणियों, विभाजन और सरणियों को जोड़ना, हिस्टोग्राम, विभिन्न तरीकों से किसी भी डेटा से सरणियों का निर्माण, ग्रिड सरणियों का निर्माण और संचालन। , विशेष मूल्यों (NaN, Inf), सेट-ऑपरेशन्स, विभिन्न प्रकार के विशेष मैट्रिसेस के निर्माण और विशेष गणितीय कार्यों की गणना के साथ (उदाहरण के लिए: Bessel फ़ंक्शन)। आप अधिक सटीक विवरणों के लिए NumPy प्रलेखन भी देख सकते हैं।

SciPy मॉड्यूल

SciPy, NumPy की कार्यक्षमता को बहुत अच्छी तरह से बढ़ाता है। हम इसके विवरण के बारे में बात नहीं करेंगे, लेकिन इसकी कुछ संभावनाओं पर विचार करेंगे। मॉड्यूल आयात करने के बाद अधिकांश SciPy फ़ंक्शन उपलब्ध हैं:

 >>> import scipy 

मदद समारोह SciPy के बारे में उपयोगी जानकारी प्रदान करता है:

>>> help(scipy)
Help on package scipy:

NAME
scipy
FILE
c:\python25\lib\site-packages\scipy\__init__.py
DESCRIPTION
SciPy --- A scientific computing package for Python
===================================================
Documentation is available in the docstrings and
online at http://docs.scipy.org.

Contents
--------
SciPy imports all the functions from the NumPy namespace, and in
addition provides:

Available subpackages
---------------------
odr --- Orthogonal Distance Regression [*]
misc --- Various utilities that don't have
another home.sparse.linalg.eigen.arpack --- Eigenvalue solver using iterative methods. [*]
fftpack --- Discrete Fourier Transform algorithms[*]
io --- Data input and output [*]
sparse.linalg.eigen.lobpcg --- Locally Optimal Block Preconditioned Conjugate Gradient Method (LOBPCG) [*]
special --- Airy Functions [*]
lib.blas --- Wrappers to BLAS library [*]
sparse.linalg.eigen --- Sparse Eigenvalue Solvers [*]
stats --- Statistical Functions [*]
lib --- Python wrappers to external libraries [*]
lib.lapack --- Wrappers to LAPACK library [*]
maxentropy --- Routines for fitting maximum entropymodels [*]
integrate --- Integration routines [*]
ndimage --- n-dimensional image package [*]
linalg --- Linear algebra routines [*]
spatial --- Spatial data structures and algorithms[*]
interpolate --- Interpolation Tools [*]
sparse.linalg --- Sparse Linear Algebra [*]
sparse.linalg.dsolve.umfpack --- :Interface to the UMFPACK library: [*]
sparse.linalg.dsolve --- Linear Solvers [*]
optimize --- Optimization Tools [*]
cluster --- Vector Quantization / Kmeans [*]
signal --- Signal Processing Tools [*]
sparse --- Sparse Matrices [*]
[*] - using a package requires explicit import (see pkgload)
...

ध्यान दें कि कुछ उप-मॉड्यूलों को सीधे अतिरिक्त आयात की आवश्यकता होती है, जो एक स्टार के साथ चिह्नित हैं:

 >>> import scipy >>> import scipy.interpolate 

प्रत्येक मॉड्यूल में कार्य आंतरिक दस्तावेज और आधिकारिक दस्तावेज में अच्छी तरह से प्रलेखित हैं। उनमें से अधिकांश सीधे संख्यात्मक एल्गोरिदम के साथ काम करने के लिए कार्य प्रदान करते हैं और उनका उपयोग करना बहुत आसान है। इस प्रकार, SciPy वैज्ञानिक गणना में समय की एक बड़ी राशि बचा सकता है, क्योंकि यह पहले से ही लिखित और परीक्षण किए गए फ़ंक्शन प्रदान करता है।
हम SciPy पर विस्तार से विचार नहीं करेंगे, लेकिन नीचे दी गई तालिका इसकी कुछ विशेषताओं को कवर करेगी:

मॉड्यूल	किसलिए प्रयोग किया जाता है
scipy.constants	गणितीय और भौतिक स्थिरांक का सेट
scipy.special	गणितीय भौतिकी के लिए कई विशेष कार्य, जैसे: हवादार, अण्डाकार, बेसेल, गामा, बीटा, हाइपरजोमेट्रिक, परवलयिक सिलेंडर, मैथ्यू, गोलाकार तरंग, स्ट्रू, केल्विन।
scipy.integrate	ट्रेपेज़ॉइड, सिम्पसन, रोमबर्ग और अन्य के तरीकों का उपयोग करके संख्यात्मक एकीकरण के साथ काम करने के लिए कार्य। पूर्ण अंतर समीकरणों के साथ काम करने के तरीके भी प्रदान करता है।
scipy.optimize	सामान्य उपयोगकर्ता कार्यों के साथ काम करने के लिए मानक उच्च / निम्न विधियाँ। एल्गोरिदम में शामिल हैं: नेल्डर - मीड, पुल ( पॉवेल ), संयुग्मक ग्रेडिएंट्स, ब्रुडेन - फ्लेचर - गोल्डफर्ब - चन्नो, कम से कम वर्ग, सशर्त अनुकूलन, नकली एनीलिंग, पूर्ण खोज, ब्रेंट, न्यूटन, बिसफेक्शन, ब्राइडेन, एंडरसन और रैखिक खोज।
scipy.linalg	NumPy की तुलना में रैखिक बीजगणित के साथ काम करने के लिए व्यापक कार्यक्षमता। विशिष्ट वस्तुओं के लिए विशेष और त्वरित कार्यों का उपयोग करने के लिए अधिक विकल्प प्रदान करता है (उदाहरण के लिए: एक तीन-विकर्ण मैट्रिक्स)। शामिल विधियां: एक गैर-अध: पतन मैट्रिक्स की खोज, एक निर्धारक की खोज, समीकरणों के रैखिक प्रणालियों का समाधान, मानदंडों की गणना और एक छद्म बिंदु मैट्रिक्स, वर्णक्रमीय विघटन, एकवचन अपघटन, एलयू अपघटन, चोल्स्की अपघटन, क्यूआर अपघटन, शूर अपघटन, और कई अन्य गणितीय संचालन कार्य करने के लिए गणितीय संचालन में।
scipy.sparse	बड़े विरल मैट्रिक्स के साथ काम करने के लिए कार्य
scipy.interpolate	उन वस्तुओं को प्रक्षेपित करने के तरीके और कक्षाएं जो असतत संख्यात्मक डेटा के लिए उपयोग की जा सकती हैं। रैखिक और तख़्ता ( नोट अनुवादक: चिकनी घटता का गणितीय प्रतिनिधित्व ) एक-और दो-आयामी डेटा सेट के लिए प्रक्षेप उपलब्ध है।
scipy.fftpack	फूरियर रूपांतरण की प्रक्रिया के लिए तरीके।
scipy.signal	सिग्नल के प्रसंस्करण के लिए तरीके, उदाहरण के लिए: फ़ंक्शन कनवल्शन, सहसंबंध, असतत फूरियर ट्रांसफॉर्म, बी-स्पलाइन स्मूथिंग, फ़िल्टरिंग, आदि।
scipy.stats	डेटा सेट के साथ काम करने के लिए सांख्यिकीय कार्यों और वितरण का एक बड़ा पुस्तकालय।

डेवलपर्स का एक बड़ा समूह नई SciPy सुविधाओं को लगातार विकसित करना जारी रखता है। एक अच्छा व्यावहारिक दृष्टिकोण यह है: यदि आप अपने कोड में किसी भी संख्यात्मक कार्यों और विधियों को लागू करने के बारे में सोच रहे हैं, तो आप पहले मूल SciPy प्रलेखन को देख सकते हैं। ऐसी संभावना है कि किसी ने पहले ही SciPy को लागू और योगदान दिया हो।

अंतभाषण

हमारी लेख श्रृंखला समाप्त हो गई है। जो भी पढ़े और समय निकाले उसके लिए धन्यवाद। मुझे यह भी उम्मीद है कि आपने कुछ उपयोगी जानकारी निकाली है और कुछ नया सीखा है। नई चीजों को विकसित करना और सीखना जारी रखें! जल्द मिलते हैं।