NumPy की linspace() फ़ंक्शन का उपयोग कैसे करें

NumPy Python डेटा साइंस इकोसिस्टम में एक आवश्यक पैकेज है, जो संख्यात्मक डेटा को कुशलतापूर्वक संसाधित करने के लिए कई प्रकार के फ़ंक्शंस प्रदान करता है। इनमें से, linspace() फ़ंक्शन का उपयोग किसी निर्दिष्ट अंतराल में समान दूरी वाले मान उत्पन्न करने के लिए किया जाता है। यह डेटा विज़ुअलाइज़ेशन और गणितीय मॉडलिंग जैसे कार्यों के लिए, जहाँ सटीक संख्यात्मक रेंज चाहिए होती है, एक उपयोगी टूल है। इस ट्यूटोरियल में, मैं आपको linspace() फ़ंक्शन के सभी पहलुओं से परिचित कराऊँगा।

संक्षेप में: np.linspace() का उपयोग कैसे करें

यदि आप जल्दी में हैं, तो यहाँ linspace() फ़ंक्शन का सबसे तेज़ स्पष्टीकरण है। NumPy का linspace() फ़ंक्शन एक परिभाषित अंतराल पर समान दूरी वाले संख्याओं की एक array बनाता है। उदाहरण के लिए, यहाँ हम एक ऐसी array बनाते हैं जो 0 से शुरू होकर 100 पर समाप्त होती है, और 5 संख्याओं के अंतराल में फैली होती है। अपेक्षा के अनुसार, यह [0, 25, 75, 100] वाली array लौटाता है।

import numpy as np

# Basic usage of linspace to create an array from 0 to 100 with 5 elements
linspace_example = np.linspace(0, 100.0, 5)
linspace_example # Return example

# Output: array([  0.,  25.,  50.,  75., 100.])
संचालित द्वारा

NumPy के linspace() फ़ंक्शन का उपयोग क्यों करें?

linspace() फ़ंक्शन रैखिक रूप से दूरी वाले मान उत्पन्न करने का एक सरल और कुशल तरीका है। यह उन अनेक परिदृश्यों में उपयोगी समाधान प्रदान करता है जहाँ विशिष्ट संख्यात्मक रेंज की आवश्यकता होती है, जैसे डेटा विज़ुअलाइज़ेशन, सिमुलेशन, और एल्गोरिदम का फाइन-ट्यूनिंग। यहाँ कुछ उदाहरण हैं जहाँ linspace() का उपयोग किया जा सकता है:

• डेटा विज़ुअलाइज़ेशन कार्य: उदाहरण के लिए, जब किसी उपग्रह की समय के साथ ट्रैजेक्टरी दर्शाने वाला लाइन ग्राफ़ बनाया जाता है, तो linspace() का उपयोग उस समयांतराल को उत्पन्न करने के लिए किया जा सकता है जिस पर स्थिति डेटा सैंपल किया जाता है, जिससे ग्राफ़ पर एक स्मूद और निरंतर रेखा सुनिश्चित होती है।
• सिमुलेशन: वित्तीय मॉडलिंग में, विभिन्न ब्याज दरों का बॉन्ड प्राइसिंग पर प्रभाव आँकने के लिए, linspace() सबसे कम से लेकर सबसे अधिक अपेक्षित ब्याज दरों की रेंज बना सकता है, जिससे पूरे स्पेक्ट्रम में व्यापक विश्लेषण संभव हो पाता है।
• वैज्ञानिक अनुसंधान: वैश्विक ऊष्मीकरण का ध्रुवीय हिम-टोपियों पर प्रभाव अध्ययन करते समय, शोधकर्ता linspace() का उपयोग कई दशकों में समान दूरी वाले समयांतरालों की शृंखला बनाने के लिए कर सकते हैं। प्रत्येक अंतराल पर, वे औसत वैश्विक तापमान वृद्धि और उसके बर्फ़ पिघलने की दरों पर प्रभाव का सिमुलेशन कर सकते हैं।

NumPy linspace() का सिंटैक्स और उदाहरणों सहित उपयोग

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

NumPy linspace() के आर्ग्युमेंट्स

• start: अनुक्रम का प्रारंभिक मान।
• stop: अनुक्रम का अंतिम मान।
• num (वैकल्पिक): निर्दिष्ट अंतराल। डिफ़ॉल्ट 50 है, और यह गैर-ऋणात्मक होना चाहिए।
• endpoint (वैकल्पिक): यदि True (डिफ़ॉल्ट) है, तो stop आखिरी सैंपल होता है। यदि False है, तो linspace() द्वारा जनरेट किए गए अनुक्रम में stop मान शामिल नहीं होता। इसका अर्थ है कि फ़ंक्शन start से लेकर stop से ठीक पहले तक समान दूरी वाले सैंपल बनाएगा, और स्वयं stop मान को प्रभावी रूप से बाहर रखेगा। यह तब उपयोगी है जब आपको ऐसी रेंज चाहिए जो endpoint के क़रीब तो पहुँचे पर उसे छुए नहीं, जिससे जनरेट की जाने वाली रेंज पर अधिक लचीला नियंत्रण मिलता है।
• retstep (वैकल्पिक): यदि True है, तो (samples, step) लौटाता है, जहाँ step सैंपलों के बीच की दूरी है।
• dtype (वैकल्पिक): आउटपुट array का प्रकार। यदि नहीं दिया गया है, तो dtype का निर्धारण start और stop आर्ग्युमेंट्स से होगा।
• axis (वैकल्पिक): परिणाम में वह axis जहाँ सैंपल स्टोर होंगे, केवल तब जब आप बहु-आयामी arrays के साथ काम कर रहे हों।

linspace() से 1-आयामी arrays बनाना

अब जब हमने linspace() में उपलब्ध आर्ग्युमेंट्स को अच्छी तरह समझ लिया है, तो आइए कुछ उदाहरणों को क्रिया में देखें!

linspace() का उपयोग करके समान दूरी वाली 1-आयामी array बनाना

यह उदाहरण 0 और 10 के बीच 7 समान दूरी वाली संख्याओं की array बनाता है।

import numpy as np

# Create an array of 7 evenly spaced elements from 0 to 10
uniform_array = np.linspace(0, 10, num=7)
print("Uniform Array")
uniform_array
संचालित द्वारा

Uniform Array
array([ 0., 1.66666667, 3.33333333, 5., 6.66666667,8.33333333, 10.])
संचालित द्वारा

linspace() का उपयोग करके 1-आयामी array में endpoint को बाहर रखना

इस उदाहरण में, हम 10 और 20 के बीच 8 संख्याओं की array जनरेट करते हैं, लेकिन अंतिम मान (20) को array से बाहर रखते हैं, और इस तरह endpoint आर्ग्युमेंट का उपयोग दर्शाते हैं।

import numpy as np


# Create an array of 8 elements from 10 to 20, excluding 20
exclude_final_array = np.linspace(10, 20, num=8, endpoint=False)
print("Array Excluding Final Value")
exclude_final_array
संचालित द्वारा

Array Excluding Final Value
array([10. , 11.25, 12.5 , 13.75, 15. , 16.25, 17.5 , 18.75])
संचालित द्वारा

linspace() का उपयोग करके 1-आयामी array में step size शामिल करना

यहाँ, हम -5 और 5 के बीच 4 तत्वों की array बनाते हैं। हम step size को भी कैप्चर कर प्रदर्शित करते हैं।

import numpy as np


# Create an array of 4 elements from -5 to 5 and capture the step size
step_array, step = np.linspace(-5, 5, num=4, retstep=True)
print("Array with Defined Step Size", step_array)
print("Step Size", step)संचालित द्वारा

Array with Defined Step Size [-5.         -1.66666667  1.66666667  5.        ]
Step Size 3.3333333333333335
संचालित द्वारा

linspace() से N-आयामी arrays बनाना

linspace() बहु-आयामी arrays बनाने में भी उपयोगी है। यहाँ हम इसके कुछ उदाहरण दिखा रहे हैं।

linspace() का उपयोग करके 2-आयामी array जनरेट करना

यह उदाहरण दर्शाता है कि कैसे 2D array जनरेट करें जहाँ प्रत्येक पंक्ति वेक्टर [0, 10] से [5, 15] तक 4 चरणों में स्मूद रूप से ट्रांज़िशन करती है, जिससे एक ग्रेडिएंट प्रभाव बनता है।

import numpy as np


# Perform column-wise linear interpolation from [10, 20] to [15, 25] over 3 steps
column_interpolation_array = np.linspace([10, 20], [15, 25], num=3, axis=1)
print("Column-wise Interpolation Array:")
print(column_interpolation_array)संचालित द्वारा

Column-wise Interpolation Array:
[[10.  12.5 15. ]
 [20.  22.5 25. ]]
संचालित द्वारा

NumPy linspace() के विकल्प

हालाँकि linspace() बहुत उपयोगी है, लेकिन कुछ विकल्प भी विचार करने योग्य हैं, जैसे NumPy का arange() फ़ंक्शन और list comprehensions।

NumPy के arange() फ़ंक्शन का उपयोग

arange() फ़ंक्शन किसी दिए गए अंतराल के भीतर मान उत्पन्न करता है। linspace() के विपरीत, इसमें मानों की संख्या के बजाय मानों के बीच की दूरी (step) निर्दिष्ट की जाती है।

# Using arange to generate values from 0 to 10, spaced by 2
arange_example = np.arange(0, 10, 2)
arange_example

# Returns array([0, 2, 4, 6, 8])

# Using linspace() to generate values from 0 to 10, with interval set to 2
linspace_example = np.linspace(0, 10, 2)
linspace_example

# Returns array([0.,10.0])
संचालित द्वारा

List comprehensions का उपयोग

List comprehensions सूचियाँ बनाने का अधिक Pythonic तरीका प्रदान करते हैं, हालाँकि इनमें NumPy linspace() जैसी वेक्टराइज़ेशन सुविधाएँ और लचीलापन नहीं होता।

list_comp = [x for x in range(10)]
print(list_comp)

# Outputs [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]संचालित द्वारा

अंतिम विचार

NumPy का linspace() फ़ंक्शन डेटा साइंस टूलकिट में एक मौलिक टूल है, जो संख्यात्मक अनुक्रमों को जनरेट करने में सटीकता और लचीलापन प्रदान करता है। यदि आप अपने NumPy कौशल को मज़बूत करना चाहते हैं, तो इस NumPy Arrays ट्यूटोरियल, इस NumPy चीट शीट को देखें, या हमारे Introduction to NumPy कोर्स में नामांकन करने पर विचार करें।