कोर्स
NumPy परिचय
4 घंटा
62.6K
NumPy, SciPy, Scikit-Learn, pandas और इसी तरह के पैकेजों जैसा ही है। ये वे Python पैकेज हैं जिन्हें आप डेटा साइंस सीखते समय मिस नहीं कर सकते, मुख्यतः क्योंकि यह लाइब्रेरी आपको एक array डेटा स्ट्रक्चर देती है जो Python lists की तुलना में कुछ फायदे देती है, जैसे अधिक कॉम्पैक्ट होना, items को पढ़ने-लिखने में तेज़ एक्सेस, अधिक सुविधाजनक और अधिक कुशल होना।
यह NumPy ट्यूटोरियल ठीक इसी पर केंद्रित होगा। यह न केवल आपको दिखाएगा कि NumPy arrays वास्तव में क्या हैं और आप Python कैसे इंस्टॉल कर सकते हैं, बल्कि आप यह भी सीखेंगे कि arrays कैसे बनाते हैं (चाहे आपका डेटा फ़ाइलों से ही क्यों न आता हो), broadcasting कैसे काम करती है, मदद कैसे माँगी जा सकती है, arrays में कैसे बदलाव करें और उन्हें कैसे विज़ुअलाइज़ करें।
यदि आप NumPy arrays और अन्य डेटा स्ट्रक्चर्स के बारे में और भी जानना चाहते हैं जिनकी आपको डेटा साइंस की यात्रा में ज़रूरत पड़ेगी, तो DataCamp के Intro to Python for Data Science पर नज़र डालें, जिसमें NumPy पर एक अध्याय है।
Python Numpy Array क्या है?
आपने परिचय में पढ़ा कि NumPy arrays कुछ हद तक Python lists जैसी होती हैं, लेकिन साथ ही काफी अलग भी। जो लोग इस विषय में नए हैं, उनके लिए चलिए स्पष्ट करते हैं कि यह क्या है और किस काम आता है।
नाम से ही स्पष्ट है कि NumPy array, numpy लाइब्रेरी की एक केंद्रीय डेटा संरचना है। लाइब्रेरी का नाम “Numeric Python” या “Numerical Python” का संक्षिप्त रूप है।
दूसरे शब्दों में, NumPy एक Python लाइब्रेरी है जो Python में वैज्ञानिक कंप्यूटिंग के लिए कोर लाइब्रेरी है। इसमें टूल्स और तकनीकों का संग्रह है जिनका उपयोग विज्ञान और इंजीनियरिंग की समस्याओं के गणितीय मॉडलों को सुलझाने में किया जा सकता है।
इन टूल्स में से एक है उच्च-प्रदर्शन वाला बहुआयामी array ऑब्जेक्ट, जो arrays और matrices की कुशल गणना के लिए एक शक्तिशाली डेटा संरचना है। इन arrays के साथ काम करने के लिए, ढेर सारे उच्च-स्तरीय गणितीय फ़ंक्शन हैं जो इन matrices और arrays पर operate करते हैं।
लेकिन array क्या है?
जब आप कुछ arrays की प्रिंटआउट देखते हैं, तो आप इसे एक ग्रिड की तरह देख सकते हैं जिसमें एक ही प्रकार के मान होते हैं:
import numpy as np
# Define a 1D array
my_array = np.array([[1, 2, 3, 4],
[5, 6, 7, 8]],
dtype=np.int64)
# Define a 2D array
my_2d_array = np.array([[1, 2, 3, 4],
[5, 6, 7, 8]],
dtype=np.int64)
# Define a 3D array
my_3d_array = np.array([[[1, 2, 3, 4],
[5, 6, 7, 8]],
[[1, 2, 3, 4],
[9, 10, 11, 12]]],
dtype=np.int64)
# Print the 1D array
print("Printing my_array:")
print(my_array)
# Print the 2D array
print("Printing my_2d_array:")
print(my_2d_array)
# Print the 3D array
print("Printing my_3d_array:")
print(my_3d_array)आप देखते हैं कि ऊपर के उदाहरण में डेटा integers हैं। array किसी भी नियमित डेटा को संरचित तरीके से रखता और दर्शाता है।
हालाँकि, आपको पता होना चाहिए कि संरचनात्मक स्तर पर, array मूलतः pointers के अलावा कुछ नहीं है। यह एक मेमोरी एड्रेस, डेटा टाइप, shape और strides का संयोजन है:
- डेटा pointer, array में पहले byte का मेमोरी एड्रेस बताता है।
- डेटा टाइप या dtype pointer, उन तत्वों के प्रकार का वर्णन करता है जो array में होते हैं।
- shape, array के आकार को दर्शाता है।
- strides वे bytes हैं जिन्हें मेमोरी में अगले तत्व तक जाने के लिए स्किप करना चाहिए। यदि आपके strides (10,1) हैं, तो अगले कॉलम तक पहुँचने के लिए आपको एक byte आगे बढ़ना होगा और अगली row के उसी स्थान तक जाने के लिए 10 bytes।
दूसरे शब्दों में, एक array में raw डेटा के बारे में, किसी तत्व का पता कैसे लगाएँ, और किसी तत्व की व्याख्या कैसे करें, इसकी जानकारी होती है।
अब बहुत हुआ सिद्धांत। आइए इसे खुद देखते हैं:
आप इसे numpy array attributes की जाँच करके आसानी से टेस्ट कर सकते हैं:
import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print out memory address
print(my_2d_array.data)
# Print out the shape of `my_array`
print(my_2d_array.shape)
# Print out the data type of `my_array`
print(my_2d_array.dtype)
# Print out the stride of `my_array`
print(my_2d_array.strides)अब आप देखते हैं कि आपको बहुत अधिक जानकारी मिलती है: उदाहरण के लिए, प्रिंट हुआ डेटा टाइप ‘int64’ है या signed 32-बिट इंटीजर टाइप; यह कहीं अधिक विस्तृत है! इसका यह भी मतलब है कि array मेमोरी में 64 bytes के रूप में स्टोर है (क्योंकि प्रत्येक integer 8 bytes लेता है और आपके array में 8 integers हैं)। array के strides हमें बताते हैं कि अगले कॉलम तक जाने के लिए आपको 8 bytes (एक मान) स्किप करने होंगे, लेकिन अगली row में उसी स्थान तक जाने के लिए 32 bytes (4 मान) स्किप करने होंगे। इसलिए, array के strides (32,8) होंगे।
ध्यान दें कि यदि आप डेटा टाइप को int32 सेट करते हैं, तो strides का tuple (16, 4) होगा, क्योंकि आपको अभी भी अगले कॉलम तक जाने के लिए एक मान और उसी स्थिति तक जाने के लिए 4 मान स्किप करने होंगे। केवल इतना बदलेगा कि प्रत्येक integer 8 की बजाय 4 bytes लेगा।
जो array आप ऊपर देख रहे हैं, वह अपने नाम के अनुरूप 2-आयामी array है: आपके पास rows और columns हैं। rows को “axis 0” और columns को “axis 1” कहा जाता है। axes की संख्या, dimensions की संख्या के साथ बढ़ती है: 3-D arrays में, जिनका उदाहरण आपने पिछली code chunk में भी देखा, एक अतिरिक्त “axis 2” होगा। ध्यान दें कि ये axes केवल उन arrays के लिए मान्य हैं जिनके कम से कम 2 dimensions हैं, क्योंकि 1-D arrays के लिए इसका कोई मतलब नहीं।
जब आप अपने NumPy arrays के shape में बदलाव करेंगे, तब ये axes काम आएँगे।
Numpy कैसे इंस्टॉल करें
अपने आप ये NumPy arrays आज़माने से पहले, आपको पहले यह सुनिश्चित करना होगा कि यह आपके लोकल सिस्टम पर इंस्टॉल है (मानते हुए कि आप अपने पीसी पर काम कर रहे हैं)। यदि आपके पास पहले से Python लाइब्रेरी उपलब्ध है, तो इस सेक्शन को छोड़ दें :)
यदि आपको अभी अपना environment सेट करना है, तो ध्यान रखें कि अपने पीसी पर NumPy इंस्टॉल करने के दो बड़े तरीके हैं: Python wheels की मदद से या Anaconda Python डिस्ट्रीब्यूशन से।
Python Wheels के साथ इंस्टॉल करें
पहले यह सुनिश्चित करें कि आपके पास Python इंस्टॉल है। यदि अभी करना बाकी है, तो हमारे Python कैसे इंस्टॉल करें गाइड पर नज़र डालें :)
यदि आप Windows पर काम कर रहे हैं, तो सुनिश्चित करें कि आपने Python को PATH environment variable में जोड़ दिया है। फिर, pip जैसे पैकेज मैनेजर को इंस्टॉल करना न भूलें, जो यह सुनिश्चित करेगा कि आप Python की ओपन-सोर्स लाइब्रेरीज़ का उपयोग कर सकें।
ध्यान दें कि Python 3 के हालिया संस्करण pip के साथ आते हैं, इसलिए जाँच लें कि यह है, और यदि है तो NumPy इंस्टॉल करने से पहले इसे अपग्रेड करें:
pip install pip --upgrade
pip --versionएक बार जब आपने NumPy wheel फ़ाइल डाउनलोड कर ली, तो कमांड प्रॉम्प्ट या टर्मिनल विंडो का उपयोग करके उस डायरेक्टरी पर जाएँ जहाँ फ़ाइल सेव है।
निम्न कमांड का उपयोग करके NumPy इंस्टॉल करें, जहाँ "numpy-<version>-<architecture>.whl" को डाउनलोड की गई NumPy wheel फ़ाइल के नाम से बदलें:
pip install numpy-<version>-<architecture>.whlउदाहरण के लिए, यदि आपने Windows 64-bit सिस्टम के लिए NumPy संस्करण 1.20.3 डाउनलोड किया है, तो कमांड होगा:
pip install numpy-1.20.3-cp39-cp39-win_amd64.whlइंस्टॉलेशन पूरा होने के बाद, आप Python इंटरप्रेटर खोलकर और निम्न कमांड चलाकर सत्यापित कर सकते हैं कि NumPy इंस्टॉल है:
import numpyयदि कोई error संदेश नहीं आता, तो NumPy इंस्टॉल हो चुका है और उपयोग के लिए तैयार है!
Anaconda Python डिस्ट्रीब्यूशन के साथ इंस्टॉल करें
NumPy पाने के लिए, आप Anaconda Python डिस्ट्रीब्यूशन भी डाउनलोड कर सकते हैं। यह आसान है और आपको जल्दी शुरू करने देगा! यदि आपने अभी तक डाउनलोड नहीं किया है, तो आधिकारिक पेज पर जाएँ और इसे प्राप्त करें। निर्देशों का पालन करें, और आप शुरू करने के लिए तैयार हैं!
क्या आप सोच रहे हैं कि यह आसान क्यों है?
इस Python डिस्ट्रीब्यूशन को लेने की अच्छी बात यह है कि आपको NumPy या उन प्रमुख पैकेजों को अलग से इंस्टॉल करने की चिंता नहीं करनी पड़ती जिन्हें आप अपने डेटा विश्लेषण के लिए उपयोग करेंगे, जैसे pandas, scikit-learn, आदि।
क्योंकि, खासकर यदि आप Python, प्रोग्रामिंग या टर्मिनल्स में नए हैं, तो Anaconda में पहले से ही डेटा साइंस के लिए 100 सबसे लोकप्रिय Python, R, और Scala पैकेज शामिल होना राहत देता है। और अनुभवी डेटा वैज्ञानिकों के लिए भी, यदि आप जल्दी से डेटा साइंस समस्याएँ सुलझाना शुरू करना चाहते हैं, तो Anaconda सही रास्ता है।
साथ ही, Anaconda में Jupyter और Spyder जैसे कई ओपन-सोर्स डेवलपमेंट एनवायरनमेंट भी शामिल हैं। यदि आप इस ट्यूटोरियल के बाद Jupyter Notebook के साथ काम करना शुरू करना चाहते हैं, तो हमारा Jupyter notebook ट्यूटोरियल देखें।
संक्षेप में, numpy और डेटा साइंस से संबंधित अन्य पैकेजों के साथ काम शुरू करने के लिए Anaconda डाउनलोड करने पर विचार करें!
NumPy Arrays कैसे बनाएं
तो, अब जब आपने अपना environment सेट कर लिया है, तो अब असली काम का समय है। मानना पड़ेगा, आपने ऊपर दिए गए कोड में arrays के साथ कुछ चीज़ें आज़माई हैं। हालाँकि, आपके पास अभी तक उनके साथ सही मायने में hands-on अभ्यास नहीं था क्योंकि आपको पहले अपने पीसी पर NumPy इंस्टॉल करना था। अब जब यह हो गया है, तो देखते हैं कि ऊपर के code chunks को अपने सिस्टम पर चलाने के लिए आपको क्या करना होगा।
एक numpy array बनाने के लिए, आप बस np.array() फ़ंक्शन का उपयोग कर सकते हैं। आपको बस एक list पास करनी है, और वैकल्पिक रूप से, आप डेटा का data type भी निर्दिष्ट कर सकते हैं। यदि आप संभावित डेटा टाइप्स के बारे में अधिक जानना चाहते हैं, तो इस गाइड पर जाएँ या DataCamp की NumPy चीट शीट पर एक नज़र डालें।
यदि आप नए उपयोगकर्ता हैं, तो इन NumPy डेटा टाइप्स को याद रखने की ज़रूरत नहीं है, लेकिन आपको यह जानना और ध्यान रखना होगा कि आप किस डेटा से निपट रहे हैं। डेटा टाइप्स तब काम आते हैं जब आपको यह नियंत्रित करने की ज़रूरत होती है कि आपका डेटा मेमोरी और डिस्क में कैसे स्टोर होगा। खासकर जब आप बड़े डेटा के साथ काम कर रहे हों, तब स्टोरेज टाइप को नियंत्रित करना जानना अच्छा है।
ना भूलें कि np.array() फ़ंक्शन के साथ काम करने के लिए, आपको यह सुनिश्चित करना होगा कि numpy लाइब्रेरी आपके environment में मौजूद हो।
NumPy लाइब्रेरी एक import convention का पालन करती है: जब आप इस लाइब्रेरी को import करते हैं, तो इसे np के रूप में import करना चाहिए। ऐसा करने से अन्य Pythonistas आपके कोड को आसानी से समझ पाते हैं।
निम्न उदाहरण में, आप वह my_array array बनाएँगे जिसके साथ आपने ऊपर पहले ही खेला है:
import numpy as np
# Make the array `my_array`
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print `my_array`
print(my_array)यदि आप यह जानना चाहते हैं कि lists कैसे बनाई जाती हैं, तो हमारा Python list questions ट्यूटोरियल देखें।
हालाँकि, कभी-कभी आपको नहीं पता होता कि आप अपने array में कौन सा डेटा रखना चाहते हैं, या आप किसी दूसरे स्रोत से numpy array में डेटा इम्पोर्ट करना चाहते हैं। ऐसे मामलों में, आप आरंभिक placeholders का उपयोग करेंगे या टेक्स्ट से arrays में डेटा लोड करने के लिए फ़ंक्शंस का उपयोग करेंगे।
निम्न सेक्शंस आपको यह दिखाएँगे कि यह कैसे करना है।
“Empty” NumPy array कैसे बनाएँ
जब लोग कहते हैं कि वे “empty” arrays बना रहे हैं, तो अक्सर उनका मतलब यह होता है कि वे आरंभिक placeholders का उपयोग करना चाहते हैं, जिन्हें आप बाद में भर सकते हैं। आप ones या zeros से arrays को initialize कर सकते हैं, लेकिन आप ऐसे arrays भी बना सकते हैं जो evenly spaced values, constant या random values से भरे हों।
फिर भी, आप एक बिल्कुल empty array भी बना सकते हैं।
खुशकिस्मती से, इसे बनाने के लिए काफी फ़ंक्शंस हैं।
इसे नीचे आज़माएँ!
import numpy as np
# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()
# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()
# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()
# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()
# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()
# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()
# Create an array of evenly-spaced values
np.linspace(0,2,9)टिप: ऊपर दिए गए फ़ंक्शंस के साथ खेलें ताकि आप समझें कि वे कैसे काम करते हैं!
- कुछ के लिए, जैसे np.ones(), np.random.random(), np.empty(), np.full() या np.zeros(), आपको ones या zeros के साथ arrays बनाने के लिए केवल उस array का shape पास करना होता है जिसे आप बनाना चाहते हैं। np.ones() और np.zeros() के विकल्प के रूप में, आप data type भी निर्दिष्ट कर सकते हैं। np.full() के मामले में, आपको वह constant मान भी देना होता है जिसे आप array में डालना चाहते हैं।
- np.linspace() और np.arange() के साथ आप evenly spaced values के arrays बना सकते हैं। इन दोनों फ़ंक्शंस के बीच अंतर यह है कि ऊपर कोड में पास किए गए तीन मानों में आखिरी मान, np.linspace() के लिए step value या np.arange() के लिए samples की संख्या बताता है। पहले मामले में आप, उदाहरण के लिए, 0 और 2 के बीच 9 मानों वाला array चाहते हैं। दूसरे में, आप निर्दिष्ट करते हैं कि आप 10 से शुरू होकर 5 के step पर, उस array के लिए मान जनरेट करना चाहते हैं जिसे आप बना रहे हैं।
ध्यान रखें कि NumPy आपको np.eye() और np.identity() के साथ एक identity array या मैट्रिक्स बनाने की भी अनुमति देता है। एक identity मैट्रिक्स एक square मैट्रिक्स होता है जिसमें मुख्य विकर्ण (principal diagonal) के सभी तत्व 1 होते हैं और अन्य सभी तत्व 0। जब आप किसी मैट्रिक्स को identity मैट्रिक्स से गुणा करते हैं, तो दिया गया मैट्रिक्स अपरिवर्तित रहता है।
दूसरे शब्दों में, यदि आप किसी मैट्रिक्स को identity मैट्रिक्स से गुणा करते हैं, तो मानक मैट्रिक्स गुणन के अनुसार परिणाम फिर वही मैट्रिक्स होगा।
भले ही इस ट्यूटोरियल का फोकस identity matrices कैसे काम करती हैं, यह दिखाना न हो, इतना कहना काफ़ी है कि जब आप मैट्रिक्स गणनाएँ शुरू करते हैं तो identity matrices उपयोगी होती हैं: वे गणितीय समीकरणों को सरल बना सकती हैं, जिससे आपकी गणनाएँ अधिक कुशल और मज़बूत हो जाती हैं।
टेक्स्ट से NumPy Arrays कैसे लोड करें
आरंभिक placeholders या कुछ example डेटा की मदद से arrays बनाना, numpy के साथ शुरुआत करने का एक शानदार तरीका है। लेकिन जब आप डेटा विश्लेषण शुरू करना चाहते हैं, तो आपको टेक्स्ट फ़ाइलों से डेटा लोड करना होगा।
जो आपने अभी तक देखा है, उससे आप बहुत कुछ नहीं कर पाएँगे। अपनी फ़ाइलों से डेटा लोड करने के लिए कुछ विशेष फ़ंक्शंस का उपयोग करें, जैसे loadtxt() या genfromtxt().
मान लीजिए आपके पास निम्न टेक्स्ट फ़ाइलें हैं, तो आप नीचे दिए गए कोड में comment की गई values को कॉपी-पेस्ट करेंगे, उन्हें टेक्स्ट फ़ाइल में पेस्ट करेंगे और “data.txt” के रूप में सेव करेंगे। फिर आप नीचे दिया गया कोड उपयोग कर सकते हैं:
# This is your data in the text file
# Value1 Value2 Value3
# 0.2536 0.1008 0.3857
# 0.4839 0.4536 0.3561
# 0.1292 0.6875 0.5929
# 0.1781 0.3049 0.8928
# 0.6253 0.3486 0.8791
# Import your data
x, y, z = np.loadtxt('data.txt',
skiprows=1,
unpack=True)ऊपर के कोड में, आप अपने environment में डेटा लोड करने के लिए loadtxt() का उपयोग करते हैं। आप देखते हैं कि दोनों फ़ंक्शंस का पहला argument टेक्स्ट फ़ाइल data.txt है। अगला, प्रत्येक के कुछ विशिष्ट argument हैं: पहले स्टेटमेंट में, आप पहली row को स्किप करते हैं और unpack=TRUE के साथ columns को अलग-अलग arrays के रूप में लौटाते हैं। इसका मतलब है कि Value1 कॉलम के मान x में रखे जाएँगे, और इसी तरह आगे।
ध्यान दें कि यदि आपके पास comma-delimited डेटा है या यदि आप डेटा टाइप निर्दिष्ट करना चाहते हैं, तो loadtxt() arguments में आप delimiter और dtype भी जोड़ सकते हैं।
यह आसान और सीधा है, है ना?
अब अपनी दूसरी डेटा फ़ाइल पर नज़र डालते हैं:
# Your data in the text file
# Value1 Value2 Value3
# 0.4839 0.4536 0.3561
# 0.1292 0.6875 MISSING
# 0.1781 0.3049 0.8928
# MISSING 0.5801 0.2038
# 0.5993 0.4357 0.7410
my_array2 = np.genfromtxt('data2.txt',
skip_header=1,
filling_values=-999)आप देखते हैं कि यहाँ, डेटा लोड करने के लिए आप genfromtxt() का सहारा लेते हैं। इस मामले में, आपको कुछ missing values को संभालना है जिनका संकेत 'MISSING' strings से किया गया है।
क्योंकि genfromtxt() फ़ंक्शन, numeric कॉलम में character strings को nan में बदल देता है, आप filling_values argument निर्दिष्ट करके इन मानों को अन्य मानों में बदल सकते हैं। इस मामले में, आप इन missing values का मान -999 सेट करना चुनते हैं।
यदि किसी तरह genfromtxt() से कुछ मान nan में convert नहीं होते, तो हमेशा missing_values argument होता है जो आपको यह निर्दिष्ट करने देता है कि आपके डेटा के missing values ठीक-ठीक क्या हैं।
लेकिन बस इतना ही नहीं।
टिप: सफलतापूर्वक डेटा इम्पोर्ट करने के लिए आप और कौन से arguments जोड़ सकते हैं, यह देखने के लिए यह numpy.genfromtxt पेज देखें।
अब आप सोच रहे होंगे कि वास्तव में इन दोनों फ़ंक्शंस में अंतर क्या है।
उदाहरणों ने शायद इसे अप्रत्यक्ष रूप से दिखाया, लेकिन आम तौर पर, genfromtxt() आपको थोड़ी अधिक लचीलापन देता है; यह loadtxt() से अधिक robust है।
इसे और व्यावहारिक बनाते हैं: बाद वाला, loadtxt(), तभी काम करता है जब टेक्स्ट फ़ाइल में हर row में समान संख्या में मान हों, इसलिए जब आप missing values को आसानी से संभालना चाहते हैं, तो आमतौर पर genfromtxt() का उपयोग करना आसान लगता है।
पर यह एकमात्र कारण नहीं है।
genfromtxt() द्वारा पेश किए गए arguments की संख्या पर एक त्वरित नज़र आपको सिखाएगी कि आप वास्तव में अपने इम्पोर्ट में और भी कई चीज़ें निर्दिष्ट कर सकते हैं, जैसे पढ़ने के लिए अधिकतम rows की संख्या या वेरिएबल्स से white spaces को स्वतः हटाने का विकल्प।
NumPy Arrays कैसे सेव करें
एक बार जब आपने arrays के साथ वह सब कर लिया जो आपको करना था, तो आप उन्हें एक फ़ाइल में सेव भी कर सकते हैं। यदि आप array को टेक्स्ट फ़ाइल में सेव करना चाहते हैं, तो आप savetxt() फ़ंक्शन का उपयोग कर सकते हैं:
import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')याद रखें कि np.arange() समान अंतराल वाले मानों का NumPy array बनाता है। इस फ़ंक्शन को पास किया गया तीसरा मान step value है।
बेशक, अपनी NumPy arrays को टेक्स्ट फ़ाइलों में सेव करने के अन्य तरीके भी हैं। यदि आप अपना डेटा बाइनरी फ़ाइलों या आर्काइव्स में ले जाना चाहते हैं, तो नीचे दी गई तालिका में फ़ंक्शंस देखें:
| save() | NumPy .npy फॉर्मेट में array को बाइनरी फ़ाइल में सेव करें |
| savez() | कई arrays को एक uncompressed .npz आर्काइव में सेव करें |
| savez_compressed() | कई arrays को एक compressed .npz आर्काइव में सेव करें |
ऊपर दिए गए फ़ंक्शंस का उपयोग करके अपने डेटा को कैसे सेव करें, इस पर अधिक जानकारी या उदाहरणों के लिए यह NumPy reference पेज देखें या तुरंत अधिक जानने के लिए NumPy की किसी help फ़ंक्शन का उपयोग करें!
क्या आपको यकीन नहीं कि ये NumPy help फ़ंक्शंस क्या हैं?
चिंता न करें! आप इन्हें अगले सेक्शंस में और जानेंगे!
अपने NumPy Arrays का निरीक्षण कैसे करें
ऊपर बताए गए array attributes, जैसे data, shape, dtype और strides, के अलावा कुछ और भी हैं जिनका उपयोग आप अपने arrays के बारे में अधिक जानने के लिए कर सकते हैं। जो शुरुआत में आपके लिए उपयोगी हो सकते हैं, वे ये हैं:
import numpy as np
# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()
# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()
# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()
# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()
# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()ये लगभग वे सभी attributes हैं जो किसी array के पास हो सकते हैं।
यदि आपको अभी इनमें से सभी उपयोगी नहीं लगते, तो चिंता न करें। यह सामान्य है, क्योंकि, जैसा कि आपने पिछले सेक्शन में पढ़ा, आप मेमोरी की परवाह तभी करेंगे जब आप बड़े डेटा सेट्स के साथ काम कर रहे हों।
साथ ही ध्यान दें कि attributes के अलावा, आपके पास अपने array के बारे में अधिक जानकारी पाने और उसे थोड़ा tweak करने के अन्य तरीके भी हैं:
import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print the length of `my_array`
print(len(my_array))
# Change the data type of `my_array`
my_array.astype(float)अब जब आपने अपना array बना लिया है, चाहे np.array() या किसी आरंभिक placeholder फ़ंक्शन से, या loadtxt() या genfromtxt() फ़ंक्शंस के माध्यम से अपना डेटा लोड करके, तो अब उस दूसरे प्रमुख तत्व पर क़रीबी नज़र डालने का समय है जो वास्तव में NumPy लाइब्रेरी को परिभाषित करता है: scientific computing।
NumPy Broadcasting कैसे काम करती है
scientific computing में और गहराई में जाने से पहले, यह देखना अच्छा होगा कि broadcasting वास्तव में क्या है: यह एक ऐसा तंत्र है जो NumPy को विभिन्न shapes वाले arrays के साथ तब काम करने देता है जब आप arithmetic operations कर रहे होते हैं।
नीचे दिया गया इन्फोग्राफिक NumPy broadcasting का एक उदाहरण दिखाता है:
व्यावहारिक संदर्भ में कहें, तो अक्सर आपके पास एक बड़ा array और एक थोड़ा छोटा array होता है। आदर्श रूप से, आप छोटे array का कई बार उपयोग करके बड़े array पर कोई ऑपरेशन (जैसे जोड़, गुणा, आदि) करना चाहते हैं।
इसे करने के लिए, आप broadcasting तंत्र का उपयोग करते हैं।
हालाँकि, यदि आप इसका उपयोग करना चाहते हैं तो कुछ नियम हैं। और, निराश होने से पहले, आप देखेंगे कि ये “नियम” बहुत सरल और सीधे हैं!
- सबसे पहले, यह सुनिश्चित करने के लिए कि broadcasting सफल है, आपके arrays के dimensions संगत (compatible) होने चाहिए। दो dimensions तब compatible होते हैं जब वे बराबर हों। निम्न उदाहरण देखें:
# Import the NumPy library and give it an alias of `np`
import numpy as np
# Initialize a 3x4 array of ones and assign it to the variable `x`
x = np.ones((3,4))
# Print the shape of the array `x`
print("Shape of x:", x.shape)
# Initialize a 3x4 array of random numbers between 0 and 1 and assign it to the variable `y`
y = np.random.random((3,4))
# Print the shape of the array `y`
print("Shape of y:", y.shape)
# Add the arrays `x` and `y` element-wise and print the resulting array
z = x + y
print("Result of x + y:\n", z)
# Print the shape of the resulting array
print("Shape of x + y:", z.shape)- दो dimensions तब भी compatible होते हैं जब उनमें से एक 1 हो:
# Import the NumPy library and give it an alias of `np`
import numpy as np
# Initialize a 3x4 array of ones and assign it to the variable `x`
x = np.ones((3,4))
# Print the shape of the array `x`
print("Shape of x:", x.shape)
# Initialize a 3x4 array of random numbers between 0 and 1 and assign it to the variable `y`
y = np.random.random((3,4))
# Print the shape of the array `y`
print("Shape of y:", y.shape)
# Add the arrays `x` and `y` element-wise and print the resulting array
z = x + y
print("Result of x + y:\n", z)
# Print the shape of the resulting array
print("Shape of x + y:", z.shape)ध्यान दें कि यदि dimensions compatible नहीं हैं, तो आपको ValueError मिलेगा।
टिप: गणनाएँ करने के बाद resulting array का size भी टेस्ट करें! आप देखेंगे कि size वास्तव में इनपुट arrays के प्रत्येक dimension के साथ अधिकतम size है।
दूसरे शब्दों में, आप देखते हैं कि x-y का परिणाम (3,4) shape वाला array देता है: y का shape (4,) था और x का (3,4)। नए, resulting array के shape के लिए x और y के प्रत्येक dimension के साथ अधिकतम size लिया जाता है।
- अंत में, arrays को तभी साथ में broadcast किया जा सकता है जब वे सभी dimensions में compatible हों। निम्न उदाहरण देखें:
# Import `numpy` as `np`
import numpy as np
# Initialize `x` and `y`
x = np.ones((3,4))
y = np.random.random((5,1,4))
# Add `x` and `y`
z = x + y
आप देखते हैं कि, भले ही x और y के dimensions कुछ अलग हों, दोनों को जोड़ा जा सकता है।
ऐसा इसलिए है क्योंकि वे सभी dimensions में compatible हैं:
- array x के dimensions 3 X 4 हैं,
- array y के dimensions 5 X 1 X 4 हैं
क्योंकि आपने देखा कि dimensions तब भी compatible होते हैं जब उनमें से एक 1 हो, इसलिए ये दोनों arrays broadcasting के लिए सही उम्मीदवार हैं!
आप देखेंगे कि जिस dimension में y का size 1 है और दूसरे array का size 1 से बड़ा (यानी 3) है, पहले array का व्यवहार ऐसे होता है मानो उसे उस dimension के along कॉपी किया गया हो।
ध्यान दें कि resulting array का shape फिर से x और y के प्रत्येक dimension के साथ अधिकतम size होगा: परिणाम का dimension (5,3,4) होगा।
संक्षेप में, यदि आप broadcasting का उपयोग करना चाहते हैं, तो आप जिन arrays के साथ काम कर रहे हैं, उनके shape और dimensions पर काफी निर्भर करेंगे।
पर अगर dimensions compatible न हों तो?
अगर वे बराबर न हों या उनमें से कोई 1 न हो?
आपको इसे अपने array को manipulate करके ठीक करना होगा! आप अगले सेक्शंस में यह कैसे करना है, देखेंगे।
Array Mathematics कैसे काम करती है?
आपने देखा कि broadcasting, arithmetic operations करते समय काम आती है। इस सेक्शन में, आप कुछ फ़ंक्शंस देखेंगे जिनका उपयोग आप arrays के साथ गणित करने में कर सकते हैं।
इस प्रकार, यह शायद आपको आश्चर्यचकित नहीं करेगा कि आप बस +, -, *, / या % का उपयोग करके दो (या अधिक) arrays को जोड़, घटा, गुणा, भाग या remainder निकाल सकते हैं। हालाँकि, NumPy के इतने काम का होने का बड़ा कारण यह है कि इसमें यह सब करने के लिए फ़ंक्शंस भी हैं। अभी आपने जो operations देखे, उनके समकक्ष फ़ंक्शंस हैं, क्रमशः, np.add(), np.subtract(), np.multiply(), np.divide() और np.remainder().
आप np.exp() और np.sqrt() के साथ exponentiation और square root भी आसानी से कर सकते हैं, या np.sin() और np.cos() के साथ अपने array के sines या cosines निकाल सकते हैं। अंत में, यह बताना भी उपयोगी है कि np.log() के साथ प्राकृतिक लघुगणक निकाला जा सकता है या dot() लगाकर dot product निकाला जा सकता है।
इसे नीचे के कोड में आज़माएँ।
बस एक टिप: पहले यह जाँच लें कि इस अभ्यास के लिए कौन से arrays लोड किए गए हैं!
# Import `numpy` as `np`
import numpy as np
x = np.array([[1, 2, 3], [3, 4, 5]])
y = np.array([6,7,8])
# Add `x` and `y`
z = np.add(x,y)
print("Addition of x and y:\n", z)
# Subtract `x` and `y`
z = np.subtract(x,y)
print("Subtraction of y from x:\n", z)
# Multiply `x` and `y`
z = np.multiply(x,y)
print("Element-wise multiplication of x and y:\n", z)याद है broadcasting कैसे काम करती है? अपने IPython shell में x और y के dimensions और shapes देखें। क्या broadcasting के नियमों का पालन हो रहा है?
लेकिन और भी है।
aggregate फ़ंक्शंस की यह छोटी सूची देखें:
| a.sum() | Array-स्तरीय sum |
| a.min() | Array-स्तरीय न्यूनतम मान |
| b.max(axis=0) | किसी array row का अधिकतम मान |
| b.cumsum(axis=1) | तत्वों का cumulative sum |
| a.mean() | औसत |
| b.median() | माध्यिका |
| a.corrcoef() | सहसंबंध गुणांक |
| np.std(b) | मानक विचलन |
इन सभी फ़ंक्शंस के अलावा, आपको यह जानना भी उपयोगी लग सकता है कि ऐसे तंत्र हैं जो आपको array elements की तुलना करने देते हैं। उदाहरण के लिए, यदि आप जाँचना चाहते हैं कि दो arrays के तत्व समान हैं या नहीं, तो आप == ऑपरेटर का उपयोग कर सकते हैं। यह जाँचने के लिए कि तत्व छोटे हैं या बड़े, आप < या > ऑपरेटर्स का उपयोग करते हैं।
यह सब काफी सीधा लगता है, है ना?
हालाँकि, आप संपूर्ण arrays की एक-दूसरे से तुलना भी कर सकते हैं! इस मामले में, आप np.array_equal() फ़ंक्शन का उपयोग करते हैं। जिन दो arrays की तुलना करनी है, उन्हें पास करें, और यह काम हो जाएगा।
ध्यान दें कि तुलना के अलावा, आप अपने arrays पर logical operations भी कर सकते हैं। आप np.logical_or(), np.logical_not() और np.logical_and() से शुरू कर सकते हैं। यह मूल रूप से आपके सामान्य OR, NOT और AND लॉजिकल ऑपरेशंस की तरह ही काम करता है;
सबसे सरल उदाहरण में, आप OR का उपयोग यह देखने के लिए करते हैं कि आपके तत्व समान हैं (उदाहरण के लिए, 1), या क्या दो में से किसी एक array तत्व का मान 1 है। यदि दोनों 0 हैं, तो FALSE लौटेगा। आप AND का उपयोग यह देखने के लिए करेंगे कि आपका दूसरा तत्व भी 1 है या नहीं, और NOT यह देखने के लिए कि दूसरा तत्व 1 से भिन्न है या नहीं।
इसे नीचे के कोड chunk में टेस्ट करें:
# Import `numpy` as `np`
import numpy as np
# Initialize arrays
a = np.array([1, 1, 0, 0], dtype=bool)
b = np.array([1, 0, 1, 0], dtype=bool)
# `a` AND `b`
np.logical_and(a, b)
# `a` OR `b`
np.logical_or(a, b)
# `a` NOT `b`
np.logical_not(a,b)Arrays को Subset, Slice और Index कैसे करें
गणितीय ऑपरेशंस के अलावा, आप मूल array (या resulting array) के केवल एक हिस्से या केवल कुछ array elements को आगे के विश्लेषण या अन्य ऑपरेशंस में उपयोग करने के लिए लेने पर विचार कर सकते हैं। ऐसे में आपको अपने arrays को subset, slice और/या index करना होगा।
ये ऑपरेशंस बहुत हद तक वैसे ही हैं जैसे आप उन्हें Python lists पर करते हैं। यदि आप अपने लिए समानताएँ देखना चाहते हैं, या अधिक विस्तृत व्याख्या चाहते हैं, तो DataCamp का Python list ट्यूटोरियल देखें।
यदि आपको इन ऑपरेशंस के काम करने का बिल्कुल पता नहीं है, तो अभी के लिए ये दो बुनियादी बातें जान लेना पर्याप्त है:
- आप square brackets [] को index ऑपरेटर के रूप में उपयोग करते हैं, और
- सामान्यतः, आप इन square brackets में integers पास करते हैं, लेकिन आप colon : या colon के integers के साथ संयोजन का उपयोग भी कर सकते हैं ताकि आप जिन elements/rows/columns का चयन करना चाहते हैं उन्हें निर्दिष्ट कर सकें।
Subsetting
इन दो बिंदुओं के अलावा, यह सब कैसे साथ में फिट होता है, यह देखने का सबसे आसान तरीका subsetting के कुछ उदाहरण देखना है:
import numpy as np
# Initialize 1D array
my_array = np.array([1,2,3,4])
# Print subsets
print(my_array[1])import numpy as np
# Initialize 2D array
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print subsets
print(my_2d_array[1][2])
print(my_2d_array[1,2])import numpy as np
# Initialize 3D array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Print subset
print(my_3d_array[1,1,2])Slicing
Subsetting से थोड़ा अधिक उन्नत, यदि आप चाहें, तो slicing है। यहाँ, आप केवल अपने arrays के विशिष्ट मानों पर विचार नहीं करते, बल्कि rows और columns के स्तर पर जाते हैं। आप शुद्ध “locations” के बजाय मूलतः डेटा के “regions” के साथ काम कर रहे हैं।
आप इस उपमा का मतलब इन कोड उदाहरणों में देख सकते हैं:
import numpy as np
# Initialize 1D array
my_array = np.array([1,2,3,4])
# Print subsets
print(my_array[0:2])import numpy as np
# Initialize 2D array
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print subsets
print(my_2d_array[0:2,1])import numpy as np
# Initialize 3D array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Print subset
print(my_3d_array[1,...])आप देखेंगे कि, सारतः, निम्न लागू होता है:
a[start:end] # items start से end तक (पर end शामिल नहीं!)
a[start:] # items start से array के अंत तक
a[:end] # शुरुआत से end तक items (पर end शामिल नहीं!)ऊपर के कोड में, प्रत्येक array को अलग-अलग initialize किया गया है, और subsets को अलग-अलग code blocks में प्रिंट किया गया है। my_array, my_2d_array, और my_3d_array क्रमशः 1D, 2D, और 3D arrays हैं, और subsets को indexing notation का उपयोग करके प्रिंट किया गया है।
पहले उदाहरण में, हम slicing का उपयोग करके my_array के index 0 और 1 पर items चुनते हैं। दूसरे उदाहरण में, हम my_2d_array की row 0 और 1, column 1 के items चुनते हैं। तीसरे उदाहरण में, हम ... notation का उपयोग करते हैं ताकि पहले और दूसरे dimensions के along सभी elements और तीसरे dimension के along दूसरे element का चयन किया जा सके।
Indexing
अंत में, indexing भी है। NumPy में, boolean indexing और advanced या “fancy” indexing होती है।
(यदि आप सोच रहे हैं, यह असली NumPy जार्गन है, मैंने आखिरी वाला खुद नहीं बनाया!)
सबसे पहले आता है boolean indexing। यहाँ, index number के आधार पर elements, rows या columns चुनने के बजाय, आप अपने array से वे मान चुनते हैं जो किसी शर्त को पूरा करते हैं।
इसे कोड में डालना काफी आसान हो सकता है:
import numpy as np
my_array = np.array([1,2,3,4])
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Try out a simple example
print(my_array[my_array<2])
# Specify a condition
bigger_than_3 = (my_3d_array >= 3)
# Use the condition to index our 3d array
print(my_3d_array[bigger_than_3])ध्यान दें कि किसी शर्त को निर्दिष्ट करने के लिए, आप लॉजिकल ऑपरेटर्स | (OR) और & (AND) का भी उपयोग कर सकते हैं। यदि आप ऊपर की शर्त को इस तरह से फिर से लिखना चाहते (जो कि अल्प-प्रभावी होगा, पर मैं शैक्षिक उद्देश्य से दिखा रहा हूँ :)), तो आपको bigger_than_3 = (my_3d_array > 3) | (my_3d_array == 3) मिलेगा।
जो arrays लोड किए गए हैं, उनके साथ संभावनाएँ बहुत नहीं हैं, लेकिन जिन arrays में, उदाहरण के लिए, नाम या राजधानियाँ हों, वहाँ संभावनाएँ अनंत हो सकती हैं!
जब fancy indexing की बात आती है, तो आप मूलतः यह करते हैं: आप rows के उस subset के क्रम को निर्दिष्ट करने के लिए integers की list या array पास करते हैं जिसे आप मूल array से चुनना चाहते हैं।
क्या यह आपको थोड़ा abstract लग रहा है?
चिंता न करें, इसे नीचे के code chunk में आज़माएँ:
import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Select elements at (1,0), (0,1), (1,2) and (0,0)
print(my_2d_array[[1, 0, 1, 0],[0, 1, 2, 0]])
# Select a subset of the rows and columns
print(my_2d_array[[1, 0, 1, 0]][:,[0,1,2,0]])अब, दूसरी स्टेटमेंट पहली नज़र में आपको कम समझ आ सकती है। यह सामान्य है। यदि आप इसे तोड़कर देखें तो अधिक समझ आएगा:
- यदि आप केवल my_2d_array[[1,0,1,0]] चलाते हैं, तो परिणाम निम्न होगा:
array([[5, 6, 7, 8],
[1, 2, 3, 4],
[5, 6, 7, 8],
[1, 2, 3, 4]])- दूसरा भाग, यानी [:,[0,1,2,0]], यह बताता है कि आप इस परिणाम की सभी rows रखना चाहते हैं, पर columns के क्रम को थोड़ा बदलना चाहते हैं। आप columns 0, 1 और 2 को जैसे हैं वैसे ही दिखाना चाहते हैं, लेकिन column नंबर 3 दिखाने के बजाय column 0 को अंतिम column के रूप में दोहराना चाहते हैं। इससे आपको निम्न परिणाम मिलेगा:
array([[5, 6, 7, 5],
[1, 2, 3, 1],
[5, 6, 7, 5],
[1, 2, 3, 1]])अब advanced indexing आपके लिए रहस्य नहीं रही!
मदद कैसे माँगे
एक छोटे से विराम के रूप में, आपको पता होना चाहिए कि जिन modules, functions या classes के साथ आप काम कर रहे हैं, उनके बारे में आप हमेशा अधिक जानकारी माँग सकते हैं, खासकर क्योंकि NumPy के साथ पहली बार काम शुरू करते समय यह काफी कुछ हो सकता है।
मदद माँगना काफ़ी आसान है।
आप numpy द्वारा दी गई विशेष help फ़ंक्शंस का उपयोग करके अपनी राह पर चल सकते हैं:
- lookfor() का उपयोग docstrings पर कीवर्ड सर्च करने के लिए करें। यदि आप अभी शुरुआत कर रहे हैं, तो यह विशेष रूप से उपयोगी है, क्योंकि इसके पीछे की ‘थ्योरी’ आपके दिमाग से धुंधली हो सकती है। एक कमी यह है कि यदि आपकी query इतनी विशिष्ट नहीं है, तो आपको सभी परिणामों से गुजरना होगा, जैसा कि नीचे के कोड उदाहरण में है। इससे आपके लिए overview कम हो सकता है।
- info() का उपयोग functions, classes, या modules की त्वरित व्याख्याओं और code examples के लिए करें। यदि आप करके सीखने वाले व्यक्ति हैं, तो यही तरीका अपनाएँ! इस फ़ंक्शन की एकमात्र कमी शायद यह है कि आपको पता होना चाहिए कि कुछ attributes या फ़ंक्शंस किस module में हैं। यदि आपको तुरंत समझ नहीं आता कि इसका क्या मतलब है, तो नीचे का कोड उदाहरण देखें।
देखा, दोनों फ़ंक्शंस के अपने फायदे और नुकसान हैं, पर आप खुद देखेंगे कि दोनों क्यों उपयोगी हो सकते हैं: इन्हें नीचे के code chunk में आज़माएँ!
import numpy as np
# Look up info on `mean` with `np.lookfor()`
print(np.lookfor("mean"))# Get info on data types with `np.info()`
np.info(np.ndarray.dtype)ध्यान दें कि आपको वास्तव में जानना होगा कि dtype, ndarray का attribute है। साथ ही, यह न भूलें कि जिन modules, classes या terms के बारे में आप जानकारी माँग रहे हैं, उनके आगे np लगाना न भूलें, नहीं तो आपको ऐसा error संदेश मिलेगा:
Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'ndarray' is not defined
अब आप जानते हैं कि मदद कैसे माँगें, और यह अच्छी बात है। अगला विषय जिसे यह NumPy ट्यूटोरियल कवर करता है, वह है array manipulation।
ऐसा नहीं कि आप अपने आप इस विषय को पार नहीं कर सकते, बिल्कुल उल्टा!
लेकिन कुछ फ़ंक्शंस सवाल खड़े कर सकते हैं, क्योंकि, resizing और reshaping में क्या अंतर है?
और अपने arrays को क्षैतिज और लंबवत रूप से stack करने में क्या फर्क है?
अगला सेक्शन इन्हीं सवालों के जवाब देने के बारे में है, पर यदि कभी संदेह हो, तो जल्दी से अपडेट होने के लिए अभी आपने जो help फ़ंक्शंस देखे उनका बेझिझक उपयोग करें।
Arrays को कैसे Manipulate करें
अपने arrays पर गणितीय ऑपरेशंस करना एक काम है जो आप करेंगे, पर शायद broadcasting को काम कराने और इसे सार्थक बनाने के लिए सबसे महत्वपूर्ण यह जानना है कि अपने arrays को कैसे manipulate करें।
नीचे कुछ सबसे आम manipulations दिए गए हैं जो आप करेंगे।
अपने Arrays को Transpose कैसे करें
अपनों arrays को transpose करने का अर्थ वास्तव में उनके dimensions को permute करना है। या, दूसरे शब्दों में, आप array के shape को इधर-उधर करते हैं। इसका प्रभाव दिखाने के लिए एक छोटा उदाहरण लेते हैं:
import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print `my_2d_array`
print(my_2d_array)
# Transpose `my_2d_array`
print(np.transpose(my_2d_array))
# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)टिप: यदि array और उसके transposed संस्करण के बीच दृश्य तुलना पूरी तरह स्पष्ट नहीं है, तो दोनों arrays के shape को inspect करें ताकि आप समझें कि dimensions क्यों permute हुए हैं।
ध्यान दें कि दो transpose फ़ंक्शंस हैं। दोनों वही करते हैं; इनमे बहुत फर्क नहीं है। आपको ध्यान रखना होगा कि T एक सुविधाजनक shorthand लगता है और np.transpose() में आपको अधिक लचीलापन मिलता है। इसलिए यदि आप अधिक arguments चाहते हैं तो इस फ़ंक्शन का उपयोग करने की सिफारिश की जाती है।
सब ठीक है जब आप एक-से-बड़े dimensions वाले arrays को transpose करते हैं, पर क्या होता है जब आपके पास केवल 1-D array हो? आपको क्या लगता है कोई प्रभाव होगा?
इसे नीचे के code chunk में स्वयं आज़माएँ। आपका 1-D array पहले से लोड है:
import numpy as np
my_array = np.array([1,2,3,4])
# Print `my_2d_array
print(my_array)
# Transpose `my_2d_array
print(np.transpose(my_array))
# Or use `T` to transpose `my_2d_array
print(my_array.T)आप बिल्कुल सही हैं! 1-D array को transpose करने पर कोई प्रभाव नहीं पड़ता!
Arrays को Reshape बनाम Resize करना
आपने broadcasting सेक्शन में पढ़ा होगा कि यदि आप arrays को arithmetic operations के लिए उपयुक्त उम्मीदवार बनाना चाहते हैं, तो उनके dimensions compatible होने चाहिए। पर जब ऐसा नहीं हो, तो क्या करना चाहिए, यह प्रश्न अभी नहीं सुलझा।
तो लीजिए, यहाँ जवाब है!
यदि arrays के dimensions समान नहीं हैं, तो आप अपने array को resize कर सकते हैं। तब आप np.resize() फ़ंक्शन को पास किए गए shape के साथ एक नया array लौटाएँगे। यदि आप अपने मूल array को नए dimensions के साथ पास करते हैं, और यदि नया array आपके मूल से बड़ा है, तो नया array मूल array की प्रतियों से भरा जाएगा जिन्हें उतनी बार दोहराया जाएगा जितनी आवश्यकता होगी।
हालाँकि, यदि आप केवल np.resize() को array पर लागू करते हैं और उसे नया shape पास करते हैं, तो नया array zeros से भरा जाएगा।
इसे एक उदाहरण से आज़माते हैं:
import numpy as np
x = np.ones((3,4))
# Print the shape of `x`
print(x.shape)
# Resize `x` to ((6,4))
np.resize(x, (6,4))
# Try out this as well
x.resize((6,4))
# Print out `x`
print(x)resizing के अलावा, आप अपने array को reshape भी कर सकते हैं। इसका अर्थ है कि आप डेटा बदले बिना array को नया shape देते हैं। reshaping की कुंजी यह सुनिश्चित करना है कि नए array का कुल size अपरिवर्तित रहे। यदि आप ऊपर उपयोग किए गए array x का उदाहरण लें, जिसका size 3 X 4 यानी 12 है, तो आपको सुनिश्चित करना होगा कि नया array भी size 12 का हो।
psst… यदि आप कोड से किसी array का size निकालना चाहते हैं, तो size attribute का उपयोग करें: x.size या x.reshape((2,6)).size:
import numpy as np
# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))
# Print the shape of `x`
print("Shape of x:", x.shape)
# Resize `x` to ((6,4))
np.resize(x, (6,4))
# Try out this as well
x.resize((6,4))
# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)
# Transpose `x`
x = x.T
# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)आउटपुट:
Shape of x: (3, 4)
Array before transposing:
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
[[1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)यदि और कुछ काम न आए, तो आप अपने मूल array में किसी array को append भी कर सकते हैं या array elements को insert या delete कर सकते हैं ताकि आपके dimensions, उस दूसरे array के साथ फिट हो जाएँ जिसे आप अपनी computation के लिए उपयोग करना चाहते हैं।
जब आप arrays के shape में बदलाव कर रहे हों, तो एक और ऑपरेशन ravel() काम का हो सकता है। यह फ़ंक्शन आपके arrays को flatten करने देता है। यानी यदि आपके पास 2D, 3D या n-D arrays हों, तो आप इस फ़ंक्शन से उन्हें 1-D array में flatten कर सकते हैं।
काफ़ी काम का है, है ना?
Arrays को Append कैसे करें
जब आप arrays को अपने मूल array में append करते हैं, तो वे उस मूल array के अंत में “चिपक” जाते हैं। यदि आप सुनिश्चित करना चाहते हैं कि जो आप जोड़ते हैं वह array के अंत में न आए, तो आप insert करने पर विचार कर सकते हैं। और जानने के लिए अगले सेक्शन में जाएँ।
NumPy लाइब्रेरी की बदौलत append करना काफ़ी आसान है; आप बस np.append() का उपयोग कर सकते हैं।
इसे नीचे के code chunk में देखें। यह न भूलें कि आप IPython shell में, उदाहरण के लिए my_array टाइप करके और ENTER दबाकर, कौन-से arrays लोड हैं, यह हमेशा जाँच सकते हैं।
import numpy as np
my_array = np.array([1,2,3,4])
# Print `my_array` before appending
print("my_array before appending:", my_array)
# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])
# Print `new_array`
print("new_array:", new_array)
# Print `my_array` after appending
print("my_array after appending:", my_array)आउटपुट:
my_array before appending: [1 2 3 4]
new_array: [ 1 2 3 4 7 8 9 10]
my_array after appending: [1 2 3 4]ध्यान दें कि np.append() एक नया array लौटाता है, मूल array को inplace संशोधित नहीं करता, इसलिए appending के बाद my_array अपरिवर्तित रहता है।
my_2d_array में append करना:
import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)
# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)
# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)
# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)आउटपुट:
my_2d_array before appending:
[[1 2 3 4]
[5 6 7 8]]
new_2d_array:
[[1 2 3 4 7]
[5 6 7 8 8]]
my_2d_array after appending:
[[1 2 3 4]
[5 6 7 8]]
ध्यान दें कि जब आप my_2d_array में एक अतिरिक्त column append करते हैं, तो axis निर्दिष्ट किया गया है। याद रखें कि 2-D arrays में axis 1 कॉलम को दर्शाता है, जबकि axis 0 rows को।
Array Elements कैसे Insert और Delete करें
append करने के अलावा, आप array elements को insert और delete भी कर सकते हैं। जैसा कि अब तक आपने समझ ही लिया होगा, ये ऑपरेशंस करने के लिए फ़ंक्शंस np.insert() और np.delete() हैं:
import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Insert `5` at index 1
np.insert(my_array, 1, 5)
# Delete the value at index 1
np.delete(my_array,[1])Arrays को Join और Split कैसे करें
आप अपने arrays को ‘merge’ या join भी कर सकते हैं। इस उद्देश्य के लिए आप जिन फ़ंक्शंस का उपयोग कर सकते हैं, उनमें से कई नीचे सूचीबद्ध हैं।
इन्हें आज़माएँ, पर यह भी सुनिश्चित करें कि IPython shell में arrays का shape क्या है, इसे भी टेस्ट करें। जो arrays लोड किए गए हैं वे हैं x, my_array, my_resized_array और my_2d_array।
import numpy as np
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))
# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))
# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])
# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))
# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))
# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])जैसे-जैसे आप फ़ंक्शंस से गुजरेंगे, आप कुछ बातें नोट करेंगे:
- यदि आप np.concatenate() के साथ दो arrays को concatenate करना चाहते हैं, तो dimensions की संख्या समान होनी चाहिए। इस प्रकार, यदि आप my_array, जो 1-D है, के साथ किसी array को concatenate करना चाहते हैं, तो आपको सुनिश्चित करना होगा कि दूसरा array भी 1-D हो।
- np.vstack() के साथ, आप my_array को my_2d_array के साथ आसानी से combine करते हैं। आपको बस यह सुनिश्चित करना है कि, क्योंकि आप arrays को row-wise stack कर रहे हैं, दोनों arrays में columns की संख्या समान हो। इस प्रकार, आप (2,4) या (3,4) shape वाला array भी my_2d_array में जोड़ सकते हैं, जब तक columns की संख्या मेल खाती हो। दूसरे शब्दों में, arrays का shape first axis को छोड़कर बाकी सभी axes के साथ समान होना चाहिए। यही बात np.r[] के लिए भी लागू होती है।
- np.hstack() के लिए, आपको यह सुनिश्चित करना है कि dimensions की संख्या समान हो और दोनों arrays में rows की संख्या समान हो। इसका अर्थ है कि आप (2,3) या (2,4) shape वाले arrays को my_2d_array (जिसका shape (2,4) है) में stack कर सकते हैं। जब तक rows की संख्या मेल खाती है, कुछ भी संभव है। यह फ़ंक्शन अभी भी NumPy द्वारा समर्थित है, पर आपको np.concatenate() या np.stack() को प्राथमिकता देनी चाहिए।
- np.column_stack() के साथ, आपको यह सुनिश्चित करना है कि इनपुट arrays का पहला dimension समान हो। इस मामले में, दोनों shapes समान हैं, पर यदि my_resized_array (2,1) या (2,) होता, तो भी arrays stack हो जाते।
- np.c_[] भी concatenate करने का एक तरीका है। यहाँ भी, दोनों arrays के पहले dimension का मिलना आवश्यक है।
जब आप arrays को join कर लेते हैं, तो आप किसी समय उन्हें split भी करना चाह सकते हैं। जैसे आप उन्हें क्षैतिज रूप से stack कर सकते हैं, वैसे ही आप वर्टिकली भी कर सकते हैं। आप क्रमशः np.hsplit() और np.vsplit() का उपयोग करते हैं:
import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))
# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))
# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))जब आप इन दोनों split फ़ंक्शंस का उपयोग कर रहे हों, तो जो बात आपके दिमाग में रहनी चाहिए, वह शायद आपके array का shape है। ऊपर के मामले को उदाहरण के रूप में लें: my_stacked_array का shape (2,8) है। यदि आप वह index चुनना चाहते हैं जहाँ split होना चाहिए, तो आपको shape को ध्यान में रखना होगा।
NumPy Arrays को कैसे विज़ुअलाइज़ करें
अंत में, यह जानना निश्चित रूप से काम आएगा कि आप अपने arrays को कैसे plot कर सकते हैं। यह विशेष रूप से डेटा exploration में काम आता है, पर डेटा साइंस workflow के बाद के चरणों में भी, जब आप अपने arrays को विज़ुअलाइज़ करना चाहते हैं।
np.histogram() के साथ
फ़ंक्शन जो सुझाव देता है उसके विपरीत, np.histogram() फ़ंक्शन histogram नहीं बनाता बल्कि यह गिनता है कि array के कितने occurrences प्रत्येक bin में आते हैं; यह निर्धारित करेगा कि आपके histogram की हर बार कितना क्षेत्र लेती है।
जिसे आप np.histogram() फ़ंक्शन को पास करते हैं, वह पहले इनपुट डेटा या वह array होता है जिसके साथ आप काम कर रहे हैं। histogram की गणना करते समय array को flatten कर दिया जाएगा।
# Import `numpy` as `np`
import numpy as np
# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))
# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))आप देखेंगे कि परिणामस्वरूप, histogram compute हो जाएगा: पहला array आपके array के सभी तत्वों की फ़्रीक्वेंसी सूचीबद्ध करता है, जबकि दूसरा array वे bins सूचीबद्ध करता है जो उपयोग किए जाते यदि आप कोई bins निर्दिष्ट नहीं करते।
यदि आप bins की संख्या निर्दिष्ट करते हैं, तो computation का परिणाम अलग होगा: floats चले जाएँगे और आप bins के लिए सभी integers देखेंगे।
आप अभी भी कुछ अन्य arguments निर्दिष्ट कर सकते हैं जो compute हुए histogram को प्रभावित कर सकते हैं। आप उन्हें सभी यहाँ पा सकते हैं।
पर histogram compute करने का क्या मतलब यदि आप उसे विज़ुअलाइज़ न कर सकें?
Matplotlib की मदद से विज़ुअलाइज़ेशन बहुत आसान है, पर आपको histogram compute करने के लिए np.histogram() की ज़रूरत नहीं है। plt.hist() स्वयं ऐसा करता है जब आप उसे (flattened) डेटा और bins पास करते हैं:
# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt
# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))
# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')
# Show the plot
plt.show()ऊपर का कोड आपको निम्न (basic) histogram देगा:
np.meshgrid() का उपयोग
अपने array को (अप्रत्यक्ष रूप से) विज़ुअलाइज़ करने का एक और तरीका np.meshgrid() का उपयोग करना है। arrays के साथ समस्या यह है कि आपको x और y निर्देशांक मानों के 2-D arrays की आवश्यकता होती है। ऊपर दिए गए फ़ंक्शन के साथ, आप x मानों के array और y मानों के array से एक rectangular grid बना सकते हैं: np.meshgrid() फ़ंक्शन दो 1D arrays लेता है और दो 2D matrices बनाता है जो दोनों arrays में (x, y) के सभी युग्मों के अनुरूप होते हैं। फिर, आप इन matrices का उपयोग विभिन्न प्रकार के plots बनाने के लिए कर सकते हैं।
np.meshgrid() विशेष रूप से तब उपयोगी है जब आप किसी ग्रिड पर functions का मान निकालना चाहते हैं, जैसा कि नीचे का कोड दिखाता है:
# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt
# Create an array
points = np.arange(-5, 5, 0.01)
# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)
# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)
# Draw a color bar
plt.colorbar()
# Show the plot
plt.show()ऊपर का कोड निम्न परिणाम देता है:
NumPy के साथ डेटा विश्लेषण से आगे
बधाई हो, आप NumPy ट्यूटोरियल के अंत तक पहुँच चुके हैं!
आपने बहुत कुछ कवर किया है, तो अब यह सुनिश्चित करें कि आपने जो ज्ञान हासिल किया है उसे बनाए रखें। इसमें आपकी मदद के लिए DataCamp की NumPy चीट शीट लेना न भूलें!
इतने सिद्धांत के बाद, अब समय है कि आप इस ट्यूटोरियल में सीखे गए कॉन्सेप्ट्स और तकनीकों का और अभ्यास करें। ऐसा करने का एक तरीका यह है कि scikit-learn ट्यूटोरियल पर वापस जाएँ और मशीन लर्निंग मॉडल बनाने में उपयोग किए गए डेटा arrays के साथ और प्रयोग करना शुरू करें।
यदि यह आपकी पसंद की चीज़ नहीं है, तो फिर से जाँचें कि आपने Anaconda डाउनलोड किया है या नहीं। फिर, Jupyter में इस Definitive Guide to Jupyter Notebook के साथ NumPy arrays पर काम शुरू करें। यह Jupyter Notebook भी देखें, जो Jupyter Notebook के interactive data science environment में NumPy और कुछ अन्य लाइब्रेरीज़ के साथ Python में डेटा विश्लेषण के माध्यम से आपका मार्गदर्शन करता है।
अंत में, DataCamp के data manipulation और visualization पर कोर्सेज़ देखना न भूलें। खासकर हमारे Continuum Analytics के साथ सहयोग में बने नवीनतम कोर्स आपको ज़रूर पसंद आएँगे! Manipulating DataFrames with Pandas या Pandas Foundations कोर्स पर नज़र डालें।