“लक्ष्य डेटा को सूचना में बदलना है, और सूचना को अंतर्दृष्टि में।”

$-$ कार्ली फियोरिना

6.1 परिचय

NumPy का अर्थ है ‘Numerical Python’। यह Python के साथ डेटा विश्लेषण और वैज्ञानिक कम्प्यूटिंग के लिए एक पैकेज है। NumPy एक बहुआयामी array ऑब्जेक्ट का उपयोग करता है, और इन arrays के साथ काम करने के लिए फंक्शन्स और टूल्स रखता है। NumPy में शक्तिशाली n-आयामी array डेटा प्रोसेसिंग को तेज करता है। NumPy को आसानी से अन्य Python पैकेजों से जोड़ा जा सकता है और C, C++ आदि जैसी अन्य प्रोग्रामिंग भाषाओं के साथ एकीकरण के लिए टूल्स प्रदान करता है।

NumPy इंस्टॉल करना

NumPy निम्नलिखित कमांड टाइप करके इंस्टॉल किया जा सकता है: pip install NumPy

6.2 Array

हमने विभिन्न डेटा प्रकारों जैसे list, tuple और dictionary के बारे में सीखा है। इस अध्याय में हम एक अन्य डेटाटाइप ‘Array’ पर चर्चा करेंगे। Array एक डेटा प्रकार है जिसका उपयोग एक single identifier (वेरिएबल नाम) का उपयोग करके कई मान संग्रहीत करने के लिए किया जाता है। Array में डेटा तत्वों का एक क्रमबद्ध संग्रह होता है जहाँ प्रत्येक तत्व एक ही प्रकार का होता है और इसे उसके index (स्थिति) द्वारा संदर्भित किया जा सकता है।

Contiguous memory

allocation: मेमोरी स्पेस को निश्चित आकार की स्थितियों में विभाजित किया जाना चाहिए और प्रत्येक स्थिति को केवल एक single डेटा को आवंटित किया जाता है।

Now Contiguous

Memory Allocation: डेटा को कई blocks में विभाजित करें और मेमोरी स्पेस की उपलब्धता के अनुसार मेमोरी के विभिन्न भागों में रखें।

Array की महत्वपूर्ण विशेषताएँ हैं:

• array के प्रत्येक तत्व का डेटा प्रकार समान होता है, यद्यपि उनमें संग्रहित मान भिन्न हो सकते हैं।
• संपूर्ण array स्मृति में एक साथ संग्रहित रहता है। इससे array पर संचालन तेज होते हैं।
• array के प्रत्येक तत्व की पहचान या संदर्भ array के नाम के साथ-साथ उस तत्व के index द्वारा किया जाता है, जो प्रत्येक तत्व के लिए अद्वितीय होता है। किसी तत्व का index एक पूर्णांक मान होता है जो तत्व की array में स्थिति के आधार से जुड़ा होता है। उदाहरण के लिए 5 संख्याओं वाले array पर विचार करें:

$ [10,9,99,71,90] $

यहाँ array का पहला मान 10 है और इससे जुड़ा index मान [0] है; array का $2^{\text {वाँ}}$ मान 9 है और इससे जुड़ा index मान [1] है, और इसी तरह। इस array का अंतिम मान (इस मामले में $5^{\text {वाँ}}$ मान) index [4] रखता है। इसे zero based indexing कहा जाता है। यह Python में lists के indexing के समान है। arrays की अवधारणा इतनी महत्वपूर्ण है कि लगभग सभी प्रोग्रामिंग भाषाएँ इसे किसी न किसी रूप में समर्थन देती हैं।

6.3 NumPy Array

NumPy arrays का उपयोग संख्यात्मक डेटा, वेक्टर और मैट्रिक्स की सूचियाँ संग्रहीत करने के लिए किया जाता है। NumPy लाइब्रेरी में NumPy arrays बनाने, उनका संचालन करने और रूपांतरित करने के लिए बड़ी संख्या में रूटीन (अंतर्निहित फ़ंक्शन) हैं। Python भाषा में भी एक array डेटा संरचना है, लेकिन वह NumPy array जितनी बहुमुखी, कुशल और उपयोगी नहीं है। NumPy array को आधिकारिक तौर पर ndarray कहा जाता है, लेकिन आमतौर पर इसे array के नाम से जाना जाता है। इस अध्याय के बाकी भाग में जब भी हम “array” शब्द का उपयोग करेंगे, तो हमारा तात्पर्य NumPy array से होगा। नीचे list और Array के बीच कुछ अंतर दिए गए हैं।

6.3.1 Difference Between List and Array

सूची	अरे
सूची में विभिन्न डेटा प्रकारों के तत्व हो सकते हैं, उदाहरण के लिए, $[1,3.4$, ‘hello’, ‘a@’]	एक अरे के सभी तत्व समान डेटा प्रकार के होते हैं, उदाहरण के लिए, फ्लोट्स का एक अरे हो सकता है: $[1.2,5.4,2.7]$
सूची के तत्व मेमोरी में लगातार स्थानों पर संग्रहीत नहीं होते हैं।	अरे के तत्व मेमोरी में लगातार स्थानों पर संग्रहीत होते हैं। इससे अरों पर संचालन सूचियों की तुलना में तेज होते हैं।
सूचियाँ एलिमेंट-वाइज़ संचालन का समर्थन नहीं करतीं, उदाहरण के लिए, जोड़, गुणा आदि, क्योंकि तत्व समान प्रकार के नहीं हो सकते।	अरे एलिमेंट-वाइज़ संचालन का समर्थन करते हैं। उदाहरण के लिए, यदि A1 एक अरे है, तो A1/3 कहना संभव है ताकि अरे के प्रत्येक तत्व को 3 से विभाजित किया जा सके।
सूचियाँ विभिन्न डेटा प्रकारों की वस्तुएँ रख सकती हैं जिनके लिए Python को प्रत्येक तत्व के साथ उसके प्रकार की जानकारी भी संग्रहीत करनी पड़ती है। इस प्रकार सूचियाँ अधिक मेमोरी लेती हैं और कम दक्ष हैं।	NumPy अरे सूची की तुलना में कम मेमोरी लेता है क्योंकि अरों को प्रत्येक तत्व का डेटा प्रकार अलग से संग्रहीत करने की आवश्यकता नहीं होती।
सूची Python के मुख्य भाग का हिस्सा है।	अरे (ndarray) NumPy लाइब्रेरी का हिस्सा है।

6.3.2 सूची से NumPy अरे का निर्माण

अरों को बनाने के कई तरीके हैं। एक अरे बनाने और उसकी विधियों का उपयोग करने के लिए, पहले हमें NumPy लाइब्रेरी आयात करनी होती है।

#NumPy को $n p$ के रूप में लोड किया जाता है (हम कोई भी
#नाम दे सकते हैं), numpy को छोटे अक्षरों में लिखना चाहिए
>>> import numpy as np

NumPy की array() फ़ंक्शन एक दी गई सूची को अरे में बदल देती है। उदाहरण के लिए,

#दी गई सूची से array1 नामक एक सरणी बनाएं।
>>> array1 = np.array([10,20,30])

#सरणी की सामग्री प्रदर्शित करें
>>> array1
array([10,20,30])

• 1-D सरणी बनाना

एक सरणी जिसमें केवल एक पंक्ति के तत्व हों, उसे 1-D सरणी कहा जाता है। आइए एक ऐसी 1-D सरणी बनाने का प्रयास करें जो संख्याओं के साथ-साथ स्ट्रिंग्स भी रखती है।

>>> array2 = np.array([5,-7.4,‘a’,7.2])
>>> array2
array([‘5’, ‘-7.4’, ‘a’, ‘7.2’],
dtype=’<U32’)

array() को तर्क देते समय एक सामान्य गलती तब होती है जब हम वर्गाकार कोष्ठक लगाना भूल जाते हैं। सुनिश्चित करें कि केवल एक ही तर्क पास किया जाए जिसमें मानों की सूची हो।

#गलत तरीका
>>> a = np.array(1,2,3,4)
#सही तरीका
>>> a = np.array([1,2,3,4])

ध्यान दें कि चूँकि सूची में एक स्ट्रिंग मान है, सभी पूर्णांक और फ़्लोट मानों को सरणी में बदलते समय स्ट्रिंग में प्रमोट कर दिया गया है।

नोट: U32 का अर्थ है Unicode-32 डेटा प्रकार।

• 2-D सरणी बनाना

हम nested lists को array() फ़ंक्शन में पास करके द्वि-आयामी (2-D) सरणियाँ बना सकते हैं।

उदाहरण 6.1

>>> array3 = np.array([[2.4,3], [4.91,7],[0,-1]])

>>> array3
array([[ 2.4 , 3. ],
$\qquad$ [ 4.91, 7. ],
$\qquad$ [ 0. , -1. ]])

ध्यान दें कि पूर्णांक 3,7,0 और -1 को फ़्लोट में प्रमोट कर दिया गया है।

6.3.3 NumPy सरणी के गुणधर्म

NumPy ndarray ऑब्जेक्ट के कुछ महत्वपूर्ण गुणधर्म हैं:

i) ndarray.ndim: सरणी के आयामों की संख्या पूर्णांक मान के रूप में देता है। सरणियाँ 1-D, 2-D या n-D हो सकती हैं। इस अध्याय में हम केवल 1-D और 2-D सरणियों पर ध्यान केंद्रित करेंगे। NumPy आयामों को axes (axis का बहुवचन) कहता है। इस प्रकार, 2-D सरणी में दो axes होते हैं। पंक्ति-अक्ष को axis-0 और स्तंभ-अक्ष को axis-1 कहा जाता है। axes की संख्या को सरणी की rank भी कहा जाता है।

एक सूची को nested list कहा जाता है जब प्रत्येक तत्व स्वयं एक सूची हो।

उदाहरण 6.2

>>> array1.ndim
1
>>> array3.ndim
2

ii) ndarray.shape: यह पूर्णांकों की अनुक्रम देता है जो प्रत्येक आयाम के लिए सरणी के आकार को दर्शाता है।

उदाहरण 6.3

# array1 is 1D-array, there is nothing
# after , in sequence
>>> array1.shape
(3,)
>>> array2.shape
(4,)
>>> array3.shape
(3, 2)

आउटपुट $(3,2)$ का अर्थ है कि array3 में 3 पंक्तियाँ और 2 स्तंभ हैं।

iii) ndarray.size: यह सरणी के तत्वों की कुल संख्या देता है। यह shape के तत्वों के गुणनफल के बराबर होता है।

उदाहरण 6.4

>>> array1.size
3
>>> array3.size
6

iv) ndarray.dtype: सरणी के तत्वों का डेटा प्रकार होता है। सरणी के सभी तत्व एक ही डेटा प्रकार के होते हैं। सामान्य डेटा प्रकार int32, int64, float32, float64, U32 आदि हैं।

उदाहरण 6.5

>>> array1.dtype
dtype(‘int32’)
>>> array2.dtype
dtype(’’)
>>> array3.dtype
dtype(‘float64’)

v) ndarray.itemsize: यह सरणी के प्रत्येक तत्व के बाइट्स में आकार निर्दिष्ट करता है। डेटा प्रकार int32 और float32 का अर्थ है कि सरणी का प्रत्येक तत्व मेमोरी में 32 बिट्स घेरता है। 8 बिट्स एक बाइट बनाते हैं। इस प्रकार, int32 प्रकार के तत्वों की सरणी का itemsize $32 / 8=4$ बाइट्स होता है। इसी तरह, int64/float64 का अर्थ है कि प्रत्येक आइटम का itemsize $64 / 8=8$ बाइट्स होता है।

उदाहरण 6.6

>>> array1.itemsize
4 $\qquad$ # पूर्णांक के लिए आवंटित मेमोरी
>>> array2.itemsize
128 $\qquad$ # स्ट्रिंग के लिए आवंटित मेमोरी
>>> array3.itemsize
8 $\qquad$ #फ्लोट प्रकार के लिए आवंटित मेमोरी

6.3.4 NumPy सरणियाँ बनाने के अन्य तरीके

1. हम array ( ) को dtype को तर्क के रूप में देकर डेटा प्रकार (पूर्णांक, फ्लोट आदि) निर्दिष्ट कर सकते हैं। यह डेटा को स्वचालित रूप से उल्लिखित प्रकार में बदल देगा। निम्नलिखित उदाहरण में, पूर्णांकों की नेस्टेड सूची को array फंक्शन को पास किया गया है। चूँकि डेटा प्रकार को float घोषित किया गया है, पूर्णांक फ्लोटिंग पॉइंट संख्याओं में बदल जाते हैं।

>>> array4 = np.array( [ [1,2], [3,4] ],
$\qquad \qquad$ dtype=float)
>>> array4
array([[1., 2.],
$\qquad$ [3., 4.]])

2. हम zeros( ) फ़ंक्शन का उपयोग करके सभी तत्वों को 0 से प्रारंभित करते हुए एक array बना सकते हैं। डिफ़ॉल्ट रूप से, zeros( ) द्वारा बनाए गए array का डेटा-प्रकार float होता है। निम्नलिखित कोड 3 पंक्तियों और 4 स्तंभों वाला एक array बनाएगा जिसमें प्रत्येक तत्व 0 पर सेट है।

>>> array5 = np.zeros((3,4))
>>> array5
array([[0., 0., 0., 0.],
$\qquad$ [0., 0., 0., 0.],
$\qquad$ [0., 0., 0., 0.]])

3. हम ones( ) फ़ंक्शन का उपयोग करके सभी तत्वों को 1 से प्रारंभित करते हुए एक array बना सकते हैं। डिफ़ॉल्ट रूप से, ones( ) द्वारा बनाए गए array का डेटा-प्रकार float होता है। निम्नलिखित कोड 3 पंक्तियों और 2 स्तंभों वाला एक array बनाएगा।

>>> array6 = np.ones((3,2))
>>> array6
array([[1., 1.],
$\qquad$ [1., 1.],
$\qquad$ [1., 1.]])

4. हम arange( ) फ़ंक्शन का उपयोग करके एक दी गई सीमा और क्रम में संख्याओं वाला array बना सकते हैं। यह फ़ंक्शन Python के range( ) फ़ंक्शन के समान है।

>>> array7 = np.arange(6)
# 6 तत्वों वाला एक array बनाया गया है
प्रारंभिक मान 5 और स्टेप आकार 1 के साथ
>>> array7
array([0, 1, 2, 3, 4, 5])
# प्रारंभिक मान -2, अंतिम
# मान 24 और स्टेप आकार 4 के साथ array बनाना
>>> array8 = np.arange( -2, 24, 4 )
>>> array8
array([-2, 2, 6, 10, 14, 18, 22])

6.4 इंडेक्सिंग और स्लाइसिंग

NumPy arrays को इंडेक्स किया जा सकता है, स्लाइस किया जा सकता है और उन पर इटरेशन किया जा सकता है।

सोचिए और विचार कीजिए

हमें कब शून्य या एक से प्रारंभित किए गए ऐरे बनाने की आवश्यकता पड़ सकती है?

6.4.1 अनुक्रमण

हमने एकल-आयामी ऐरे के अनुक्रमण के बारे में खंड 6.2 में सीखा है। द्वि-आयामी ऐरे के लिए दोनों आयामों के लिए अनुक्रमण 0 से प्रारंभ होता है, और प्रत्येक तत्व को दो सूचकांकों $i$ और $j$ के माध्यम से संदर्भित किया जाता है, जहाँ $i$ पंक्ति संख्या को और $\mathrm{j}$ स्तंभ संख्या को दर्शाता है।

तालिका 6.1 विभिन्न विषयों में छात्रों के अंक

नाम	गणित	अंग्रेज़ी	विज्ञान
रमेश	78	67	56
वेदिका	76	75	47
हारून	84	59	60
प्रसाद	67	72	54

तालिका 6.1 को देखिए जो तीन विभिन्न विषयों में छात्रों द्वारा प्राप्त अंक दिखा रही है। आइए एक ऐरे बनाते हैं जिसे marks कहा जाता है ताकि इस तालिका में दिए गए चार छात्रों के तीन विषयों के अंक संग्रहीत किए जा सकें। चूँकि 4 छात्र हैं (अर्थात् 4 पंक्तियाँ) और 3 विषय हैं (अर्थात् 3 स्तंभ), ऐरे को marks[4][3] कहा जाएगा। यह ऐरे $4 * 3=12$ तत्व संग्रहीत कर सकता है।

यहाँ, marks $[i, j]$ उस तत्व को संदर्भित करता है जो $(i+1)^{\text {वीं }}$ पंक्ति और $(j+1)^{\text {वीं }}$ स्तंभ में है क्योंकि सूचकांक मान 0 से प्रारंभ होते हैं। इस प्रकार marks $[3,1]$ चौथी पंक्ति और दूसरे स्तंभ का तत्व है जो 72 है (प्रसाद के अंग्रेज़ी में अंक)।

# पहली पंक्ति में स्थित तत्व तक पहुँचता है
# तीसरे स्तंभ में
>>> marks[0,2]
56
>>> marks [0,4]
सूचकांक सीमा से बाहर “Index Error”. सूचकांक 4
आकार 3 वाले अक्ष के लिए सीमा से बाहर है

6.4.2 स्लाइसिंग

कभी-कभी हमें एक array का कुछ भाग निकालने की ज़रूरत होती है। यह slicing के ज़रिए किया जाता है। हम array के उस भाग को परिभाषित कर सकते हैं जिसे slice करना है, [start : end] का उपयोग करके start और end index values को array name के साथ निर्दिष्ट करके।

उदाहरण 6.7

>>> array8
array([-2, 2, 6, 10, 14, 18, 22])

# end index पर मौजूद value को छोड़ता है
>>> array8[3:5]
array([10, 14])

# array को उलटता है
>>> array8[ : : -1]
array([22, 18, 14, 10, 6, 2, -2])

अब आइए देखें कि 2-D arrays के लिए slicing कैसे की जाती है। इसके लिए, आइए एक 2-D array बनाते हैं जिसे array9 कहा जाता है जिसमें 3 rows और 4 columns हैं।

>>> array9 = np.array([[ -7, 0, 10, 20],
$\qquad \qquad \qquad\qquad$ [ -5, 1, 40, 200],
$\qquad \qquad \qquad\qquad$ [ -1, 1, 4, 30]])

# 3rd column में सभी elements access करें
>>> array9[0:3,2]
array([10, 40, 4])

ध्यान दें कि हम rows को 0:3 range में specify कर रहे हैं क्योंकि range का end value exclude किया जाता है।

# 2nd और 3rd row के 1st
# और 2nd column के elements access करें
>>> array9[1:3,0:2]
array([[-5, 1],
$\qquad $ [-1, 1]])

अगर row indices specify नहीं किए जाते हैं, तो इसका मतलब है कि सभी rows को consider किया जाना है। इसी तरह, अगर column indices specify नहीं किए जाते हैं, तो सभी columns को consider किया जाना है। इस प्रकार, $3^{\text {rd }}$ column के सभी elements access करने के लिए statement को इस प्रकार भी लिखा जा सकता है:

>>>array9[:,2]
array([10, 40, 4])

6.5 Arrays पर Operations

एक बार arrays घोषित हो जाने के बाद, हम उसके तत्वों को एक्सेस कर सकते हैं या कुछ ऑपरेशन कर सकते हैं। पिछले खंड में, हमने तत्वों को एक्सेस करना सीखा। यह खंड arrays पर लगाए जा सकने वाले कई ऑपरेशनों का वर्णन करता है।

6.5.1 अंकगणितीय संचालन

NumPy arrays पर अंकगणितीय संचालन तेज और सरल होते हैं। जब हम दो arrays पर जोड़, घटाव, गुणा, भाग आदि जैसा कोई बुनियादी अंकगणितीय संचालन करते हैं, तो यह संचालन प्रत्येक संगत तत्वों के जोड़े पर किया जाता है। उदाहरण के लिए, दो arrays को जोड़ने से पहले array का पहला तत्व दूसरे array के पहले तत्व से जुड़ेगा, और इसी तरह आगे। दो arrays पर निम्नलिखित तत्व-दर-तत्व संचालनों पर विचार करें:

>>> array1 = np.array([[3,6],[4,2]])
>>> array2 = np.array([[10,20],[15,12]])

#दो मैट्रिक्सों का तत्व-दर-तत्व योग।
>>> array1 + array2
array([[13, 26],
$\qquad$ [19, 14]])

#घटाव
>>> array1 - array2
array([[ -7, -14],
$\qquad$ [-11, -10]])

#गुणा
>>> array1 * array2
array([[ 30, 120],
$\qquad$ [ 60, 24]])

#मैट्रिक्स गुणा
>>> array1 @ array2
array([[120, 132],
$\qquad$ [ 70, 104]])

#घातांक
>>> array1 ** 3
array([[ 27, 216],
$\qquad$ [ 64, 8]], dtype=int32)

#भाग
>>> array2 / array1
array([[3.33333333, 3.33333333],
$\qquad$ [3.75 , 6. ]])

#विभाजन का तत्ववार शेष
#(मॉड्यूलो)
>>> array2 % array1
array([[1, 2],
$\qquad$ [3, 0]], dtype=int32)

यह ध्यान देना महत्वपूर्ण है कि तत्ववार संचालनों के लिए, दोनों सरणियों का आकार समान होना चाहिए। यानी, array1.shape का array2.shape के बराबर होना आवश्यक है।

6.5.2 ट्रांसपोज़

किसी सरणी को ट्रांसपोज़ करने से उसकी पंक्तियाँ स्तंभों में और स्तंभ पंक्तियों में बदल जाती हैं, ठीक गणित में मैट्रिक्स की तरह।

#ट्रांसपोज़
>>> array3 = np.array([[10,-7,0, 20],
$\qquad \qquad$ [-5,1,200,40],[30,1,-1,4]]) >>> array3
array([[ 10, -7, 0, 20],
$\qquad$ [ -5, 1, 200, 40],
$\qquad$ [ 30, 1, -1, 4]])

# मूल सरणी नहीं बदलती
>>> array3.transpose()
array([[ 10, -5, 30],
$\qquad$ [ -7, 1, 1],
$\qquad$ [ 0, 200, -1],
$\qquad$ [ 20, 40, 4]])

6.5.3 सॉर्टिंग

सॉर्टिंग का अर्थ है सरणी के तत्वों को आरोही या अवरोही क्रम में व्यवस्थित करना। डिफ़ॉल्ट रूप से, numpy आरोही क्रम में सॉर्टिंग करता है।

>>> array4 = np.array([1,0,2,-3,6,8,4,7])
>>> array4.sort()
>>> array4
array([-3, 0, 1, 2, 4, 6, 7, 8])

2-D सरणी में, सॉर्टिंग दोनों अक्षों में की जा सकती है, अर्थात् पंक्तिवार या स्तंभवार। डिफ़ॉल्ट रूप से, सॉर्टिंग पंक्तिवार (axis $=1$) होती है। इसका अर्थ है प्रत्येक पंक्ति के तत्वों को आरोही क्रम में व्यवस्थित करना। जब axis $=0$ होता है, तो सॉर्टिंग स्तंभवार होती है, जिसका अर्थ है प्रत्येक स्तंभ को आरोही क्रम में सॉर्ट किया जाता है।

>>> array4 = np.array([[10,-7,0, 20],
[-5,1,200,40],[30,1,-1,4]])
>>> array4
array([[ 10, -7, 0, 20],
$\qquad$ [ -5, 1, 200, 40],
$\qquad$ [ 30, 1, -1, 4]])

#default पंक्ति-वार क्रमबद्धता है
>>> array4.sort()
>>> array4
array([[ -7, 0, 10, 20],
$\qquad$ [ -5, 1, 40, 200],
$\qquad$ [ -1, 1, 4, 30]])
>>> array5 = np.array([[10,-7,0, 20],
$\qquad\qquad$ [-5,1,200,40],[30,1,-1,4]])

6.6 सरणियों को जोड़ना

संयोजन का अर्थ है दो या अधिक सरणियों को जोड़ना। 1-D सरणियों को संयोजित करने का अर्थ है अनुक्रमों को एक के बाद एक जोड़ना। NumPy.concatenate() फ़ंक्शन का उपयोग दो या अधिक 2-D सरणियों को पंक्ति-वार या स्तंभ-वार संयोजित करने के लिए किया जा सकता है। संयोजित की जाने वाली सभी सरणियों के आयामों को बिल्कुल मेल खाने चाहिए, सिवाय उस आयाम या अक्ष के जिसके साथ उन्हें जोड़ा जाना है। आयामों में कोई भी असंगति त्रुटि का कारण बनता है। डिफ़ॉल्ट रूप से, सरणियों का संयोजन अक्ष $=0$ के साथ होता है।

उदाहरण 6.8

>>> array1 = np.array([[10, 20], [-30,40]])
>>> array2 = np.zeros((2, 3), dtype=array1. dtype)

>>> array1
array([[10, 20],
$\qquad$ [-30, 40]])

>>> array2
array([[0, 0, 0],
$\qquad$ [0, 0, 0]])

>>> array1.shape
(2, 2)
>>> array2.shape
(2, 3)

>>> np.concatenate((array1,array2), axis=1)
array([[ 10, 20, 0, 0, 0],
$\qquad$ [-30, 40, 0, 0, 0, 0]])

>>> np.concatenate((array1,array2), axis=0)
Traceback (most recent call last):
File “<pyshell#3>”, line 1, in
np.concatenate((array1,array2))
ValueError: all the input array dimensions except for the concatenation axis must match exactly

6.7 सरणियों को पुनः आकार देना

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

उदाहरण 6.9

>>> array3 = np.arange(10,22)
>>> array3
array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21])

>>> array3.reshape(3,4)
array([[10, 11, 12, 13],
$\qquad$ [14, 15, 16, 17],
$\qquad$ [18, 19, 20, 21]])

>>> array3.reshape(2,6)
array([[10, 11, 12, 13, 14, 15],
$\qquad$ [16, 17, 18, 19, 20, 21]])

6.8 सरणियों को विभाजित करना

हम एक array को दो या अधिक उप-arrays में विभाजित कर सकते हैं। numpy.split() array को निर्दिष्ट axis के अनुसार विभाजित करता है। हम या तो index values की sequence निर्दिष्ट कर सकते हैं जहाँ array को विभाजित किया जाना है; या हम एक पूर्णांक $\mathrm{N}$ निर्दिष्ट कर सकते हैं, जो दर्शाता है कि array को कितने बराबर भागों में विभाजित किया जाना है, जैसे कि NumPy.split() function के parameter(s)। डिफ़ॉल्ट रूप से, NumPy.split() axis = 0 के साथ विभाजित करता है। नीचे दिया गया array देखें:

>>> array4
array([[ 10, -7, 0, 20],
$\qquad$ [ -5, 1, 200, 40],
$\qquad$ [ 30, 1, -1, 4],
$\qquad$ [ 1, 2, 0, 4],
$\qquad$ [ 0, 1, 0, 2]])

# [1,3] row indices को इंगित करते हैं जहाँ
# array को विभाजित करना है
>>> first, second, third = numpy split(array4, [1, 3])

# array4 को पहली row पर विभाजित किया गया है और
# उप-array first में संग्रहीत है
>>> first
array([[10, -7, 0, 20]])

# array4 को पहली row के बाद विभाजित किया गया है और
# तीसरी row तक और इसे उप-array second में संग्रहीत किया गया है
>>> second
array([[ -5, 1, 200, 40],
$\qquad$ [ 30, 1, -1, 4]])

# array4 की शेष rows को उप-array third में संग्रहीत किया गया है
>>> third
array([[1, 2, 0, 4],
$\qquad$ [0, 1, 0, 2]])

#[1, 2], axis=1 स्तंभ सूचकांक देता है
#जिनके साथ विभाजित करना है
>>> firstc, secondc, thirdc =numpy split(array4,
[1, 2], axis=1)
>>> firstc
array([[10],
$\qquad$ [-5],
$\qquad$ [30],
$\qquad$ [ 1],
$\qquad$ [ 0]])

>>> secondc
array([[-7],
$\qquad$ [ 1],
$\qquad$ [ 1],
$\qquad$ [ 2],
$\qquad$ [ 1]])

>>> thirdc
array([[ 0, 20],
$\qquad$ [200, 40],
$\qquad$ [ -1, 4],
$\qquad$ [ 0, 4],
$\qquad$ [ 0, 2]])

# दूसरा पैरामीटर 2 इसका तात्पर्य है कि सरणी को
# 2 बराबर भागों में axis=1 स्तंभ अक्ष के साथ विभाजित किया जाना है
>>> firsthalf, secondhalf =np.split(array4,2,axis=1)
>>> firsthalf
array([[10, -7],
$\qquad$ [-5, 1],
$\qquad$ [30, 1],
$\qquad$ [ 1, 2],
$\qquad$ [ 0, 1]])

>>> secondhalf
array([[ 0, 20],
$\qquad$ [200, 40],
$\qquad$ [ -1, 4],
$\qquad$ [ 0, 4],
$\qquad$ [ 0, 2]])

6.9 सरणियों पर सांख्यिकीय संचालन

NumPy सरणियों पर कई उपयोगी सांख्यिकीय संचालन करने के लिए फ़ंक्शन प्रदान करता है। इस खंड में हम उन आधारभूत सांख्यिकीय तकनीकों को लागू करेंगे जिन्हें वर्णनात्मक सांख्यिकी कहा जाता है और जिन्हें हमने अध्याय 5 में सीखा है।

आइए दो सरणियों पर विचार करें:

>>> arrayA = np.array([1,0,2,-3,6,8,4,7])
>>> arrayB = np.array([[3,6],[4,2]])

1. $\max ()$ फलन एक सरणी से अधिकतम अवयव खोजता है।

# संपूर्ण 1-D सरणी से अधिकतम अवयव
>>> arrayA.max()
8
# संपूर्ण 2-D सरणी से अधिकतम अवयव
>>> arrayB.max()
6
# यदि axis=1 है, तो यह स्तंभवार अधिकतम देता है
>>> arrayB.max(axis=1)
array([6, 4])
# यदि axis=0 है, तो यह पंक्तिवार अधिकतम देता है
>>> arrayB.max(axis=0)
array([4, 6])

2. min() फलन एक सरणी से न्यूनतम अवयव खोजता है।

>>> arrayA.min()
-3
>>> arrayB.min()
2
>>> arrayB.min(axis=0)
array([3, 2])

3. sum( ) फलन एक सरणी के सभी अवयवों का योग खोजता है।

>>> arrayA.sum()
25
>>> arrayB.sum()
15
#axis यह निर्दिष्ट करने के लिए प्रयोग किया जाता है कि योग किस विमा पर करना है। यहाँ axis = 1
#का अर्थ है पहली पंक्ति के अवयवों का योग
>>> arrayB.sum(axis=1)
array([9, 6])

4. mean ( ) फलन सरणी के अवयवों का औसत खोजता है।

>>> arrayA.mean()
3.125
>>> arrayB.mean()
3.75
>>> arrayB.mean(axis=0)
array([3.5, 4. ])

>>> arrayB.mean(axis=1)
array([4.5, 3. ])

5. $\operatorname{std}()$ फलन अवयवों की एक सरणी का मानक विचलन खोजने के लिए प्रयोग किया जाता है।

>>> arrayA.std()
3.550968177835448

>>> arrayB.std()
1.479019945774904

>>> arrayB.std(axis=0)
array([0.5, 2. ])

>>> arrayB.std(axis=1)
array([1.5, 1. ])

6.10 फ़ाइलों से ऐरे लोड करना

कभी-कभी, हमारे पास फ़ाइलों में डेटा हो सकता है और हमें उस डेटा को प्रोसेसिंग के लिए एक ऐरे में लोड करने की आवश्यकता हो सकती है। numpy.loadtxt() और numpy.genfromtxt() दो फंक्शन हैं जिनका उपयोग टेक्स्ट फ़ाइलों से डेटा लोड करने के लिए किया जा सकता है। बड़ी मात्रा में डेटा को संभालने के लिए सबसे अधिक प्रयुक्त फ़ाइल प्रकार CSV (Comma Separated Values) होता है।

टेक्स्ट फ़ाइल से numpy ऐरे में डेटा लोड करने के लिए फ़ाइल में प्रत्येक पंक्ति में समान संख्या में मान होने चाहिए। मान लीजिए हमारे पास C:/NCERT फ़ोल्डर में संग्रहित data.txt नाम की टेक्स्ट फ़ाइल में निम्नलिखित डेटा है।

रोल नंबर	अंक1	अंक2	अंक3
1,	36,	18,	57
2,	22,	23,	45
3,	43,	51,	37
4,	41,	40,	60
5,	13,	18,	37

हम data.txt फ़ाइल से डेटा को निम्नलिखित तरीके से studentdata नामक ऐरे में लोड कर सकते हैं:

6.10.1 NumPy.loadtxt() का उपयोग करना

>>> studentdata = np.loadtxt(‘C:/NCERT/
$\quad$ data.txt’, skiprows=1, delimiter=’,’,
$\quad$ dtype = int)
>>> studentdata
array([[ 1, 36, 18, 57],
$\qquad$ [ 2, 22, 23, 45],
$\qquad$ [ 3, 43, 51, 37],
$\qquad$ [ 4, 41, 40, 60],
$\qquad$ [ 5, 13, 18, 27]])

उपरोक्त कथन में, पहले हम डेटा युक्त टेक्स्ट फ़ाइल का नाम और पथ निर्दिष्ट करते हैं। आइए np.loadtxt() फंक्शन में पास किए गए कुछ पैरामीटरों को समझें:

• पैरामीटर skiprows=1 दर्शाता है कि पहली पंक्ति हेडर पंक्ति है और इसलिए हमें इसे छोड़ना होगा क्योंकि हम इसे ऐरे में लोड नहीं करना चाहते।
• डिलिमिटर यह निर्दिष्ट करता है कि मान अल्पविराम, अर्धविराम, टैब या स्पेस (इन चारों को मिलाकर व्हाइटस्पेस कहा जाता है) या किसी अन्य वर्ण से अलग किए गए हैं। डिलिमिटर का डिफ़ॉल्ट मान स्पेस है।
• हम dtype आर्ग्युमेंट द्वारा बनने वाले ऐरे का डेटा टाइप भी निर्दिष्ट कर सकते हैं। डिफ़ॉल्ट रूप से, dtype फ़्लोट होता है।

हम unpack पैरामीटर का उपयोग करके डेटा फ़ाइल की प्रत्येक पंक्ति या कॉलम को अलग-अलग numpy ऐरेज़ में लोड कर सकते हैं। डिफ़ॉल्ट रूप से unpack=False का अर्थ है कि हम डेटा की प्रत्येक पंक्ति को अलग ऐरे के रूप में निकाल सकते हैं। जब unpack=True होता है, तो लौटाया गया ऐरे ट्रांसपोज़ हो जाता है, जिससे हम कॉलम को अलग ऐरेज़ के रूप में निकाल सकते हैं।

# डेटा को कई NumPy ऐरेज़ में आयात करने के लिए

# पंक्ति अनुसार। student1 से संबंधित मान

# ऐरे stud1 में, student2 का मान ऐरे stud2 में आदि।

>>> stud1, stud2, stud3, stud4, stud5 =

np.loadtxt(‘C:/NCERT/data.txt’,skiprows=1,

delimiter=’,’, dtype = int)

>>> stud1

array([ 1, 36, 18, 57])

>>> stud2

array([ 2, 22, 23, 45]) # और इसी तरह

.CSV फ़ाइलें या comma separated values फ़ाइलें एक प्रकार की टेक्स्ट फ़ाइलें होती हैं जिनमें मान अल्पविराम से अलग किए जाते हैं। एक CSV फ़ाइल टेबुलर डेटा को टेक्स्ट फ़ाइल में संग्रहीत करती है। CSV फ़ाइलों को NumPy ऐरेज़ में लोड किया जा सकता है और इन फंक्शनों का उपयोग करके उनके डेटा का विश्लेषण किया जा सकता है।

# डेटा को कॉलमवार कई arrays में import करें।
# कॉलम RollNo का डेटा array rollno में जाएगा,
# कॉलम Marks1 का डेटा array mks1 में जाएगा और इसी तरह।
>>> rollno, mks1, mks2, mks3 =
np.loadtxt(‘C:/NCERT/data.txt’,
skiprows=1, delimiter=’,’, unpack=True,
dtype = int)
>>> rollno
array([1, 2, 3, 4, 5])

>>> mks1
array([36, 22, 43, 41, 13])

>>> mks2
array([18, 23, 51, 40, 18])

>>> mks3
array([57, 45, 37, 60, 27])

6.10.2 NumPy.genfromtxt() का उपयोग

genfromtxt ( ) NumPy का एक अन्य फ़ंक्शन है जो फ़ाइलों से डेटा लोड करता है। loadtxt() की तुलना में, genfromtxt() डेटा फ़ाइल में मौजूद लापता मानों को भी संभाल सकता है। आइए निम्नलिखित फ़ाइल dataMissing.txt को देखें जिसमें कुछ लापता मान और कुछ गैर-संख्यात्मक डेटा हैं:

गतिविधि 6.1

क्या आप data.txt को header row सहित लोड करने का कमांड लिख सकते हैं?

RollNo	Marks1	Marks2	Marks3
1,	36,	18,	57
2,	ab,	23,	45
3,	43,	51,
4,	41,	40,	60
5,	13,	18,	27

>>> dataarray = np.genfromtxt(‘C:/NCERT/
$\quad$ dataMissing.txt’,skip_header=1,
$\quad$ delimiter = ‘,’)

>>> dataarray
array([[ 1., 36., 18., 57.],
$\qquad$ [ 2., nan, 23., 45.],
$\qquad$ [ 3., 43., 51., nan],
$\qquad$ [ 4., 41., 40., 60.],
$\qquad$ [ 5., 13., 18., 27.]])

genfromtxt() फ़ंक्शन संख्यात्मक कॉलमों में मौजूद लापता मानों और वर्ण स्ट्रिंग्स को nan में बदल देता है। लेकिन यदि हम dtype को int निर्दिष्ट करें, तो यह लापता या अन्य गैर-संख्यात्मक मानों को -1 में बदल देता है। हम इन लापता मानों और वर्ण स्ट्रिंग्स को डेटा फ़ाइलों में किसी विशिष्ट मान में भी बदल सकते हैं, filling_values पैरामीटर का उपयोग करके।

उदाहरण 6.10 आइए लापता या गैर-संख्यात्मक डेटा का मान -999 पर सेट करें:

>>> dataarray = np.genfromtxt(‘C:/NCERT/
$\quad$ dataMissing.txt’,skip_header=1,
$\quad$ delimiter=’,’, filling_values=-999,
$\quad$ dtype = int)

>>> dataarray
array([[ 1, 36, 18, 57],
$\qquad$ [ 2, -999, 23, 45],
$\qquad$ [ 3, 43, 51, -999],
$\qquad$ [ 4, 41, 40, 60],
$\qquad$ [ 5, 13, 18, 27]])

गतिविधि 6.2

क्या आप एक डेटाफ़ाइल बना सकते हैं और डेटा को कॉलमवार कई NumPy arrays में आयात कर सकते हैं? (संकेत: unpack पैरामीटर का उपयोग करें)

6.11 डिस्क पर फ़ाइलों में NumPy Arrays को सहेजना

savetxt() फ़ंक्शन का उपयोग एक NumPy array को टेक्स्ट फ़ाइल में सहेजने के लिए किया जाता है।

उदाहरण 6.11

>>> np.savetxt(‘C:/NCERT/testout.txt’,
studentdata, delimiter=’,’, fmt=’%i’)

नोट: हमने fmt पैरामीटर का उपयोग यह निर्दिष्ट करने के लिए किया है कि डेटा किस प्रारूप में सहेजा जाएगा। डिफ़ॉल्ट float है।

सारांश

• Array एक डेटा प्रकार है जो समान डेटा प्रकार (संख्यात्मक, पाठ आदि) के वस्तुओं को रखता है। Array के तत्व स्मृति में लगातार संग्रहीत किए जाते हैं। Array के प्रत्येक तत्व का एक सूचकांक या स्थिति मान होता है।
• NumPy वैज्ञानिक गणना के लिए एक Python लाइब्रेरी है जो डेटा को शक्तिशाली n-आयामी ndarray वस्तु में संग्रहीत करती है तेज गणनाओं के लिए।
• Array के प्रत्येक तत्व को array के नाम के साथ-साथ उस तत्व के सूचकांक द्वारा संदर्भित किया जाता है।
• numpy.array() एक फ़ंक्शन है जो numpy.ndarray प्रकार की वस्तु लौटाता है।
• सभी अंकगणितीय संचालन arrays पर किए जा सकते हैं जब दोनों arrays का आकार समान हो।
• NumPy arrays विस्तारणीय या विस्तारणीय नहीं होते हैं। एक बार numpy array परिभाषित हो जाने के बाद, वह स्मृति में जगह जो वह घेरता है वह निश्चित होती है और बदली नहीं जा सकती।
• numpy.split() एक array को कई उप-arrays में एक अक्ष के साथ टुकड़ों में काटता है।
• numpy.concatenate() फ़ंक्शन arrays को जोड़ने के लिए प्रयोग किया जा सकता है।
• numpy.loadtxt() और numpy.genfromtxt() फ़ंक्शन फ़ाइलों से डेटा लोड करने के लिए प्रयोग किए जाते हैं। savetxt() फ़ंक्शन एक NumPy array को टेक्स्ट फ़ाइल में सहेजने के लिए प्रयोग किया जाता है।

अभ्यास

1. NumPy क्या है? इसे कैसे स्थापित करें?

2. Array क्या है और यह सूची से कैसे भिन्न है? NumPy में अंतर्निहित array वर्ग का नाम क्या है?

3. आप ndarray के रैंक से क्या समझते हैं?

4. निम्नलिखित NumPy arrays बनाएं:

a) एक 1-D array जिसे zeros कहा जाता है, जिसमें 10 तत्व हैं और सभी तत्व शून्य पर सेट हैं।

b) एक 1-D array जिसे vowels कहा जाता है, जिसमें तत्व ’ $a$ ‘, ’e’, ‘i’, ‘o’ और ‘u’ हैं।

c) एक 2-D array जिसका नाम ones है, जिसमें 2 पंक्तियाँ और 5 स्तंभ हैं और सभी तत्व 1 पर सेट हैं और dtype int है।

d) नेस्टेड Python lists का उपयोग करके एक 2-D array बनाएँ जिसका नाम myarray1 है, जिसमें 3 पंक्तियाँ और 3 स्तंभ हैं और निम्नलिखित डेटा संग्रहीत करें:

$ \begin{array}{lll} 2.7, & -2, & -19 \ 0, & 3.4, & 99.9 \ 10.6, & 0, & 13 \end{array} $

e) एक 2-D array जिसका नाम myarray2 है, arange() का उपयोग करके, जिसमें 3 पंक्तियाँ और 5 स्तंभ हैं, प्रारंभ मान $=4$, स्टेप साइज़ 4 और dtype float है।

5. ऊपर प्रश्न 4 में बनाए गए arrays का उपयोग करके, निम्नलिखित के लिए NumPy कमांड लिखें:

a) Arrays zeros, vowels, ones, myarray1 और myarray2 की dimensions, shape, size, data type of the items और itemsize ज्ञात करें।

b) Array ones को reshape करें ताकि सभी 10 तत्व एकल पंक्ति में हों।

c) Array vowels का $2^{\text{nd}}$ और $3^{\text{rd}}$ तत्व प्रदर्शित करें।

d) Array myarray1 की $2^{\text{nd}}$ और $3^{\text{rd}}$ पंक्ति के सभी तत्व प्रदर्शित करें।

e) Array myarray1 के $1^{\text{st}}$ और $2^{\text{nd}}$ स्तंभ के तत्व प्रदर्शित करें।

f) Array myarray1 की $2^{\text{nd}}$ और $3^{\text{rd}}$ पंक्ति के $1^{\text{st}}$ स्तंभ के तत्व प्रदर्शित करें।

g) Array vowels को रिवर्स करें।

6. ऊपर प्रश्न 4 में बनाए गए arrays का उपयोग करके, निम्नलिखित के लिए NumPy कमांड लिखें:

NOTES a) Array ones के सभी तत्वों को 3 से विभाजित करें।

b) Arrays myarray1 और myarray2 को जोड़ें।

c) myarray1 को myarray2 से घटाएँ और परिणाम को एक नए array में संग्रहीत करें।

d) myarray1 और myarray2 को तत्व-दर-तत्व गुणा करें।

e) myarray1 और myarray2 का आव्यूह गुणन करें और परिणाम को नई सरणी myarray3 में संग्रहित करें।

f) myarray1 को myarray2 से विभाजित करें।

g) myarray1 के सभी तत्वों का घन निकालें और परिणामी सरणी को 2 से विभाजित करें।

h) myarray2 के सभी तत्वों का वर्गमूल निकालें और परिणामी सरणी को 2 से विभाजित करें। परिणाम दशमलव के दो स्थानों तक पूर्णांकित होना चाहिए।

7. ऊपर प्रश्न 4 में बनाई गई सरणियों का उपयोग करते हुए, निम्नलिखित के लिए NumPy आदेश लिखें:

a) ones और myarray2 का स्थानांतरण (transpose) निकालें।

b) सरणी vowels को उलट क्रम में सॉर्ट करें।

c) सरणी myarray1 को इस प्रकार सॉर्ट करें कि कॉलम का सबसे छोटा मान पहली पंक्ति में आए और इसी तरह आगे बढ़े।

8. ऊपर प्रश्न 4 में बनाई गई सरणियों का उपयोग करते हुए, निम्नलिखित के लिए NumPy आदेश लिखें:

a) NumPy .split() का उपयोग करके सरणी myarray2 को 5 सरणियों में कॉलमवार विभाजित करें। अपनी परिणामी सरणियों को myarray2A, myarray2B, myarray2C, myarray2D और myarray2E में संग्रहित करें। सरणियों myarray2A, myarray2B, myarray2C, myarray2D और myarray2E को प्रिंट करें।

b) सरणी zeros को सरणी सूचकांक 2, 5, 7, 8 पर विभाजित करें और परिणामी सरणियों को zerosA, zerosB, zerosC और zerosD में संग्रहित करें और उन्हें प्रिंट करें।

c) सरणियों myarray2A, myarray2B और myarray2C को 3 पंक्तियों और 3 कॉलमों वाली एक सरणी में संयोजित (concatenate) करें।

9. arange() का उपयोग करके एक 2-D array बनाइए जिसका नाम myarray4 हो, जिसमें 14 पंक्तियाँ और 3 स्तंभ हों, प्रारंभिक मान $=-1$ और चरण आकार 0.25 हो। इस array को पंक्ति-दर-पंक्ति 3 बराबर भागों में विभाजित कीजिए और परिणाम प्रिंट कीजिए।

10. ऊपर के प्रश्न में बनाए गए myarray4 का उपयोग करते हुए, निम्नलिखित के लिए आदेश लिखिए:

a) सभी तत्वों का योग निकालिए।

b) सभी तत्वों का योग पंक्ति-दर-पंक्ति निकालिए। c) सभी तत्वों का योग स्तंभ-दर-स्तंभ निकालिए।

d) सभी तत्वों में अधिकतम मान निकालिए।

e) प्रत्येक पंक्ति में सभी तत्वों का न्यूनतम मान निकालिए।

f) प्रत्येक पंक्ति में सभी तत्वों का माध्य निकालिए।

g) स्तंभ-दर-स्तंभ मानक विचलन निकालिए।

केस स्टडी (हल किया गया)

हम पहले ही सीख चुके हैं कि एक डेटा सेट (या dataset) डेटा का एक संग्रह होता है। आमतौर पर एक डेटा सेट किसी डेटाबेस टेबल की सामग्री या किसी सांख्यिकीय डेटा मैट्रिक्स से संबंधित होता है, जहाँ टेबल का प्रत्येक स्तंभ एक विशेष चर (variable) को दर्शाता है और प्रत्येक पंक्ति किसी सदस्य या आइटम आदि से संबंधित होती है। एक डेटा सेट प्रत्येक चर के लिए मान सूचीबद्ध करता है, जैसे किसी छात्र की ऊँचाई और वज़न, डेटा सेट की प्रत्येक पंक्ति (आइटम) के लिए। ओपन डेटा (Open data) उस सूचना को संदर्भित करता है जिसे सार्वजनिक रूप से सुलभ रिपॉज़िटरी में जारी किया गया हो।

आइरिस फूल डेटा सेट एक खुले डेटा का उदाहरण है। इसे फिशर का आइरिस डेटा सेट भी कहा जाता है क्योंकि यह डेटा सेट ब्रिटिश सांख्यिकीविद् और जीवविज्ञानी रोनाल्ड फिशर ने 1936 में प्रस्तुत किया था। आइरिस डेटा सेट में आइरिस फूल की तीन प्रजातियों (आइरिस सेटोसा, आइरिस वर्जिनिका और आइरिस वर्सीकलर) में से प्रत्येक के 50 नमूने शामिल हैं। प्रत्येक नमूने के लिए चार विशेषताएँ मापी गईं: सेफल और पेटल की लंबाई और चौड़ाई, सेंटीमीटर में। इन चार विशेषताओं के संयोजन के आधार पर, फिशर ने एक मॉडल विकसित किया जो एक प्रजाति को दूसरी से अलग करता है। पूरा डेटा सेट यूसीआई मशीन लर्निंग रिपॉजिटरी पर मुफ्त में उपलब्ध है https://archive.ics.uci.edu/ml/datasets/iris।

हम इस डेटा सेट के निम्नलिखित छोटे हिस्से का उपयोग करेंगे जिसमें 30 पंक्तियाँ हैं (तीनों प्रजातियों में से प्रत्येक के लिए 10 पंक्तियाँ)। हम प्रजाति संख्या के लिए एक कॉलम शामिल करेंगे जिसमें आइरिस सेटोसा के लिए मान 1, आइरिस वर्जिनिका के लिए 2 और आइरिस वर्सीकलर के लिए 3 होता है।

सेफल लंबाई	सेफल चौड़ाई	पेटल लंबाई	पेटल चौड़ाई	आइरिस	प्रजाति संख्या
5.1	3.5	1.4	0.2	Iris-setosa	1
4.9	3	1.4	0.2	Iris-setosa	1
4.7	3.2	1.3	0.2	Iris-setosa	1
4.6	3.1	1.5	0.2	Iris-setosa	1
5	3.6	1.4	0.2	Iris-setosa	1
5.4	3.9	1.7	0.4	Iris-setosa	1
4.6	3.4	1.4	0.3	Iris-setosa	1
5	3.4	1.5	0.2	Iris-setosa	1
4.4	2.9	1.4	0.2	Iris-setosa	1
4.9	3.1	1.5	0.1	Iris-setosa	1
5.5	2.6	4.4	1.2	Iris-versicolor	2
6.1	3	4.6	1.4	Iris-versicolor	2
5.8	2.6	4	1.2	Iris-versicolor	2
5	2.3	3.3	1	Iris-versicolor	2
5.6	2.7	4.2	1.3	Iris-versicolor	2
5.7	3	4.2	1.2	Iris-versicolor	2
5.7	2.9	4.2	1.3	Iris-versicolor	2
6.2	2.9	4.3	1.3	Iris-versicolor	2
5.1	2.5	3	1.1	Iris-versicolor	2
5.7	2.8	4.1	1.3	Iris-versicolor	2
6.9	3.1	5.4	2.1	Iris-virginica	3
6.7	3.1	5.6	2.4	Iris-virginica	3
6.9	3.1	5.1	2.3	Iris-virginica	3
5.8	2.7	5.1	1.9	Iris-virginica	3
6.8	3.2	5.9	2.3	Iris-virginica	3
6.7	3.3	5.7	2.5	Iris-virginica	3
6.7	3	5.2	2.3	Iris-virginica	3
6.3	2.5	5	1.9	Iris-virginica	3
6.5	3	5.2	2	Iris-virginica	3
6.2	3.4	5.4	2.3	Iris-virginica	3

आप इसे किसी भी टेक्स्ट एडिटर (नोटपैड, जीएडिट या कोई अन्य) में नीचे दिखाए गए तरीके से टाइप कर सकते हैं और फ़ाइल को Iris.txt नाम से सहेज सकते हैं। (यदि आप पूरे डेटासेट के साथ काम करना चाहते हैं तो आप इंटरनेट से इसके लिए .csv फ़ाइल डाउनलोड कर सकते हैं और उसे Iris.txt के रूप में सहेज सकते हैं)। शीर्षलेख इस प्रकार हैं:

सीपल लंबाई, सीपल चौड़ाई, पetal लंबाई, पetal चौड़ाई, आइरिस, प्रजाति संख्या

5.1, 3.5, 1.4, 0.2, Iris-setosa, 1

$4.9,3,1.4,0.2$, Iris-setosa, 1

$4.7,3.2,1.3,0.2$, Iris-setosa, 1

4.6, 3.1, 1.5, 0.2, Iris-setosa, 1

5, 3.6, 1.4, 0.2, Iris-setosa, 1

5.4, 3.9, 1.7, 0.4, Iris-setosa, 1

4.6, 3.4, 1.4, 0.3, Iris-setosa, 1

$5,3.4,1.5,0.2$, Iris-setosa, 1

4.4, 2.9, 1.4, 0.2, Iris-setosa, 1

4.9, 3.1, 1.5, 0.1, Iris-setosa, 1

5.5, 2.6, 4.4, 1.2, Iris-versicolor, 2

6.1, 3, 4.6, 1.4, Iris-versicolor, 2

5.8, 2.6, 4, 1.2, Iris-versicolor, 2

5, 2.3, 3.3, 1, Iris-versicolor, 2

5.6, 2.7, 4.2, 1.3, Iris-versicolor, 2

5.7, 3, 4.2, 1.2, Iris-versicolor, 2

5.7, 2.9, 4.2, 1.3, Iris-versicolor, 2

6.2, 2.9, 4.3, 1.3, Iris-versicolor, 2

5.1, 2.5, 3, 1.1, Iris-versicolor, 2

5.7, 2.8, 4.1, 1.3, Iris-versicolor, 2

$6.9,3.1,5.4,2.1$, Iris-virginica, 3

6.7, 3.1, 5.6, 2.4, Iris-virginica, 3

6.9, 3.1, 5.1, 2.3, Iris-virginica, 3

5.8, 2.7, 5.1, 1.9, Iris-virginica, 3

$6.8,3.2,5.9,2.3$, Iris-virginica, 3

6.7, 3.3, 5.7, 2.5, Iris-virginica, 3

$6.7,3,5.2,2.3$, Iris-virginica, 3

6.3, 2.5, 5, 1.9, Iris-virginica, 3

6.5, 3, 5.2, 2, Iris-virginica, 3

6.2, 3.4, 5.4, 2.3, Iris-virginica, 3

1. फ़ाइल Iris.txt में मौजूद डेटा को iris नामक 2-D array में लोड करें।

2. iris array से उस कॉलम को हटा दें जिसका इंडेक्स $=4$ है।

3. iris की shape, dimensions और size प्रदर्शित करें।

4. iris को तीन 2-D arrays में विभाजित करें, प्रत्येक array एक अलग species के लिए। उन्हें iris1, iris2, iris3 कहें।

5. तीनों arrays iris1, iris2, iris3 को प्रिंट करें।

6. एक 1-D array header बनाएँ जिसमें इस क्रम में तत्व हों: “sepal length”, “sepal width”, “petal length”, “petal width”, “Species No”।

7. array header को प्रदर्शित करें।

8. iris के कॉलमों के लिए max, min, mean और standard deviation ज्ञात करें और परिणामों को क्रमशः arrays iris_max, iris_min, iris_avg, iris_std, iris_var में संग्रहित करें। परिणामों को दो दशमलव स्थानों से अधिक नहीं राउंड करना है।

9. इसी प्रकार iris1, iris2 और iris3 के कॉलमों के लिए max, min, mean और standard deviation ज्ञात करें और परिणामों को उपयुक्त नामों वाले arrays में संग्रहित करें।

10. तीनों species के sepal length, sepal width, petal length और petal width के न्यूनतम मानों की तुलना पूरे डेटासेट के संबंधित न्यूनतम मानों से करें और नीचे दी गई तालिका में True भरें यदि species का मान डेटासेट के मान से अधिक है, अन्यथा False भरें।

	Iris setosa	Iris virginica	Iris versicolor
sepal length
sepal width
petal length
petal width

11. आइरिस सेटोसा की औसत सीपल चौड़ाई की तुलना आइरिस वर्जिनिका से करें।

12. आइरिस सेटोसा की औसत पेटल लंबाई की तुलना आइरिस वर्जिनिका से करें।

13. आइरिस सेटोसा की औसत पेटल चौड़ाई की तुलना आइरिस वर्जिनिका से करें।

14. सरणी iris_avg को हार्ड डिस्क पर IrisMeanValues.txt नाम से कॉमा सेपरेटेड फ़ाइल में सहेजें।

15. सरणियों iris_max, iris_avg, iris_min को हार्ड डिस्क पर Irisstat.txt नाम से कॉमा सेपरेटेड फ़ाइल में सहेजें।

केस स्टडी आधारित अभ्यासों के समाधान

>>> import numpy as np

>>> iris = np.genfromtxt(‘C:/NCERT/Iris.txt’,skip_
$\qquad$ header=1, delimiter=’,’, dtype = float)

# Q2 का समाधान

>>> iris = iris[0:30,[0,1,2,3,5]] # drop column 4

# Q3 का समाधान

>>> iris.shape
(30, 5)
>>> iris.ndim
2
>>> iris.size
150

# Q4 का समाधान

# Split into three arrays, each array for a different
# species
>>> iris1, iris2, iris3 = np.split(iris, [10,20], axis=0)

# Q5 का समाधान

# तीनों arrays को प्रिंट करें
>>> iris1
array([[5.1, 3.5, 1.4, 0.2, 1. ],
$\qquad$ [4.9, 3. , 1.4, 0.2, 1. ],
$\qquad$ [4.7, 3.2, 1.3, 0.2, 1. ],
$\qquad$ [4.6, 3.1, 1.5, 0.2, 1. ],
$\qquad$ [5. , 3.6, 1.4, 0.2, 1. ],
$\qquad$ [5.4, 3.9, 1.7, 0.4, 1. ],
$\qquad$ [4.6, 3.4, 1.4, 0.3, 1. ],
$\qquad$ [5. , 3.4, 1.5, 0.2, 1. ],
$\qquad$ [4.4, 2.9, 1.4, 0.2, 1. ],
$\qquad$ [4.9, 3.1, 1.5, 0.1, 1. ]])

>>> iris2
array([[5.5, 2.6, 4.4, 1.2, 2. ],
$\qquad$ [6.1, 3. , 4.6, 1.4, 2. ],
$\qquad$ [5.8, 2.6, 4. , 1.2, 2. ],
$\qquad$ [5. , 2.3, 3.3, 1. , 2. ],
$\qquad$ [5.6, 2.7, 4.2, 1.3, 2. ],
$\qquad$ [5.7, 3. , 4.2, 1.2, 2. ],
$\qquad$ [5.7, 2.9, 4.2, 1.3, 2. ],
$\qquad$ [6.2, 2.9, 4.3, 1.3, 2. ],
$\qquad$ [5.1, 2.5, 3. , 1.1, 2. ],
$\qquad$ [5.7, 2.8, 4.1, 1.3, 2. ]])

>>> iris3
array([[6.9, 3.1, 5.4, 2.1, 3. ],
$\qquad$ [6.7, 3.1, 5.6, 2.4, 3. ],
$\qquad$ [6.9, 3.1, 5.1, 2.3, 3. ],
$\qquad$ [5.8, 2.7, 5.1, 1.9, 3. ],
$\qquad$ [6.8, 3.2, 5.9, 2.3, 3. ],
$\qquad$ [6.7, 3.3, 5.7, 2.5, 3. ],
$\qquad$ [6.7, 3. , 5.2, 2.3, 3. ],
$\qquad$ [6.3, 2.5, 5. , 1.9, 3. ],
$\qquad$ [6.5, 3. , 5.2, 2. , 3. ],
$\qquad$ [6.2, 3.4, 5.4, 2.3, 3. ]])

# Q6 का समाधान

>>> header =np.array([“sepal length”, “sepal width”, “petal length”, “petal width”, “Species No”])

# प्रश्न 7 का समाधान

>>> print(header)
[‘sepal length’ ‘sepal width’ ‘petal length’ ‘petal width’ ‘Species No’]

# प्रश्न 8 का समाधान

# array iris के लिए आँकड़े
# sepal length, sepal
width, petal length, petal width, Species No के लिए डेटा का अधिकतम मान खोजता है
>>> iris_max = iris.max(axis=0)
>>> iris_max
array([6.9, 3.9, 5.9, 2.5, 3. ])

# sepal length, sepal
# width, petal length, petal width, Species No के लिए डेटा का न्यूनतम मान खोजता है
>>> iris_min = iris.min(axis=0)
>>> iris_min
array([4.4, 2.3, 1.3, 0.1, 1. ])

# sepal length, sepal
# width, petal length, petal width, Species No के लिए डेटा का औसत मान खोजता है
>>> iris_avg = iris.mean(axis=0).round(2)
>>> iris_avg
array([5.68, 3.03, 3.61, 1.22, 2. ])

# sepal
# length, sepal width, petal length, petal width,
# Species No के लिए डेटा का मानक विचलन खोजता है
>>> iris_std = iris.std(axis=0).round(2)
>>> iris_std
array([0.76, 0.35, 1.65, 0.82, 0.82])

# प्रश्न 9 का समाधान

>>> iris1_max = iris1.max(axis=0)
>>> iris1_max
array([5.4, 3.9, 1.7, 0.4, 1. ])

>>> iris2_max = iris2.max(axis=0)
>>> iris2_max
array([6.2, 3. , 4.6, 1.4, 2. ])

>>> iris3_max = iris3.max(axis=0)
>>> iris3_max
array([6.9, 3.4, 5.9, 2.5, 3. ])

>>> iris1_min = iris1.min(axis=0)
>>> iris1_min
array([4.4, 2.9, 1.3, 0.1, 1. ]) >>> iris2_min = iris2.min(axis=0)
>>> iris2_min
array([5. , 2.3, 3. , 1. , 2. ])

>>> iris3_min = iris3.min(axis=0)
>>> iris3_min
array([5.8, 2.5, 5. , 1.9, 3. ])

>>> iris1_avg = iris1.mean(axis=0)
>>> iris1_avg
array([4.86, 3.31, 1.45, 0.22, 1. ])

>>> iris2_avg = iris2.mean(axis=0)
>>> iris2_avg
array([5.64, 2.73, 4.03, 1.23, 2. ])

>>> iris3_avg = iris3.mean(axis=0)
>>> iris3_avg
array([6.55, 3.04, 5.36, 2.2 , 3. ])

>>> iris1_std = iris1.std(axis=0).round(2)
>>> iris1_std
array([0.28, 0.29, 0.1 , 0.07, 0. ])

>>> iris2_std = iris2.std(axis=0).round(2)
>>> iris2_std
array([0.36, 0.22, 0.47, 0.11, 0. ])

>>> iris3_std = iris3.std(axis=0).round(2)
>>> iris3_std
array([0.34, 0.25, 0.28, 0.2 , 0. ])

# Solution to Q10 (solve other parts on the same lines)

# min sepal length of each species Vs the min sepal
# length in the data set
>>> iris1_min[0] > iris_min[0] #sepal length
False
>>> iris2_min[0] > iris_min[0]
True
>>> iris3_min[0] > iris_min[0]
True

# Solution to Q11

#Compare Iris setosa and Iris virginica
>>> iris1_avg[1] > iris2_avg[1] #sepal width
True

# Solution to Q12

>>> iris1_avg[2] > iris2_avg[2] #petal length
False

# Solution to Q13

》> iris1_avg[3] > iris2_avg[3] #petal width False

# Solution to Q14

>>> np.savetxt(‘C:/NCERT/IrisMeanValues.txt’,
$\qquad$ iris_avg, delimiter = ‘,’)

# Solution to Q15

>>> np.savetxt(‘C:/NCERT/IrisStat.txt’, (iris_
$\qquad$ max, iris_avg, iris_min), delimiter=’,’)