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

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

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 एक डेटा प्रकार है जिसका उपयोग एकल पहचानकर्ता (वेरिएबल नाम) का उपयोग करके कई मान संग्रहीत करने के लिए किया जाता है। Array में डेटा तत्वों का एक क्रमबद्ध संग्रह होता है जहाँ प्रत्येक तत्व एक ही प्रकार का होता है और इसे उसके सूचकांक (स्थिति) द्वारा संदर्भित किया जा सकता है।

Contiguous memory

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

Now Contiguous

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

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 बनाने, हेरफेर करने और रूपांतरित करने के लिए बड़ा सेट रूटीन (built-in functions) है। Python भाषा में भी एक array डेटा संरचना है, लेकिन वह NumPy array जितनी बहुमुखी, कुशल और उपयोगी नहीं है। NumPy array को आधिकारिक तौर पर ndarray कहा जाता है लेकिन सामान्यतः array के नाम से जाना जाता है। इस अध्याय के बाकी भाग में, जब भी हम “array” शब्द का उपयोग करेंगे, हमारा तात्पर्य NumPy array से होगा। निम्नलिखित list और Array के बीच कुछ अंतर हैं।

6.3.1 Difference Between List and Array

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 1D-सरणी है, अनुक्रम में , के बाद कुछ नहीं है
>>> 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. हम सरणी बनाते समय dtype को array ( ) के आर्ग्यूमेंट के रूप में डेटा प्रकार (पूर्णांक, फ्लोट आदि) निर्दिष्ट कर सकते हैं। यह डेटा को स्वचालित रूप से उल्लिखित प्रकार में बदल देगा। निम्नलिखित उदाहरण में, पूर्णांकों की नेस्टेड सूची को array फंक्शन में पास किया गया है। चूँकि डेटा प्रकार को फ्लोट घोषित किया गया है, पूर्णांक फ्लोटिंग पॉइंट संख्याओं में बदल जाते हैं।

>>> 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 बनाया गया है जिसका
प्रारंभिक मान 0 और स्टेप आकार 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 विभिन्न विषयों में छात्रों के अंक

तालिका 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 Out of Bound “Index Error”. Index 4
is out of bounds for axis with size 3

6.4.2 स्लाइसिंग

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

उदाहरण 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])

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

# 2nd और 3rd row के 1st और 2nd column के elements access करना
# and 2nd column
>>> 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)

ध्यान देना महत्वपूर्ण है कि एलिमेंट-वाइज़ संचालन के लिए दोनों arrays का आकार समान होना चाहिए। अर्थात्, array1.shape का मान array2.shape के बराबर होना चाहिए।

6.5.2 ट्रांसपोज़

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

#ट्रांसपोज़
>>> 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]])

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

6.5.3 सॉर्टिंग

सॉर्टिंग का अर्थ है array के तत्वों को क्रमबद्ध करना, या तो आरोही या अवरोही क्रम में। डिफ़ॉल्ट रूप से 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 array में सॉर्टिंग दोनों अक्षों के अनुदेश की जा सकती है, अर्थात् पंक्ति-वार या स्तंभ-वार। डिफ़ॉल्ट रूप से सॉर्टिंग पंक्ति-वार (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 नाम की टेक्स्ट फ़ाइल में निम्नलिखित डेटा है।

हम 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 float होता है।

हम 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 सहित लोड करने का आदेश लिख सकते हैं?

>>> 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 के आयाम, आकृति, आकार, आइटमों का डेटा प्रकार और itemsize ज्ञात करें।

b) Array ones को रीशेप करें ताकि सभी 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 का ट्रांसपोज़ निकालें।

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 स्तंभों वाली एक सरणी में कंकटेनेट करें।

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 है।

sepal length, sepal width, petal length, petal width, iris, Species No

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।

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)

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

>>> iris = iris[0:30,[0,1,2,3,5]] # कॉलम 4 हटाएं

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

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

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

# तीन सरणियों में विभाजित करें, प्रत्येक सरणी एक अलग
# प्रजाति के लिए
>>> iris1, iris2, iris3 = np.split(iris, [10,20], axis=0)

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

# तीनों 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”])

# Q7 का समाधान

>>> print(header)
[‘सीपल लंबाई’ ‘सीपल चौड़ाई’ ‘पेटल लंबाई’ ‘पेटल चौड़ाई’ ‘प्रजाति संख्या’]

# Q8 का समाधान

# ऐरे iris के लिए आँकड़े
# सीपल लंबाई, सीपल
चौड़ाई, पेटल लंबाई, पेटल चौड़ाई, प्रजाति संख्या के लिए डेटा का अधिकतम मान खोजता है
>>> iris_max = iris.max(axis=0)
>>> iris_max
array([6.9, 3.9, 5.9, 2.5, 3. ])

# सीपल लंबाई, सीपल
चौड़ाई, पेटल लंबाई, पेटल चौड़ाई, प्रजाति संख्या के लिए डेटा का न्यूनतम मान खोजता है
>>> iris_min = iris.min(axis=0)
>>> iris_min
array([4.4, 2.3, 1.3, 0.1, 1. ])

# सीपल लंबाई, सीपल
चौड़ाई, पेटल लंबाई, पेटल चौड़ाई, प्रजाति संख्या के लिए डेटा का औसत मान खोजता है
>>> iris_avg = iris.mean(axis=0).round(2)
>>> iris_avg
array([5.68, 3.03, 3.61, 1.22, 2. ])

# सीपल लंबाई, सीपल चौड़ाई,
पेटल लंबाई, पेटल चौड़ाई, प्रजाति संख्या के लिए डेटा का मानक विचलन खोजता है
>>> iris_std = iris.std(axis=0).round(2)
>>> iris_std
array([0.76, 0.35, 1.65, 0.82, 0.82])

# Q9 का समाधान

>>> 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. ])

# Q10 का समाधान (अन्य भागों को भी इसी तरह हल करें)

# प्रत्येक प्रजाति की न्यूनतम सीपल लंबाई बनाम डेटा सेट में
# न्यूनतम सीपल लंबाई
>>> iris1_min[0] > iris_min[0] #sepal length
False
>>> iris2_min[0] > iris_min[0]
True
>>> iris3_min[0] > iris_min[0]
True

# Q11 का समाधान

#Iris setosa और Iris virginica की तुलना करें
>>> iris1_avg[1] > iris2_avg[1] #sepal width
True

# 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=’,’)