Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

पायथन में दिए गए एक्सिस पर n-वां डिस्क्रीट डिफरेंस कैलकुलेट करना


n-वें डिस्क्रीट डिफरेंस (n-th discrete difference) की गणना करने के लिए, numpy.diff() मेथड का उपयोग करें। पहला डिफरेंस दिया जाता है out[i] = a[i+1] - a[i] दिए गए एक्सिस के साथ, उच्च डिफरेंस की गणना diff को रिकर्सिवली उपयोग करके की जाती है। diff() मेथड n-वें डिफरेंस लौटाता है। आउटपुट का आकार a के समान होता है सिवाय एक्सिस के जहां डायमेंशन n से छोटा होता है। आउटपुट का प्रकार a में किन्हीं दो एलिमेंट्स के बीच के डिफरेंस के प्रकार के समान होता है। यह ज्यादातर मामलों में a के प्रकार के समान होता है। एक उल्लेखनीय अपवाद datetime64 है, जिसके परिणामस्वरूप timedelta64 आउटपुट ऐरे होता है।

पहला पैरामीटर इनपुट ऐरे है। दूसरा पैरामीटर n है, यानी मानों को डिफरेंस करने की संख्या। यदि शून्य है, तो इनपुट को जैसा है वैसा ही लौटाया जाता है। तीसरा पैरामीटर वह एक्सिस है जिसके साथ डिफरेंस लिया जाता है, डिफ़ॉल्ट अंतिम एक्सिस है। चौथा पैरामीटर इनपुट ऐरे के साथ एक्सिस के साथ डिफरेंस करने से पहले प्रीपेंड या अपेंड करने के लिए मान हैं। स्केलर मानों को एक्सिस की दिशा में लंबाई 1 के ऐरे में विस्तारित किया जाता है और अन्य सभी एक्सिस के साथ इनपुट ऐरे का आकार होता है।

चरण

सबसे पहले, आवश्यक लाइब्रेरी इम्पोर्ट करें:

import numpy as np

array() मेथड का उपयोग करके एक नम्पाई ऐरे बनाएं। हमने int टाइप के एलिमेंट्स के साथ nan जोड़ा है:

arr = np.array([[10, 15, 30, 65], [80, 87, 100, np.nan]])

ऐरे प्रदर्शित करें:

print("हमारा ऐरे...\n", arr)

आयाम जांचें:

print("\nहमारे ऐरे के आयाम...\n", arr.ndim)

डेटा टाइप प्राप्त करें:

print("\nहमारे ऐरे ऑब्जेक्ट का डेटा टाइप...\n", arr.dtype)

n-वें डिस्क्रीट डिफरेंस की गणना करने के लिए, numpy.diff() मेथड का उपयोग करें। पहला डिफरेंस out[i] = a[i+1] - a[i] द्वारा दिया जाता है दिए गए एक्सिस के साथ, उच्च डिफरेंस की गणना diff को रिकर्सिवली उपयोग करके की जाती है:

print("\nडिस्क्रीट डिफरेंस..\n", np.diff(arr, axis=1))

उदाहरण

import numpy as np
# array() मेथड का उपयोग करके एक नम्पाई ऐरे बनाना
# हमने int टाइप के एलिमेंट्स के साथ nan जोड़ा है
arr = np.array([[10, 15, 30, 65], [80, 87, 100, np.nan]])
# ऐरे प्रदर्शित करना
print("हमारा ऐरे...\n", arr)
# आयाम जांचना
print("\nहमारे ऐरे के आयाम...\n", arr.ndim)
# डेटा टाइप प्राप्त करना
print("\nहमारे ऐरे ऑब्जेक्ट का डेटा टाइप...\n", arr.dtype)
# n-वें डिस्क्रीट डिफरेंस की गणना करने के लिए, numpy.diff() मेथड का उपयोग करें
# पहला डिफरेंस out[i] = a[i+1] - a[i] द्वारा दिया जाता है दिए गए एक्सिस के साथ, उच्च डिफरेंस की गणना diff को रिकर्सिवली उपयोग करके की जाती है।
print("\nडिस्क्रीट डिफरेंस..\n", np.diff(arr, axis=1))

आउटपुट

हमारा ऐरे... [[ 10. 15. 30. 65.] [ 80. 87. 100. nan]] हमारे ऐरे के आयाम... 2 हमारे ऐरे ऑब्जेक्ट का डेटा टाइप... float64 डिस्क्रीट डिफरेंस.. [[ 5. 15. 35.] [ 7. 13. nan]]

  1. - पायथन में अक्ष 0 पर NaN को शून्य मानकर सरणी तत्वों का संचयी योग लौटाना

    दिए गए अक्ष पर सरणी तत्वों का संचयी योग लौटाने के लिए, NaN को शून्य मानकर nancumsum() विधि का उपयोग करें। जब NaN का सामना होता है तो संचयी योग नहीं बदलता और अग्रणी NaN को शून्य से बदल दिया जाता है। उन स्लाइस के लिए शून्य लौटाए जाते हैं जो सभी NaN हैं या खाली हैं। संचयी कार्य इस तरह करता है: 5, 5+10,

  1. - पायथन में N-डायमेंशनल ऐरे का ग्रेडिएंट एक्सिस 0 पर लौटाएं

    ग्रेडिएंट की गणना इंटीरियर पॉइंट्स में सेकंड ऑर्डर एक्यूरेट सेंट्रल डिफरेंसेस का उपयोग करके की जाती है और बाउंड्रीज पर फर्स्ट या सेकंड ऑर्डर एक्यूरेट वन-साइडेड (फॉरवर्ड या बैकवर्ड) डिफरेंसेस का उपयोग करके। लौटाया गया ग्रेडिएंट इसलिए इनपुट ऐरे के समान आकार का होता है। पहला पैरामीटर f एक N-डायमेंशनल

  1. - पायथन में एक्सिस 0 पर n-th डिस्क्रीट डिफरेंस की गणना करें

    n-th डिस्क्रीट डिफरेंस की गणना करने के लिए numpy.diff() मेथड का उपयोग करें। पहला डिफरेंस दिए गए एक्सिस के साथ out[i] = a[i+1] - a[i] द्वारा दिया जाता है, उच्च डिफरेंस की गणना diff को रिकर्सिवली उपयोग करके की जाती है। diff() मेथड n-th डिफरेंस लौटाता है। आउटपुट का आकार a के समान होता है सिवाय एक्सिस