“यदि आप ध्यान से नहीं सोचेंगे, तो आप यह मान सकते हैं कि प्रोग्रामिंग केवल एक प्रोग्रामिंग भाषा में कथन टाइप करना है।”

— व. कनिंघम

2.1 Python लाइब्रेरीज़ का परिचय

Python लाइब्रेरीज़ में builtin मॉड्यूल्स का एक संग्रह होता है जो हमें कई कार्यों को उनके लिए विस्तृत प्रोग्राम लिखे बिना करने की अनुमति देता है। Python में प्रत्येक लाइब्रेरी में बड़ी संख्या में मॉड्यूल्स होते हैं जिन्हें आप import करके उपयोग कर सकते हैं।

NumPy, Pandas और Matplotlib वैज्ञानिक और विश्लेषणात्मक उपयोग के लिए तीन प्रतिष्ठित Python लाइब्रेरीज़ हैं। ये लाइब्रेरीज़ हमें डेटा को आसानी से और कुशलता से हेरफेर, रूपांतरित और दृश्यात्मक बनाने की अनुमति देती हैं।

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

PANDAS (PANelDAta) एक उच्च-स्तरीय डेटा हेरफेर टूल है जिसे डेटा का विश्लेषण करने के लिए उपयोग किया जाता है। Pandas लाइब्रेरी का उपयोग करके डेटा को import और export करना बहुत आसान है जिसमें फंक्शन्स का एक बहुत समृद्ध सेट है। यह NumPy और Matplotlib जैसे पैकेजों पर बना है और हमें डेटा विश्लेषण और दृश्यात्मक कार्यों के अधिकांश काम के लिए एकल, सुविधाजनक स्थान देता है। Pandas में तीन महत्वपूर्ण डेटा संरचनाएं हैं, अर्थात् Series, DataFrame और Panel, जो डेटा का विश्लेषण करने की प्रक्रिया को संगठित, प्रभावी और कुशल बनाती हैं।

पायथन में Matplotlib लाइब्रेरी ग्राफ़ प्लॉट करने और विज़ुअलाइज़ेशन के लिए उपयोग की जाती है। Matplotlib की मदद से मात्र कुछ पंक्तियों के कोड से ही हम प्रकाशन-गुणवत्ता वाले प्लॉट, हिस्टोग्राम, बार चार्ट, स्कैटरप्लॉट आदि उत्पन्न कर सकते हैं। यह Numpy पर भी आधारित है और Numpy तथा Pandas के साथ अच्छे से काम करने के लिए डिज़ाइन की गई है।

आप सोच सकते हैं कि जब NumPy डेटा विश्लेषण के लिए उपयोग किया जा सकता है, तब Pandas की क्या ज़रूरत है। नीचे Pandas और NumPy के बीच कुछ अंतर दिए गए हैं:

1. NumPy array समरूप डेटा की आवश्यकता होती है, जबकि Pandas DataFrame में विभिन्न डेटा प्रकार (float, int, string, datetime आदि) हो सकते हैं।
2. Pandas में फ़ाइल लोडिंग, प्लॉटिंग, चयन, जॉइनिंग, GROUP BY जैसे संचालनों के लिए सरल इंटरफ़ेस होता है, जो डेटा-प्रोसेसिंग अनुप्रयोगों में बहुत उपयोगी सिद्ध होते हैं।
3. Pandas DataFrames (कॉलम नामों के साथ) डेटा को ट्रैक करना बहुत आसान बना देते हैं।
4. जब डेटा टैब्युलर प्रारूप में होता है तब Pandas का उपयोग किया जाता है, जबकि NumPy संख्यात्मक array आधारित डेटा मैनिपुलेशन के लिए उपयोग किया जाता है।

2.1.1. Pandas इंस्टॉल करना

Pandas इंस्टॉल करना NumPy इंस्टॉल करने के समान ही है। कमांड लाइन से Pandas इंस्टॉल करने के लिए हमें टाइप करना होगा:

$$ \text { pip install pandas } $$

ध्यान दें कि NumPy और Pandas दोनों तभी इंस्टॉल किए जा सकते हैं जब उस सिस्टम पर पहले से Python इंस्टॉल हो। यही बात Python की अन्य लाइब्रेरीज़ के लिए भी सच है।

2.1.2. Pandas में डेटा संरचना

एक डेटा संरचना डेटा मानों और उस डेटा पर लागू किए जा सकने वाले संचालनों का संग्रह होता है। यह डेटा को कुशलता से संग्रहीत, पुनः प्राप्त और संशोधित करने में सक्षम बनाती है। उदाहरण के लिए, हमने कक्षा ग्यारह में NumPy में ndarray नामक डेटा संरचना पहले ही प्रयोग की है। याद कीजिए कि NumPy array का उपयोग कर डेटा को संग्रहीत, पहुँचाने और अद्यतन करना कितना आसान था। Pandas में दो सामान्यतः प्रयुक्त डेटा संरचनाएँ जिन्हें हम इस पुस्तक में कवर करेंगे, ये हैं:

• Series
• DataFrame

2.2 Series

Series एक एक-आयामी array होता है जिसमें किसी भी डेटा प्रकार (int, float, list, string, आदि) के मानों का क्रम होता है और जिनके साथ डिफ़ॉल्ट रूप से शून्य से शुरू होने वाले संख्यात्मक डेटा लेबल होते हैं। किसी विशेष मान से जुड़ा डेटा लेबल उसका index कहलाता है। हम index के रूप में अन्य डेटा प्रकारों के मान भी निर्धारित कर सकते हैं। हम Pandas Series की कल्पना किसी स्प्रेडशीट के एक कॉलम के रूप में कर सकते हैं। नीचे विद्यार्थियों के नामों वाली Series का उदाहरण दिया गया है:

Index $\quad$ Value
0 $\quad$ अर्नब
1 $\quad$ समृद्धि
2 $\quad$ रमित
3 $\quad$ दिव्यम
4 $\quad$ कृतिका

2.2.1 Creation of Series

Pandas में Series को बनाने के विभिन्न तरीके हैं। Series को बनाने या उपयोग करने के लिए, हमें सर्वप्रथम Pandas library को import करना होता है।

(A) Creation of Series from Scalar Values

Scalar मानों का उपयोग कर Series इस प्रकार बनाई जा सकती है:

>>> import pandas as pd #import Pandas with alias pd
>>> series1 = pd.Series([10,20,30]) #create a Series
>>> print(series1) #Display the series

Output:

0 $\quad$ 10
1 $\quad$ 20
2 $\quad$ 30

dtype: int 64

गतिविधि 2.1

भारत के किन्हीं पाँच प्रसिद्ध स्मारकों के नामों की एक श्रृंखला बनाएँ और उनके राज्यों को सूचकांक मानों के रूप में निर्धारित करें।

ध्यान दें कि आउटपुट दो स्तंभों में दिखाया गया है - बाईं ओर सूचकांक है और दाईं ओर डेटा मान है। यदि हम डेटा मानों के लिए स्पष्ट रूप से सूचकांक निर्दिष्ट नहीं करते हैं, तो डिफ़ॉल्ट रूप से सूचकांक 0 से $N-1$ तक होते हैं। यहाँ $N$ डेटा तत्वों की संख्या है।

हम सूचकांक को उपयोगकर्ता-परिभाषित लेबल भी दे सकते हैं और उनका उपयोग करके Series के तत्वों को एक्सेस कर सकते हैं। निम्नलिखित उदाहरण में सूचकांक यादृच्छिक क्रम में संख्यात्मक है।

>>> series2 = pd.Series([“कवि”,“श्याम”,“रवि”], index=[3,5,1]) >>> print(series2) #श्रृंखला को प्रदर्शित करें

आउटपुट:

3 $\quad$ कवि
5 $\quad$ श्याम
1 $\quad$ रवि

dtype: object

यहाँ, डेटा मान कवि, श्याम और रवि के सूचकांक मान क्रमशः 3, 5 और 1 हैं। हम अक्षरों या स्ट्रिंग्स को भी सूचकांक के रूप में उपयोग कर सकते हैं, उदाहरण के लिए:

>>> series2 = pd.Series([2,3,4],index=[“फर”,“मार”,“अप्र”])
>>> print(series2) #श्रृंखला को प्रदर्शित करें

आउटपुट:

फर $\quad$ 2
मार $\quad$ 3
अप्र $\quad$ 4

dtype: int 64

यहाँ, डेटा मान 2,3,4 के सूचकांक मान क्रमशः फर, मार और अप्र हैं।

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

Pandas आयात करते समय क्या हमेशा pd को उपनाम के रूप में उपयोग करना अनिवार्य है? यदि हम कोई अन्य नाम दें तो क्या होगा?

(B) NumPy Arrays से Series का निर्माण

हम एक-आयामी (1D) NumPy array से Series बना सकते हैं, जैसा कि नीचे दिखाया गया है:

>>> import numpy as np # NumPy को np उपनाम से आयात करें
>>> import pandas as pd
>>> array1 = np.array([1,2,3,4])
>>> series3 = pd.Series(array1)
>>> print(series3)

आउटपुट:

0 $\quad$ 1
1 $\quad$ 2
2 $\quad$ 3
3 $\quad$ 4

dtype: int 32

निम्न उदाहरण दिखाता है कि हम अनुक्रमण के लिए अक्षरों या स्ट्रिंग्स का उपयोग कर सकते हैं:

>>> series4 = pd.Series(array1, index = [“Jan”, “Feb”, “Mar”, “Apr”])
>>> print(series4)

जब सरणी के साथ अनुक्रमण लेबल पास किए जाते हैं, तो अनुक्रमण और सरणी की लंबाई समान होनी चाहिए, अन्यथा यह ValueError उत्पन्न करेगा। नीचे दिखाए गए उदाहरण में, array1 में 4 मान हैं जबकि केवल 3 अनुक्रमण हैं, इसलिए ValueError प्रदर्शित होता है।

>>> series5 = pd.Series(array1, index = [“Jan”, “Feb”, “Mar”])
ValueError: Length of passed values is 4, index implies 3

(C) डिक्शनरी से सीरीज़ का निर्माण

याद कीजिए कि Python डिक्शनरी में key: value जोड़े होते हैं और जब किसी key को जाना जाता है तो उसका value तेजी से प्राप्त किया जा सकता है। डिक्शनरी की keys को किसी Series के लिए अनुक्रमण बनाने के लिए उपयोग किया जा सकता है, जैसा कि निम्न उदाहरण में दिखाया गया है। यहाँ, डिक्शनरी dict1 की keys सीरीज़ में indices बन जाती हैं।

>>> dict1 = {‘India’: ‘NewDelhi’, ‘UK’: ‘London’, ‘Japan’: ‘Tokyo’}
>>> print(dict1) # डिक्शनरी प्रदर्शित करें {‘India’: ‘NewDelhi’, ‘UK’: ‘London’, ‘Japan’: ‘Tokyo’}
>>> series8 = pd.Series(dict1)
>>> print(series8) # सीरीज़ प्रदर्शित करें

India $\quad$ NewDelhi
UK $\quad$ London
Japan $\quad$ Tokyo

dtype: object

2.2.2 सीरीज़ के तत्वों तक पहुँचना

सीरीज़ के तत्वों तक पहुँचने के दो सामान्य तरीके हैं: इंडेक्सिंग और स्लाइसिंग।

(A) इंडेक्सिंग

सीरीज़ में इंडेक्सिंग नुम्पाय ऐरे की तरह ही होती है, और इसका उपयोग सीरीज़ में तत्वों तक पहुँचने के लिए किया जाता है। इंडेक्स दो प्रकार के होते हैं: पोज़िशनल इंडेक्स और लेबल्ड इंडेक्स। पोज़िशनल इंडेक्स एक पूर्णांक मान लेता है जो सीरीज़ में उसकी स्थिति से मेल खाता है, 0 से शुरू होकर, जबकि लेबल्ड इंडेक्स कोई उपयोगकर्ता-परिभाषित लेबल इंडेक्स के रूप में लेता है।

• निम्न उदाहरण सीरीज़ से मान तक पहुँचने के लिए पोज़िशनल इंडेक्स के उपयोग को दर्शाता है।

>>> seriesNum = pd.Series([10,20,30])
>>> seriesNum[2]
30

यहाँ, पोज़िशनल इंडेक्स 2 के लिए मान 30 प्रदर्शित होता है।

जब लेबल निर्दिष्ट किए जाते हैं, तो हम सीरीज़ से मान चुनते समय लेबल को इंडेक्स के रूप में उपयोग कर सकते हैं, जैसा नीचे दिखाया गया है। यहाँ, लेबल्ड इंडेक्स Mar के लिए मान 3 प्रदर्शित होता है।

>>> seriesMnths = pd.Series([2,3,4],index=[“Feb”,“Mar”,“Apr”])
>>> seriesMnths[“Mar”]
3

निम्न उदाहरण में, लेबल्ड इंडेक्स India के लिए मान NewDelhi प्रदर्शित होता है।

>>> seriesCapCntry = pd.Series([‘NewDelhi’, ‘WashingtonDC’, ‘London’, ‘Paris’], index=[‘India’, ‘USA’, ‘UK’, ‘France’])
>>> seriesCapCntry[‘India’]
‘NewDelhi’

गतिविधि 2.2

NewDelhi को आउटपुट के रूप में पाने के लिए पोज़िशनल इंडेक्स का उपयोग करते हुए कथन लिखें।

हम पोज़िशनल इंडेक्स का उपयोग करके भी सीरीज़ के तत्व तक पहुँच सकते हैं:

>>> seriesCapCntry[1]
‘WashingtonDC’

एक श्रेणी के एक से अधिक तत्वों को पहुंचा जा सकता है पदानुक्रमित पूर्णांकों की सूची या सूचकांक लेबलों की सूची का उपयोग करके जैसा कि निम्नलिखित उदाहरणों में दिखाया गया है:

>>> seriesCapCntry[[3,2]]

France $\quad$ Paris
UK $\quad$ London

dtype: object

>>> seriesCapCntry[[‘UK’,‘USA’]]

UK $\quad$ London
USA $\quad$ WashingtonDC

dtype: object

श्रेणी से संबद्ध सूचकांक मानों को बदला जा सकता है नए सूचकांक मान निर्धारित करके जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

>>> seriesCapCntry.index=[10,20,30,40]
>>> seriesCapCntry

10 $\quad$ NewDelhi
20 $\quad$ WashingtonDC
30 $\quad$ London
40 $\quad$ Paris

dtype: object

(B) स्लाइसिंग

कभी-कभी हमें श्रेणी का एक भाग निकालने की आवश्यकता हो सकती है। यह स्लाइसिंग के माध्यम से किया जा सकता है। यह NumPy arrays के साथ प्रयुक्त स्लाइसिंग के समान है। हम यह परिभाषित कर सकते हैं कि श्रेणी का कौन-सा भाग स्लाइस किया जाना है आरंभ और अंत पैरामीटर [start :end] श्रेणी नाम के साथ निर्दिष्ट करके। जब हम पदानुक्रमित सूचकांकों का उपयोग स्लाइसिंग के लिए करते हैं, तो अंत-सूचकांक स्थिति पर स्थित मान को छोड़ दिया जाता है, अर्थात् केवल (end-start) संख्या के डेटा मान श्रेणी से निकाले जाते हैं। निम्नलिखित श्रेणी seriesCapCntry पर विचार करें:

>>> seriesCapCntry = pd.Series([‘NewDelhi’, ‘WashingtonDC’, ‘London’, ‘Paris’], index=[‘India’, ‘USA’, ‘UK’, ‘France’])
>>> seriesCapCntry[1:3] #excludes the value at index position 3

USA $\quad$ WashingtonDC
UK $\quad$ London

dtype: object

जैसा कि हम ऊपर के आउटपुट में देख सकते हैं, केवल सूचकांक 1 और 2 पर डेटा मान प्रदर्शित किए गए हैं। यदि स्लाइसिंग के लिए लेबल वाले सूचकांक उपयोग किए जाते हैं, तो अंतिम सूचकांक लेबल पर स्थित मान भी आउटपुट में शामिल होता है, उदाहरण के लिए:

>>> seriesCapCntry[‘USA’ : ‘France’]

USA $\quad$ वॉशिंगटनडीसी
UK $\quad$ लंदन
France $\quad$ पेरिस

dtype: object

हम श्रृंखला को उलटे क्रम में भी प्राप्त कर सकते हैं, उदाहरण के लिए:

>>> seriesCapCntry[ : : -1]

France $\quad$ पेरिस
UK $\quad$ लंदन
USA $\quad$ वॉशिंगटनडीसी
India $\quad$ नईदिल्ली

dtype: object

हम श्रृंखला तत्वों के मानों को संशोधित करने के लिए स्लाइसिंग का भी उपयोग कर सकते हैं जैसा कि निम्न उदाहरण में दिखाया गया है:

>>> import numpy as np
>>> seriesAlph = pd.Series(np.arange(10,16,1), index = [‘a’, ‘b’, ‘c’, ’d’, ’e’, ‘f’])
>>> seriesAlph

a $\quad$ 10
b $\quad$ 11
c $\quad$ 12
d $\quad$ 13
e $\quad$ 14
f $\quad$ 15

dtype: int32

>>> seriesAlph[1:3] = 50
>>> seriesAlph

a $\quad$ 10
b $\quad$ 50
c $\quad$ 50
d $\quad$ 13
e $\quad$ 14
f $\quad$ 15

dtype: int32

ध्यान दें कि स्लाइसिंग का उपयोग करके श्रृंखला में मानों को अपडेट करने पर अंतिम सूचकांक स्थिति पर स्थित मान को छोड़ा जाता है। लेकिन, जब लेबल का उपयोग करके स्लाइसिंग की जाती है तो अंतिम सूचकांक लेबल पर स्थित मान बदल जाता है।

>>> seriesAlph[‘c’:’e’] = 500
>>> seriesAlph

a $\quad$ 10
b $\quad$ 50
c $\quad$ 500
d $\quad$ 500
e $\quad$ 500
f $\quad$ 15

dtype: int32

2.2.3 श्रृंखला के गुणधर्म

हम किसी series का नाम उस property के साथ प्रयोग करके कुछ विशेष properties जिन्हें attributes कहा जाता है, access कर सकते हैं। तालिका 2.1 कुछ Pandas series attributes को उदाहरण के तौर पर seriesCapCntry के साथ सूचीबद्ध करती है:

>>> seriesCapCntry

India $\quad$ NewDelhi
USA $\quad$ WashingtonDC
UK $\quad$ London
France $\quad$ Paris

dtype: object

तालिका 2.1 Pandas Series के Attributes

Attribute Name	Purpose	Example
name	Series को एक नाम देता है	>>> seriesCapCntry.name = ‘Capitals’ >>> print(seriesCapCntry) India $\quad$ NewDelhi USA $\quad$ WashingtonDC UK $\quad$ London France $\quad$ Paris Name: Capitals, dtype: object
index.name	series के index को एक नाम देता है	>>>seriesCapCntry. index. name $=$ ’ Countries’ >>>print(seriesCapCntry) Countries India $\quad$ NewDelhi USA $\quad$ WashingtonDC UK $\quad$ London France $\quad$ Paris Name: Capitals, dtype: object
values	series में मौजूद values की सूची प्रिंट करता है	>>> print (seriesCapCntry. val ues) [‘NewDelhi’ ‘WashingtonDC’ ‘London’ ‘Paris’]
size	Series object में मौजूद values की संख्या प्रिंट करता है	>>>print(seriesCapCntry. size) 4
empty	यदि series खाली है तो True प्रिंट करता है, अन्यथा False	»> seriesCapCntry. empty False # एक खाली series बनाएँ seriesEmpt=pd. Series() >>> seriesEmpt. empty True

गतिविधि 2.3

निम्नलिखित कोड पर विचार करें:
>>>import pandas as pd
>>>import numpy as np
>>>s = pd.
Series([12,np.nan, 10])
>>>print (s)

उपरोक्त कोड का आउटपुट ज्ञात करें और ऊपर दी गई श्रृंखला में केवल गैर-खाली मानों को गिनने और प्रदर्शित करने के लिए एक Python कथन लिखें।

2.2.4 श्रेणी की विधियाँ

इस खंड में, हम उन कुछ विधियों पर चर्चा करने जा रहे हैं जो Pandas Series के लिए उपलब्ध हैं। आइए निम्नलिखित श्रृंखला पर विचार करें:

>>> seriesTenTwenty=pd. Series(np. arange( 10, 20, 1))
>>> print(seriesTenTwenty)

$0 \quad 10$
$1 \quad 11$
$2 \quad 12$
$3 \quad 13$
$4 \quad 14$
$5 \quad 15$
$6 \quad 16$
$7 \quad 17$
$8 \quad 18$
$9 \quad 19$

dtype: int 32

विधि	व्याख्या	उदाहरण
head(n)	श्रेणी के पहले n सदस्यों को लौटाता है। यदि n का मान नहीं दिया गया है, तो डिफ़ॉल्ट रूप से n 5 लेता है और पहले पाँच सदस्य प्रदर्शित होते हैं।	>>>seriesTenTwenty.head(2) 0 $\quad$ 10 1 $\quad$ 11 dtype: int32 >>>seriesTenTwenty.head() 0 $\quad$ 10 1 $\quad$ 11 2 $\quad$ 12 3 $\quad$ 13 4 $\quad$ 14 dtype: int32
count()	श्रेणी में गैर-NaN मानों की संख्या लौटाता है	>>>seriesTenTwenty.count()10
tail(n)	श्रेणी के अंतिम n सदस्यों को लौटाता है। यदि n का मान नहीं दिया गया है, तो डिफ़ॉल्ट रूप से n 5 लेता है और अंतिम पाँच सदस्य प्रदर्शित होते हैं।	>>> seriesTenTwenty.tail(2) 8 $\quad$ 18 9 $\quad$ 19 dtype: int32 >>> seriesTenTwenty.tail() 5 $\quad$ 15 6 $\quad$ 16 7 $\quad$ 17 8 $\quad$ 18 9 $\quad$ 19 dtype: int32

2.2.5 श्रेणी पर गणितीय संचालन

हमने कक्षा ग्यारह में सीखा है कि यदि हम दो NumPy arrays पर जोड़, घटाव, गुणा, भाग जैसी मूलभूत गणितीय क्रियाएँ करते हैं, तो संचालन प्रत्येक संगत जोड़ी के तत्वों पर किया जाता है। इसी प्रकार, हम Pandas में दो श्रेणियों पर गणितीय संचालन कर सकते हैं।

श्रेणियों पर गणितीय संचालन करते समय सूचकांक मिलान लागू किया जाता है और सभी लापता मान डिफ़ॉल्ट रूप से NaN से भरे जाते हैं।

निम्नलिखित श्रृंखलाओं पर विचार करें: seriesA और seriesB पांडास में श्रृंखलाओं पर गणितीय संचालन को समझने के लिए।

>>> seriesA = pd.Series([1,2,3,4,5], index = [‘a’, ‘b’, ‘c’, ’d’, ’e’])
>>> seriesA
a $\quad$ 1
b $\quad$ 2
c $\quad$ 3
d $\quad$ 4
e $\quad$ 5
dtype: int64

>>> seriesB = pd.Series([10,20,-10,-50,100], index = [‘z’, ‘y’, ‘a’, ‘c’, ’e’])
>>> seriesB
z $\quad$ 10
y $\quad$ 20
a $\quad$ -10
c $\quad$ -50
e $\quad$ 100
dtype: int64

(A) दो श्रृंखलाओं का योग

इसे दो तरीकों से किया जा सकता है। पहली विधि में, दो श्रृंखलाओं को सरलता से एक साथ जोड़ा जाता है, जैसा कि निम्नलिखित कोड में दिखाया गया है। तालिका 2.2 योग करते समय मिलान किए गए विस्तृत मानों को दर्शाती है। यहाँ ध्यान दें कि यदि एक या दोनों अवयवों में कोई मान नहीं है तो योग का आउटपुट $\mathrm{NaN}$ होता है।

_>>> seriesA + seriesB
_ a $\quad$ -9.0
b $\quad$ NaN
c $\quad$ -47.0
d $\quad$ NaN
e $\quad$ 105.0
y $\quad$ NaN
z $\quad$ NaN
dtype: float64

तालिका 2.2 दो श्रृंखलाओं के योग का विवरण

index	value from seriesA	value from seriesB	seriesA + seriesB
a	1	-10	-9.0
b	2		NaN
c	3	-50	-47.0
d	4		$\mathrm{NaN}$
e	5	100	105.00
y		20	$\mathrm{NaN}$
z		10	$\mathrm{NaN}$

दूसरी विधि तब लागू होती है जब हम आउटपुट में NaN मान नहीं चाहते। हम series मेथड add() और पैरामीटर fill_value का उपयोग करके गायब मान को एक निर्धारित मान से बदल सकते हैं। अर्थात् seriesA.add(seriesB) को कॉल करना seriesA+seriesB को कॉल करने के समतुल्य है, लेकिन add() किसी भी ऐसे तत्व के लिए fill value को स्पष्ट रूप से निर्दिष्ट करने की अनुमति देता है जो seriesA या seriesB में गायब हो सकता है, जैसा कि Table 2.3 में दिखाया गया है।

गतिविधि 2.4

Table 2.2 और 2.3 के समान घटाव के लिए दो तालिकाएँ बनाएँ जो series तत्वों और संगत आउटपुट में परिवर्तन को दिखाएँ—पहले गायब मानों को बदले बिना और फिर गायब मानों को 1000 से बदलने के बाद।

>>> seriesA.add(seriesB, fill_value=0)
a $\quad$ -9.0
b $\quad$ 2.0
c $\quad$ -47.0
d $\quad$ 4.0
e $\quad$ 105.0
y $\quad$ 20.0
z $\quad$ 10.0
dtype: float64

Table 2.3 add() मेथड से दो series के योग का विवरण

index	value from seriesA	value from seriesB	seriesA + seriesB
a	1	-10	-9.0
b	2	0	2.0
c	3	-50	-47.0
d	4	0	4.0
e	5	100	105.00
y	0	20	20.0
z	0	10	10.0

ध्यान दें कि तालिका 2.2 श्रेणी के तत्वों में बिना लापता मानों को बदले हुए परिवर्तन और संगत आउटपुट दिखाती है, जबकि तालिका 2.3 लापता मानों को 0 से बदलने के बाद श्रेणी के तत्वों में परिवर्तन और संगत आउटपुट दिखाती है। योग की तरह ही, घटाव, गुणा और भाग भी संगत गणितीय संचालकों का उपयोग करके या उपयुक्त विधि की स्पष्ट रूप से कॉल करके किए जा सकते हैं।

गतिविधि 2.5

गुणा के लिए तालिका 2.2 और 2.3 के समान दो तालिकाएँ बनाएँ जो लापता मानों को बदले बिना और लापता मानों को 0 से बदलने के बाद श्रेणी के तत्वों में परिवर्तन और संगत आउटपुट दिखाएँ।

(B) दो श्रेणियों का घटाव

इसे भी दो अलग-अलग तरीकों से किया जा सकता है, जैसा कि निम्न उदाहरणों में दिखाया गया है:[^0]

_>>> seriesA – seriesB #घटाव संचालक का उपयोग
_ a $\quad$ 11.0
b $\quad$ NaN
c $\quad$ 53.0
d $\quad$ NaN
e $\quad$ -95.0
y $\quad$ NaN
z $\quad$ NaN
dtype: float64

आइए अब घटाव से पहले लापता मानों को 1000 से बदलें और फिर स्पष्ट घटाव विधि sub() का उपयोग करके seriesB को seriesA से घटाएँ।

>>> seriesA.sub(seriesB, fill_value=1000)
# स्पष्ट रूप से विधि को कॉल करते समय fill value 1000 का उपयोग
$\quad$ # विधि की कॉल करते समय”
a $\quad$ 11.0
b $\quad$ -998.0
c $\quad$ 53.0
d $\quad$ -996.0
e $\quad$ -95.0
y $\quad$ 980.0
z $\quad$ 990.0
dtype: float64

(C) दो श्रेणियों का गुणा

फिर, इसे दो अलग-अलग तरीकों से किया जा सकता है, जैसा कि निम्नलिखित उदाहरणों में दिखाया गया है:

>>>seriesA * seriesB # गुणा ऑपरेटर का उपयोग करते हुए
a $\quad$ -10.0
b $\quad$ NaN
c $\quad$ -150.0
d $\quad$ NaN
e $\quad$ 500.0
y $\quad$ NaN
z $\quad$ NaN
dtype: float64

गतिविधि 2.6

विभाजन के लिए दो तालिकाएँ बनाएँ जो तालिका 2.2 और 2.3 के समान हों, जिनमें श्रृंखला तत्वों और संगत आउटपुट में परिवर्तन दिखाएँ बिना लापता मानों को बदले, और लापता मानों को 0 से बदलने के बाद।

आइए अब श्रृंखलाB को श्रृंखलाA से गुणा करने से पहले लापता मानों को 0 से बदल दें, स्पष्ट गुणा विधि mul() का उपयोग करके।

>>> seriesA.mul(seriesB, fill_value=0)
# विधि को स्पष्ट रूप से बुलाते समय
# fill value 0 का उपयोग करना
a $\quad$ -10.0
b $\quad$ 0.0
c $\quad$ -150.0
d $\quad$ 0.0
e $\quad$ 500.0
y $\quad$ 0.0
z $\quad$ 0.0
dtype: float64

गणितीय संक्रिया के लिए स्पष्ट कॉल तब प्राथमिकता दी जाती है जब श्रृंखला में लापता मान हो सकते हैं और हम उसे किसी विशिष्ट मान से बदलना चाहते हैं ताकि $\mathrm{NaN}$ के स्थान पर एक ठोस आउटपुट प्राप्त हो सके।

(D) दो श्रृंखलाओं का विभाजन

फिर, इसे दो अलग-अलग तरीकों से किया जा सकता है, जैसा कि निम्नलिखित उदाहरणों में दिखाया गया है:

>>> seriesA/seriesB # विभाजन ऑपरेटर का उपयोग करते हुए
a $\quad$ -0.10
b $\quad$ NaN
c $\quad$ -0.06
d $\quad$ NaN
e $\quad$ 0.05
y $\quad$ NaN
z $\quad$ NaN
dtype: float64

आइए अब स्पष्ट विभाजन विधि $\operatorname{div}($ ) का उपयोग करके seriesA को seriesB से विभाजित करने से पहले लापता मानों को 0 से प्रतिस्थापित करें।

# स्पष्ट विधि को कॉल करते समय
# fill value 0 का उपयोग करना

a $\quad$ -0.10
b $\quad$ inf
c $\quad$ -0.06
d $\quad$ inf
e $\quad$ 0.05
y $\quad$ 0.00
z $\quad$ 0.00
dtype: float64

2.3 DataFrame

कभी-कभी हमें एक साथ कई कॉलम पर काम करना होता है, अर्थात् हमें सारणीबद्ध डेटा को प्रोसेस करना होता है। उदाहरण के लिए, किसी कक्षा का परिणाम, किसी रेस्तरां की मेन्यू सूची, ट्रेन का आरक्षण चार्ट आदि। Pandas ऐसे सारणीबद्ध डेटा को DataFrame के रूप में संग्रहीत करता है। DataFrame एक द्वि-आयामी लेबलयुक्त डेटा संरचना है जो MySQL की तालिका के समान है। इसमें पंक्तियाँ और कॉलम होते हैं, और इसलिए इसमें एक पंक्ति तथा कॉलम सूचकांक दोनों होते हैं। प्रत्येक कॉलम में अलग-अलग प्रकार के मान जैसे संख्यात्मक, स्ट्रिंग, बूलियन आदि हो सकते हैं, जैसा कि डेटाबेस की तालिकाओं में होता है।

	State	Geographical Area (sq Km)	Area under Very Dense Forests (sq Km)
1	Assam	78438	2797
2	Delhi	1483	6.72
3	Kerala	38852	1663

2.3.1 Creation of DataFrame

DataFrame बनाने के कई तरीके हैं। उनमें से कुछ इस खंड में सूचीबद्ध हैं।

(A) Creation of an empty DataFrame

एक खाली DataFrame इस प्रकार बनाया जा सकता है:

>>> import pandas as pd
>>> dFrameEmt = pd. DataFrame()
>>> dFrameEmt

Empty Dataframe
Columns: [ ]
Index: [ ]

सोचें और विचार करें

यदि हम उपरोक्त कोड में 4 के बजाय 3 कॉलम या 5 कॉलम पास करें तो क्या होगा? कारण क्या है?

(B) नमपी ndarrays से डेटाफ्रेम का निर्माण

निम्नलिखित तीन नमपी ndarrays पर विचार करें। आइए बिना किसी कॉलम लेबल के, एकल ndarray का उपयोग करके एक सरल डेटाफ्रेम बनाएं:

>>> import numpy as np
>>> array1 = np.array([10,20,30])
>>> array2 = np.array([100,200,300])
>>> array3 = np.array([-10,-20,-30, -40])
>>> dFrame4 = pd.DataFrame(array1)
>>> dFrame4

0 1 2	0 10 20 30

हम एक से अधिक ndarrays का उपयोग करके डेटाफ्रेम बना सकते हैं, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

>>> dFrame5 = pd.DataFrame([array1, array3, array2], columns=[ ‘A’, ‘B’, ‘C’, ‘D’])
>>> dFrame5

0 1 2	A 10 -10 100	B 20 -20 200	C 30 -30 300	D NaN -40.0 NaN

(C) शब्दकोशों की सूची से डेटाफ्रेम का निर्माण

हम शब्दकोशों की सूची से डेटाफ्रेम बना सकते हैं, उदाहरण के लिए:

# Create list of dictionaries
>>> listDict = [{‘a’:10, ‘b’:20}, {‘a’:5, ‘b’:10, ‘c’:20}]
>>> dFrameListDict = pd.DataFrame(listDict)
>>> dFrameListDict

0 1	a 10 5	b 20 10	c NaN 20.0

यहाँ, शब्दकोश की कुंजियों को स्तंभ लेबल के रूप में लिया जाता है, और प्रत्येक कुंजी से संबंधित मानों को पंक्तियों के रूप में लिया जाता है। जितने शब्दकोश सूची में मौजूद हैं, उतनी ही पंक्तियाँ होंगी। उपरोक्त उदाहरण में सूची में दो शब्दकोश हैं। इसलिए, डेटाफ्रेम में दो पंक्तियाँ हैं। डेटाफ्रेम में स्तंभों की संख्या सूची के किसी भी शब्दकोश में उपस्थित अधिकतम कुंजियों की संख्या के बराबर होती है। इसलिए, तीन स्तंभ हैं क्योंकि दूसरे शब्दकोश में तीन तत्व हैं। साथ ही, ध्यान दें कि यदि किसी स्तंभ के लिए संगत मान गायब है तो NaN (Not a Number) डाला जाता है।

(D) सूचियों के शब्दकोश से डेटाफ्रेम का निर्माण

डेटाफ्रेम सूचियों के शब्दकोश से भी बनाए जा सकते हैं। निम्नलिखित शब्दकोश पर विचार करें जिसमें कुंजियाँ ‘State’, ‘GArea’ (भौगोलिक क्षेत्र) और ‘VDF’ (अत्यंत घना वन) हैं और संगत मान सूची के रूप में हैं।

>>> dictForest = {‘State’: [‘Assam’, ‘Delhi’, ‘Kerala’],
$\quad$ ‘GArea’: [78438, 1483, 38852] ,
$\quad$ ‘VDF’ : [2797, 6.72,1663]}
>>> dFrameForest= pd.DataFrame(dictForest)
>>> dFrameForest

0 1 2	State Assam Delhi Kerala	GArea 78438 1483 38852	VDF 2797.00 6.72 1663.00

ध्यान दें कि डिफ़ॉल्ट रूप से डेटाफ्रेम में डिक्शनरी की कुंजियाँ कॉलम लेबल बन जाती हैं और सूचियाँ पंक्तियाँ बन जाती हैं। इस प्रकार, डेटाफ्रेम को सूचियों का डिक्शनरी या श्रेणियों का डिक्शनरी माना जा सकता है।

हम डेटाफ्रेम में कॉलमों का क्रम बदल सकते हैं। यह डिक्शनरी कुंजियों के किसी विशिष्ट क्रम को columns पैरामीटर के रूप में निर्धारित करके किया जा सकता है, उदाहरण के लिए:

>>> dFrameForest1 = pd.DataFrame(dictForest, columns = [‘State’,‘VDF’, ‘GArea’])
>>> dFrameForest1

0 1 2	State असम दिल्ली केरल	VDF 2797.00 6.72 1663.00	GArea 78438 1483 38852

आउटपुट में, VDF अब अंतिम के बजाय मध्य कॉलम के रूप में प्रदर्शित हो रहा है।

(E) श्रेणी से डेटाफ्रेम का निर्माण

निम्नलिखित तीन श्रेणियों पर विचार करें:

seriesA = pd.Series([1,2,3,4,5],
$\quad$ index = [‘a’, ‘b’, ‘c’, ’d’, ’e’])
seriesB = pd.Series ([1000,2000,-1000,-5000,1000],
$\quad$ index = [‘a’, ‘b’, ‘c’, ’d’, ’e’])
seriesC = pd.Series([10,20,-10,-50,100],
$\quad$ index = [‘z’, ‘y’, ‘a’, ‘c’, ’e’])

हम एकल श्रेणी का उपयोग करके डेटाफ्रेम बना सकते हैं जैसा नीचे दिखाया गया है:

>>> dFrame6 = pd.DataFrame(seriesA)
>>> dFrame6

a b c d e	0 1 2 3 4 5

यहाँ, DataFrame dFrame6 में उतनी ही पंक्तियाँ हैं जितने सीरीज़ में तत्व हैं, लेकिन केवल एक स्तंभ है। एक से अधिक सीरीज़ का उपयोग करके DataFrame बनाने के लिए, हमें एक सूची में कई सीरीज़ पास करनी होती हैं जैसा नीचे दिखाया गया है:

>>> dFrame7 = pd.DataFrame([seriesA, seriesB])
>>> dFrame7

a 0 1	b 1 1000	c 2 2000	d 3 -1000	e 4 -5000	5 1000

ध्यान दें कि सीरीज़ ऑब्जेक्ट में लेबल DataFrame ऑब्जेक्ट में स्तंभ नाम बन जाते हैं और प्रत्येक सीरीज़ DataFrame में एक पंक्ति बन जाती है। अब निम्न उदाहरण देखें:

>>> dFrame8 = pd.DataFrame([seriesA, seriesC])
>>> dFrame8

a 0 1	b 1.0 -10.0	c 2.0 NaN	d 3.0 -50.0	e 4.0 NaN	z 5.0 100.0	y NaN 10.0	NaN 20.0

यहाँ, विभिन्न सीरीज़ में समान लेबल सेट नहीं हैं। लेकिन, DataFrame में स्तंभों की संख्या सभी सीरीज़ में विभिन्न लेबल के बराबर होती है। इसलिए, यदि कोई विशेष सीरीज़ किसी लेबल के लिए संगत मान नहीं रखती है, तो DataFrame स्तंभ में $\mathrm{NaN}$ डाला जाता है।

(F) सीरीज़ के शब्दकोश से DataFrame का निर्माण

एक शब्दकोश (dictionary) ऑफ़ सीरीज़ का उपयोग करके भी एक DataFrame बनाया जा सकता है। उदाहरण के लिए, ResultSheet एक सीरीज़ का शब्दकोश है जिसमें तीन विषयों में 5 विद्यार्थियों के अंक हैं। विद्यार्थियों के नाम शब्दकोश की कुंजियाँ हैं और सीरीज़ के इंडेक्स मान विषयों के नाम हैं जैसा कि नीचे दिखाया गया है:

गतिविधि 2.7

type फ़ंक्शन का उपयोग करके ResultSheet और ResultDF के डेटाटाइप की जाँच करें। क्या वे समान हैं?

>>> ResultSheet={
‘Arnab’: pd.Series([90, 91, 97],
$\quad$ index=[‘Maths’,‘Science’,‘Hindi’]),
‘Ramit’: pd.Series([92, 81, 96],
$\quad$ index=[‘Maths’,‘Science’,‘Hindi’]),
‘Samridhi’: pd.Series([89, 91, 88],
$\quad$ index=[‘Maths’,‘Science’,‘Hindi’]),
‘Riya’: pd.Series([81, 71, 67],
$\quad$ index=[‘Maths’,‘Science’,‘Hindi’]),
‘Mallika’: pd.Series([94, 95, 99],
$\quad$ index=[‘Maths’,‘Science’,‘Hindi’])}
>>> ResultDF = pd.DataFrame(ResultSheet)
>>> ResultDF

maths Science Hindi	Arnab 90 91 97	Ramit 92 81 96	Samridhi 89 91 88	Riya 81 71 67	Mallika 94 95 99

निम्न आउटपुट दिखाता है कि DataFrame का हर कॉलम एक Series है:

>>> type(ResultDF.Arnab)
<class ‘pandas.core.series.Series’>

जब एक DataFrame को Series के Dictionary से बनाया जाता है, तो परिणामी index या row labels उन सभी series indexes का union होता है जिनका उपयोग DataFrame बनाने के लिए किया गया है। उदाहरण के लिए:

dictForUnion = { ‘Series1’ :
pd.Series([1,2,3,4,5],
$\quad$ index = [‘a’, ‘b’, ‘c’, ’d’, ’e’]) ,
$\quad$ ‘Series2’ :
pd.Series([10,20,-10,-50,100],
$\quad$ index = [‘z’, ‘y’, ‘a’, ‘c’, ’e’]),
$\quad$ ‘Series3’ :
pd.Series([10,20,-10,-50,100],
$\quad$ index = [‘z’, ‘y’, ‘a’, ‘c’, ’e’]) }
>>> dFrameUnion = pd.DataFrame(dictForUnion)
>>> dFrameUnion

a b c d e y z	Series1 1.0 2.0 3.0 4.0 5.0 NaN NaN	Series2 -10.0 NaN -50.0 NaN 100.0 20.0 10.0	Series3 -10.0 NaN -50.0 NaN 100.0 20.0 10.0

2.3.2 DataFrames में rows और columns पर operations

हम DataFrame की rows और columns पर कुछ बुनियादी operations जैसे selection, deletion, addition और renaming कर सकते हैं, जैसा कि इस section में चर्चा की गई है।

(A) DataFrame में एक नया Column जोड़ना

हम एक DataFrame में आसानी से एक नया column जोड़ सकते हैं। आइए पहले परिभाषित किए गए DataFrame ResultDF पर विचार करें। एक और student ‘Preeti’ के लिए एक नया column जोड़ने के लिए, हम निम्नलिखित statement लिख सकते हैं:

गणित विज्ञान हिंदी	अर्नब 90 91 97	रमित 92 81 96	समृद्धि 89 91 88	रिया 81 71 67	मल्लिका 94 95 99	प्रीति 89 78 76

किसी नए कॉलम लेबल को मान देने से, जो पहले से मौजूद नहीं है, अंत में एक नया कॉलम बन जाएगा। यदि कॉलम पहले से ही DataFrame में मौजूद है तो असाइनमेंट स्टेटमेंट पहले से मौजूद कॉलम के मानों को अपडेट कर देगा, उदाहरण के लिए:

>>> ResultDF[‘Ramit’]=[99, 98, 78]
>>> ResultDF

गणित विज्ञान हिंदी	अर्नब 90 91 97	रमित 99 98 78	समृद्धि 89 91 88	रिया 81 71 67	मल्लिका 94 95 99	प्रीति 89 78 76

हम DataFrame में किसी पूरे कॉलम के डेटा को किसी विशेष मान पर भी सेट कर सकते हैं। उदाहरण के लिए, निम्नलिखित स्टेटमेंट ‘अर्नब’ नाम के कॉलम के सभी विषयों के लिए अंक $=90$ सेट करता है:

>>> ResultDF[‘Arnab’]=90
>>> ResultDF

गणित विज्ञान हिंदी	अर्नब 90 90 90	रमित 99 98 78	समृद्धि 89 91 88	रिया 81 71 67	मल्लिका 94 95 99	प्रीति 89 78 76

(B) DataFrame में एक नई पंक्ति जोड़ना

हम DataFrame.loc[ ] विधि का उपयोग करके DataFrame में एक नई पंक्ति जोड़ सकते हैं। ResultDF नामक DataFrame पर विचार करें जिसमें तीन विषयों Maths, Science और Hindi के लिए तीन पंक्तियाँ हैं। मान लीजिए, हमें ResultDF में English विषय के अंक जोड़ने हैं, हम निमलिखित कथन का उपयोग कर सकते हैं:

>>> ResultDF

	Arnab	Ramit	Samridhi	Riya	Mallika	Preeti
Maths	90	92	89	81	94	89
Science	91	81	91	71	95	78
Hindi	97	96	88	67	99	76

>>> ResultDF.loc[‘English’] = [85, 86, 83, 80, 90, 89]
>>> ResultDF

	Arnab	Ramit	Samridhi	Riya	Mallika	Preeti
Maths	90	92	89	81	94	89
Science	91	81	91	71	95	78
Hindi	97	96	88	67	99	76
English	85	86	83	80	90	89

हम इस विधि का उपयोग पहले से मौजूद (डुप्लिकेट) सूचकांक मान (लेबल) के साथ डेटा की एक पंक्ति जोड़ने के लिए नहीं कर सकते। ऐसी स्थिति में, इस सूचकांक लेबल वाली एक पंक्ति अपडेट हो जाएगी, उदाहरण के लिए:

>>> ResultDF.loc[‘English’] = [95, 86, 95, 80, 95,99]
>>> ResultDF

	अर्नब	रमित	समृद्धि	रिया	मल्लिका	प्रीति
गणित	90	92	89	81	94	89
विज्ञान	91	81	91	71	95	78
हिन्दी	97	96	88	67	99	76
अंग्रेज़ी	95	86	95	80	95	99

DataFrame.loc[] विधि का उपयोग किसी पंक्ति के डेटा मानों को किसी विशेष मान पर सेट करने के लिए भी किया जा सकता है। उदाहरण के लिए, निम्नलिखित कथन सभी स्तंभों के लिए ‘गणित’ में अंक 0 पर सेट करता है:

>>> ResultDF.loc[‘Maths’]=0
>>> ResultDF

	अर्नब	रमित	समृद्धि	रिया	मल्लिका	प्रीति
गणित	0	0	0	0	0	0
विज्ञान	91	81	91	71	95	78
हिन्दी	97	96	88	67	99	76
अंग्रेज़ी	95	86	95	80	95	99

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

क्या आप DataFrame में पंक्तियों और स्तंभों की संख्या गिनने के लिए एक प्रोग्राम लिख सकते हैं?

यदि हम DataFrame में ऐसी पंक्ति जोड़ने की कोशिश करते हैं जिसमें मानों की संख्या DataFrame के स्तंभों की संख्या से कम हो, तो इससे ValueError आती है, जिसका संदेश होता है: ValueError: Cannot set a row with mismatched columns.

इसी प्रकार, यदि हम DataFrame में ऐसा स्तंभ जोड़ने की कोशिश करते हैं जिसमें मानों की संख्या DataFrame की पंक्तियों की संख्या से कम हो, तो इससे ValueError आती है, जिसका संदेश होता है: ValueError: Length of values does not match length of index.

आगे, हम DataFrame के सभी मानों को किसी विशेष मान पर सेट कर सकते हैं, उदाहरण के लिए:

>>> ResultDF[: ] = 0 # ResultDF के सभी मान 0 पर सेट करें
>>> ResultDF

	अर्नब	रमित	समृद्धि	रिया	मल्लिका	प्रीति
गणित	0	0	0	0	0	0
विज्ञान	0	0	0	0	0	0
हिन्दी	0	0	0	0	0	0
अंग्रेज़ी	0	0	0	0	0	0

(C) DataFrame से पंक्तियाँ या स्तंभ हटाना

हम DataFrame.drop() विधि का उपयोग करके DataFrame से पंक्तियाँ और स्तंभ हटा सकते हैं। हमें हटाए जाने वाले लेबलों के नाम और वह अक्ष (axis) निर्दिष्ट करना होता है जिससे उन्हें हटाना है। एक पंक्ति हटाने के लिए पैरामीटर axis को मान 0 दिया जाता है और एक स्तंभ हटाने के लिए पैरामीटर axis को मान 1 दिया जाता है। निम्नलिखित DataFrame पर विचार करें:

>>> ResultDF

	अर्नब	रमित	समृद्धि	रिया	मल्लिका
गणित	90	92	89	81	94
विज्ञान	91	81	91	71	95
हिन्दी	97	96	88	67	99
अंग्रेज़ी	95	86	95	80	95

निम्नलिखित उदाहरण दिखाता है कि लेबल ‘विज्ञान’ वाली पंक्ति को कैसे हटाया जाता है:

>>> ResultDF = ResultDF.drop(‘विज्ञान’, axis=0)
>>> ResultDF

	अर्नब	रमित	समृद्धि	रिया	मल्लिका
गणित	90	92	89	81	94
हिन्दी	97	96	88	67	99
अंग्रेज़ी	95	86	95	80	95

निम्नलिखित उदाहरण दिखाता है कि लेबल ‘समृद्धि’, ‘रमित’ और ‘रिया’ वाले स्तंभों को कैसे हटाया जाता है:

>>> ResultDF = ResultDF.drop([‘समृद्धि’,‘रमित’,‘रिया’], axis=1)
>>> ResultDF

	अर्नब	मल्लिका
गणित	90	94
हिन्दी	97	99
अंग्रेज़ी	95	95

यदि DataFrame में एक से अधिक पंक्तियाँ समान लेबल के साथ हों, तो DataFrame.drop() विधि उनमें से सभी मिलान वाली पंक्तियों को हटा देगी। उदाहरण के लिए, निम्न DataFrame पर विचार करें:

गणित विज्ञान हिन्दी हिन्दी	अर्नब 90 91 97 97	रमित 92 81 96 89	समृद्धि 89 91 88 78	रिया 81 71 67 60	मल्लिका 94 95 99 45

‘हिन्दी’ लेबल वाली दोहराई गई पंक्तियों को हटाने के लिए हमें निम्न कथन लिखना होगा:

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

यदि rename फ़ंक्शन में हम ऐसा पंक्ति लेबल दें जो मौजूद न हो, तो क्या होगा?

>>> ResultDF = ResultDF.drop(‘हिन्दी’, axis=0)
>>> ResultDF

	अर्नब	रमित	समृद्धि	रिया	मल्लिका
गणित	90	92	89	81	94
विज्ञान	91	81	91	71	95

(D) DataFrame के पंक्ति लेबल का नाम बदलना

हम DataFrame.rename() विधि का प्रयोग करके DataFrame की पंक्तियों और स्तंभों के लेबल बदल सकते हैं। निम्न DataFrame पर विचार करें। पंक्ति अनुक्रमणिका गणित को sub1, विज्ञान को sub2, हिन्दी को sub3 और अंग्रेज़ी को sub4 नाम देने के लिए हम निम्न कथन लिख सकते हैं:

>>> ResultDF

	अर्नब	रमित	समृद्धि	रिया	मल्लिका
गणित	90	92	89	81	94
विज्ञान	91	81	91	71	95
अंग्रेज़ी	97	96	88	67	99
हिन्दी	97	89	78	60	45

>>> ResultDF=ResultDF.rename({‘Maths’:‘Sub1’, ‘Science’:‘Sub2’,‘English’:‘Sub3’, ‘Hindi’:‘Sub4’}, axis=‘index’)
>>> print(ResultDF)

	अर्नब	रमित	समृद्धि	रिया	मल्लिका
Sub1	90	92	89	81	94
Sub2	91	81	91	71	95
Sub3	97	96	88	67	99
Sub4	97	89	78	60	45

पैरामीटर axis=‘index’ यह निर्दिष्ट करने के लिए प्रयोग किया जाता है कि पंक्ति लेबल को बदलना है। यदि किसी मौजूदा लेबल के अनुरूप कोई नया लेबल पास नहीं किया जाता है, तो मौजूदा पंक्ति लेबल वैसा ही रहता है, उदाहरण के लिए:

>>> ResultDF=ResultDF.rename({‘Maths’:‘Sub1’,‘Science’:‘Sub2’,‘Hindi’:‘Sub4’}, axis=‘index’) >>> print(ResultDF)

Sub1 Sub2 English Sub	अर्नब 90 91 97 97	रमित 92 81 96 89	समृद्धि 89 91 88 78	रिया 81 71 67 60	मल्लिका 94 95 99 45

(E) डेटाफ्रेम के स्तंभ लेबल का नाम बदलना

ResultDF के कॉलम नाम बदलने के लिए हम पुनः rename() विधि का उपयोग कर सकते हैं, जैसा नीचे दिखाया गया है। पैरामीटर axis=‘columns’ दर्शाता है कि हम कॉलम लेबल बदलना चाहते हैं:

>>>ResultDF=ResultDF.rename({‘Arnab’:‘Student1’,‘Ramit’:‘Student2’,‘Samridhi’:‘Student3’,
‘Mallika’:‘Student4’},axis=‘columns’)
>>> print(RsultDF)

	Student1	Student2	Student3	Riya	Student4
Maths	90	92	89	81	94
Science	91	81	91	71	95
English	97	96	88	67	99
Hindi	97	89	78	60	45

ध्यान दें कि Riya कॉलम अपरिवर्तित रहता है क्योंकि हमने उसके लिए कोई नया लेबल नहीं दिया।

2.3.3 इंडेक्सिंग के माध्यम से डेटाफ्रेम के तत्वों तक पहुँचना

डेटाफ्रेम में डेटा तत्वों तक इंडेक्सिंग का उपयोग करके पहुँचा जा सकता है। डेटाफ्रेम को इंडेक्स करने के दो तरीके हैं: लेबल आधारित इंडेक्सिंग और बूलियन इंडेक्सिंग।

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

यदि डेटाफ्रेम में दिया गया लेबल या पंक्ति इंडेक्स मौजूद न हो तो क्या होगा?

(A) लेबल आधारित इंडेक्सिंग

पांडास में लेबल आधारित इंडेक्सिंग लागू करने के कई तरीके हैं। DataFrame.loc[ ] एक महत्वपूर्ण विधि है जो डेटाफ्रेम के साथ लेबल आधारित इंडेक्सिंग के लिए प्रयोग की जाती है। आइए पहले बनाए गए ResultDF का उपयोग करना जारी रखें। निम्न उदाहरण के अनुसार, एकल पंक्ति लेबल पंक्ति को एक सीरीज़ के रूप में लौटाता है।

>>> ResultDF

गणित	अर्नब	रमित	समृद्धि	रिया	मल्लिका
विज्ञान	90	92	89	81	94
हिन्दी	91	81	91	71	95

>>> ResultDF.loc[‘विज्ञान’]

अर्नब	91
रमित	81
समृद्धि	91
रिया	71
मल्लिका	95

नाम: विज्ञान, dtype: int64

ध्यान दें कि जब पंक्ति लेबल को पूर्णांक मान के रूप में पास किया जाता है, तो इसे सूचकांक की स्थिति के बजाय सूचकांक का लेबल माना जाता है, उदाहरण के लिए:

>>> dFrame10Multiples = pd.DataFrame([10,20,30,40,50])
>>> dFrame10Multiples.loc[2]
0 $\quad $ 30
नाम: 2, dtype: int64

जब एकल स्तंभ लेबल पास किया जाता है, तो यह स्तंभ को Series के रूप में लौटाता है।

>>> ResultDF.loc[:,‘अर्नब’]

गणित $\quad$ 90
विज्ञान $\quad$ 91
हिन्दी $\quad$ 97
नाम: अर्नब, dtype: int64

साथ ही, हम वही परिणाम प्राप्त कर सकते हैं अर्थात् सभी विषयों में ‘अर्नब’ के अंक निम्नलिखित कमांड का उपयोग करके:

>>> print(df[‘अर्नब’])

गणित $\quad$ 56
विज्ञान $\quad$ 91
अंग्रेज़ी$\quad$ 97
हिन्दी $\quad$ 97
नाम: अर्नब, dtype: int64

DataFrame से एक से अधिक पंक्तियाँ पढ़ने के लिए, नीचे दिखाए अनुसार पंक्ति लेबलों की सूची का उपयोग किया जाता है। ध्यान दें कि [[]] का उपयोग करने से एक DataFrame लौटता है।

>>> ResultDF.loc[[‘विज्ञान’, ‘हिन्दी’]]

	अर्नब	रमित	समृद्धि	रिया	मल्लिका
विज्ञान	91	81	91	71	95
हिन्दी	97	96	88	67	99

(B) बूलियन अनुक्रमण

बूलियन का अर्थ है एक द्विआधारी चर जो दो अवस्थाओं में से किसी एक को दर्शा सकता है - सत्य (1 से दर्शाया जाता है) या असत्य (0 से दर्शाया जाता है)। बूलियन अनुक्रमण में, हम डेटा के उपसमूहों का चयन डेटाफ्रेम में वास्तविक मानों के आधार पर कर सकते हैं, न कि उनके पंक्ति/स्तंभ लेबलों के आधार पर। इस प्रकार, हम डेटा मानों को फिल्टर करने के लिए स्तंभ नामों पर शर्तों का उपयोग कर सकते हैं। DataFrame ResultDF पर विचार करें, निम्न कथन सत्य या असत्य प्रदर्शित करता है यह देखते हुए कि डेटा मान दी गई शर्त को संतुष्ट करता है या नहीं।

>>> ResultDF.loc[‘Maths’] > 90
Arnab $\quad$ False
Ramit $\quad$ True
Samridhi $\quad$ False
Riya $\quad$ False
Mallika $\quad$ True
Name: Maths, dtype: bool

यह जांचने के लिए कि ‘Arnab’ ने किन विषयों में 90 से अधिक अंक प्राप्त किए हैं, हम लिख सकते हैं:

>>> ResultDF.loc[:,‘Arnab’]>90
Maths $\quad$ False
Science $\quad$ True
Hindi $\quad$ True
Name: Arnab, dtype: bool

2.3.4 स्लाइसिंग के माध्यम से डेटाफ्रेम्स के तत्वों तक पहुंचना

हम डेटाफ्रेम से पंक्तियों और/या स्तंभों के उपसमूह का चयन करने के लिए स्लाइसिंग का उपयोग कर सकते हैं। पंक्तियों के समूह को पुनः प्राप्त करने के लिए, पंक्ति लेबलों के साथ स्लाइसिंग का उपयोग किया जा सकता है। उदाहरण के लिए:

>>> ResultDF.loc[‘Maths’: ‘Science’]

	Arnab	Ramit	Samridhi	Riya	Mallika
Maths	90	92	89	81	94
Science	91	81	91	71	95

गतिविधि 2.8

क) DataFrame ResultDF का उपयोग करते हुए, Arnab के Maths में अंकों तक पहुँचने के लिए कथन लिखें।

ख) 5 पंक्तियों वाला एक DataFrame बनाएँ और उसकी पहली 4 पंक्तियाँ प्राप्त करने के लिए कथन लिखें।

यहाँ, Maths और Science लेबल वाली पंक्तियाँ प्रदर्शित हैं। ध्यान दें कि DataFrames में स्लाइसिंग अंतिम मानों को सम्मिलित करती है। हम किसी स्तंभ नाम के साथ लेबल्स के स्लाइस का उपयोग केवल उस स्तंभ में उन पंक्तियों के मान तक पहुँचने के लिए कर सकते हैं। उदाहरण के लिए, निम्नलिखित कथन Maths और Science लेबल वाली पंक्तियाँ और Arnab लेबल वाला स्तंभ प्रदर्शित करता है:

>>> ResultDF.loc[‘Maths’: ‘Science’, ‘Arnab’]
Maths $\quad$ 90
Science $\quad$ 91
Name: Arnab, dtype: int64

हम लेबल्स के स्लाइस के साथ स्तंभ नामों के स्लाइस का उपयोग उन पंक्तियों और स्तंभों के मान तक पहुँचने के लिए कर सकते हैं:

>>> ResultDF.loc[‘Maths’: ‘Science’, ‘Arnab’:’Samridhi’]

	Arnab	Ramit	Samridhi
Maths	90	92	89
Science	91	81	91

वैकल्पिक रूप से, हम लेबल्स के स्लाइस के साथ स्तंभ नामों की सूची का उपयोग उन पंक्तियों और स्तंभों के मान तक पहुँचने के लिए कर सकते हैं:

>>> ResultDF.loc[‘Maths’: ‘Science’,[‘Arnab’,’Samridhi’]]

	Arnab	Samridhi
Maths	90	89
Science	91	91

DataFrames में पंक्तियाँ फ़िल्टर करना

DataFrames में, True (1) और False (0) जैसे बूलीयान मानों को सूचकांकों से जोड़ा जा सकता है। वे DataFrmae.loc[] विधि का उपयोग करके रिकॉर्ड फ़िल्टर करने के लिए भी उपयोग किए जा सकते हैं।

विशेष पंक्ति(याँ) चुनने या छोड़ने के लिए, हम एक बूलियन सूची का उपयोग कर सकते हैं जिसमें आउटपुट में दिखाई देने वाली पंक्तियों के लिए ‘True’ और छोड़ी जाने वाली पंक्तियों के लिए ‘False’ निर्दिष्ट किया जाता है। उदाहरण के लिए, निम्नलिखित कथन में, जिस पंक्ति की अनुक्रमणिका Science है, उसे छोड़ दिया गया है:

>>> ResultDF.loc[[True, False, True]]

	Arnab	Ramit	Samridhi	Riya	Mallika
Maths	90	92	89	81	94
Hindi	97	96	88	67	99

2.3.5 DataFrames को जोड़ना, मर्ज करना और संयोजन

(A) जोड़ना (Joining)

हम दो DataFrames को मर्ज करने के लिए pandas.DataFrame.append() विधि का उपयोग कर सकते हैं। यह दूसरे DataFrame की पंक्तियों को पहले DataFrame के अंत में जोड़ता है। वे कॉलम जो पहले DataFrame में मौजूद नहीं हैं, नए कॉलम के रूप में जोड़े जाते हैं। उदाहरण के लिए, नीचे वर्णित दो DataFrames dFrame1 और dFrame2 पर विचार करें। आइए append() विधि का उपयोग करके dFrame2 को dFrame1 में जोड़ें:

>>> dFrame1=pd.DataFrame([[1, 2, 3], [4, 5], [6]], columns=[‘C1’, ‘C2’, ‘C3’], index=[‘R1’, ‘R2’, ‘R3’])
>>> dFrame1

	C1	C2	C3
R1	1	2.0	3.0
R2	4	5.0	NaN
R3	6	NaN	NaN

>>> dFrame2=pd.DataFrame([[10, 20], [30], [40, 50]], columns=[‘C2’, ‘C5’], index=[‘R4’, ‘R2’, ‘R5’])
>>> dFrame2

	C2	C3
R4	10	20.0
R2	30	NaN
R5	40	50.0

>>> dFrame1=dFrame1.append(dFrame2)
>>> dFrame1

	C1	C2	C3	C5
R1	1.1	2.0	3.0	NaN
R2	4.0	5.0	NaN	NaN
R3	6.0	NaN	NaN	NaN
R4	NaN	10.0	NaN	20.0
R2	NaN	30.0	NaN	NaN
R5	NaN	40.0	NaN	50.0

वैकल्पिक रूप से, यदि हम dFrame1 को dFrame2 में जोड़ते हैं, तो dFrame2 की पंक्तियाँ dFrame1 की पंक्तियों से पहले आती हैं। कॉलम लेबल्स को क्रमबद्ध (sorted) क्रम में दिखाने के लिए हम पैरामीटर sort=True सेट कर सकते हैं। जब पैरामीटर sort=False होता है, तो कॉलम लेबल्स अक्रमबद्ध (unsorted) क्रम में दिखाई देंगे।

# dFrame1 को dFrame2 में जोड़ना
>>> dFrame2 =dFrame2.append(dFrame1, sort=’True’)
>>> dFrame2

	C1	C2	C3	C5
R4	NaN	10.0	NaN	20.0
R2	NaN	30.0	NaN	NaN
R5	NaN	40.0	NaN	50.0
R1	1.0	2.0	3.0	NaN
R2	4.0	5.0	NaN	NaN
R3	6.0	NaN	NaN	NaN

# dFrame1 को dFrame2 में sort=False के साथ जोड़ना
>>> dFrame2 = dFrame2.append(dFrame1, sort=’False’)
>>> dFrame2

	C1	C5	C1	C3
R4	10.0	20.0	NaN	20.0
R2	30.0	NaN	NaN	NaN
R5	40.0	50.0	NaN	NaN
R1	2.0	NaN	1.0	3.0
R2	5.0	NaN	4.0	NaN
R3	NaN	NaN	6.0	NaN

append() मेथड के parameter verify_integrity को True पर सेट किया जा सकता है जब हम चाहते हैं कि यदि रो लेबल डुप्लिकेट हों तो error उठाया जाए। डिफ़ॉल्ट रूप से, verify_integrity = False होता है। इसीलिए हम ऊपर दिखाए गए दो DataFrames को append करते समय R2 लेबल वाली डुप्लिकेट रो को append कर पाए।

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

आप कैसे जांच सकते हैं कि किसी दिए गए DataFrame में कोई missing value है या नहीं?

append() मेथड के parameter ignore_index को True पर सेट किया जा सकता है, जब हम रो इंडेक्स लेबल का उपयोग नहीं करना चाहते। डिफ़ॉल्ट रूप से, ignore_index = False होता है।

>>> dFrame1 = dFrame1.append(dFrame2, ignore_index=True)
>>> dFrame1

	C1	C2	C3	C5
0	1.0	2.0	3.0	NaN
1	4.0	5.0	NaN	NaN
2	6.0	NaN	NaN	NaN
3	NaN	10.0	NaN	20.0
4	NaN	30.0	NaN	NaN
5	NaN	40.0	NaN	50.0

append() मेथड का उपयोग किसी series या dictionary को DataFrame में append करने के लिए भी किया जा सकता है।

2.3.6 DataFrames के Attributes

Series की तरह, हम DataFrame के कुछ properties को attributes कहकर DataFrame के नाम के साथ उस property का उपयोग करके एक्सेस कर सकते हैं। Table 2.4 में Pandas DataFrame के कुछ attributes सूचीबद्ध हैं। हम इस सेक्शन में अपने example data के रूप में Forest Survey of India द्वारा प्रकाशित “STATE OF FOREST REPORT 2017” नामक रिपोर्ट के कुछ भाग का उपयोग करेंगे, जो http://fsi.nic.in/forest-report-2017 पर उपलब्ध है।

इस रिपोर्ट के अनुसार, भौगोलिक क्षेत्र, अत्यंत घने वनों का क्षेत्र, मध्यम घने वनों का क्षेत्र और खुले वनों का क्षेत्र (सभी वर्ग किमी में), भारत के तीन राज्यों - असम, दिल्ली और केरल में निम्नलिखित डेटाफ्रेम ForestAreaDF के रूप में दिखाए गए हैं:

>>> ForestArea = {
$\quad$‘Assam’ :pd.Series([78438, 2797,
10192, 15116], index = [‘GeoArea’, ‘VeryDense’,
ModeratelyDense’, ‘OpenForest’]),
$\quad$‘Kerala’ :pd.Series([ 38852, 1663,
9407, 9251], index = [‘GeoArea’ ,‘VeryDense’,
‘ModeratelyDense’, ‘OpenForest’]),
$\quad$ ‘Delhi’ :pd.Series([1483, 6.72, 56.24,
129.45], index = [‘GeoArea’, ‘VeryDense’,
‘$\quad$ModeratelyDense’, ‘OpenForest’])}

>>> ForestAreaDF = pd.DataFrame(ForestArea)
>>> ForestAreaDF

	Assam	Kerala	Delhi
GeoArea	78438	38852	1483.00
VeryDense	2797	1663	6.72
ModeratelyDense	10192	9407	56.24
OpenForest	15116	9251	129.45

तालिका 2.4 पांडास डेटाफ्रेम के कुछ गुण

विशेषता नाम	उद्देश्य	उदाहरण
DataFrame.index	पंक्ति लेबल प्रदर्शित करने के लिए	»> ForestAreaDF.index Index([‘GeoArea’, ‘VeryDense’, ‘ModeratelyDense’, ‘OpenForest’], dtype =’object’)
DataFrame.columns	स्तंभ लेबल प्रदर्शित करने के लिए	»> ForestAreaDF.columns Index([‘Assam’, ‘Kerala’, ‘Delhi’], dtype=’object’)
DataFrame.dtypes	DataFrame में प्रत्येक स्तंभ के डेटा प्रकार को प्रदर्शित करने के लिए	>>> ForestAreaDF.dtypes Assam $\quad$ int64 Kerala $\quad$ int64 Delhi $\quad$ float64 dtype: object
DataFrame.values	DataFrame में सभी मानों वाला एक NumPy ndarray प्रदर्शित करने के लिए, बिना अक्ष लेबल के	>>> ForestAreaDF.values array([[7.8438e+04, 3.8852e+04, 1.4830e+03], $\qquad$ [2.7970e+03, 1.6630e+03, 6.7200e+00], $\qquad$ [1.0192e+04, 9.4070e+03, 5.6240e+01], $\qquad$ [1.5116e+04, 9.2510e+03, 1.2945e+02]])
DataFrame.shape	DataFrame की विमीयता को दर्शाने वाला एक टपल प्रदर्शित करने के लिए	>>>ForestAreaDF.shape(4, 3) इसका अर्थ है ForestAreaDF में 4 पंक्तियाँ और 3 स्तंभ हैं।
DataFrame.size	DataFrame की विमीयता को दर्शाने वाला एक टपल प्रदर्शित करने के लिए	>>> ForestAreaDF.size12 इसका अर्थ है ForestAreaDF में 12 मान हैं।
DataFrame.T	DataFrame को ट्रांसपोज़ करने के लिए। इसका अर्थ है, DataFrame की पंक्ति सूचकांक और स्तंभ लेबल एक-दूसरे की स्थिति ले लेते हैं	>>> ForestAreaDF.T
DataFrame.head(n)	DataFrame में पहली n पंक्तियाँ प्रदर्शित करने के लिए	>>> ForestAreaDF.head(2) DataFrame ForestAreaDF की पहली 2 पंक्तियाँ प्रदर्शित करता है। यदि पैरामीटर n निर्दिष्ट नहीं किया जाता है तो डिफ़ॉल्ट रूप से यह DataFrame की पहली 5 पंक्तियाँ देता है।
DataFrame.tail(n)	DataFrame में अंतिम n पंक्तियाँ प्रदर्शित करने के लिए	>>> ForestAreaDF.tail(2) DataFrame ForestAreaDF की अंतिम 2 पंक्तियाँ प्रदर्शित करता है। यदि पैरामीटर n निर्दिष्ट नहीं किया जाता है तो डिफ़ॉल्ट रूप से यह DataFrame की अंतिम 5 पंक्तियाँ देता है।
	DataFrame खाली है तो True और अन्यथा False लौटाता है	>>> ForestAreaDF.empty False >>> df=pd.DataFrame() #एक खाली dataFrame बनाएँ >>> df.empty True

2.4 CSV फ़ाइलों और DataFrame के बीच डेटा आयात और निर्यात

हम कॉमा से अलग किए गए मानों वाली CSV फ़ाइलों से डेटा आयात करके एक DataFrame बना सकते हैं। इसी प्रकार, हम DataFrame में मौजूद डेटा को .csv फ़ाइल के रूप में भी संग्रहित या निर्यात कर सकते हैं।

2.4.1 CSV फ़ाइल को DataFrame में आयात करना

मान लीजिए कि हमारे पास C:/NCERT फ़ोल्डर में संग्रहित ResultData.csv नामक csv फ़ाइल में निम्नलिखित डेटा है। जैसे-जैसे हम आगे बढ़ें, आपको सुझाव दिया जाता है कि आप इस csv फ़ाइल को स्प्रेडशीट का उपयोग करके बनाएं और अपने कंप्यूटर में सहेजें।

Roll No	Name	Eco	Maths
1	Arnab	18	57
2	Kritika	23	45
3	Divyam	51	37
4	Vivaan	40	60
5	Aaroosh	18	27

हम ResultData.csv फ़ाइल से डेटा को Pandas के read_csv() फ़ंक्शन का उपयोग करके marks नामक DataFrame में लोड कर सकते हैं जैसा नीचे दिखाया गया है:

>>> marks = pd.read_csv(“C:/NCERT/ResultData.csv”,sep =",", header=0)
>>> marks

	Roll No	Name	Eco	Maths
0	1	Arnab	18	57
1	2	Kritika	23	45
2	3	Divyam	51	37
3	4	Vivaan	40	60
4	5	Aaroosh	18	27

• read_csv() का पहला पैरामीटर कॉमा सेपरेटेड डेटा फ़ाइल का नाम और उसका पाथ होता है।
• sep पैरामीटर बताता है कि मान कॉमा, सेमीकोलन, टैब या किसी अन्य कैरेक्टर से अलग किए गए हैं। sep का डिफ़ॉल्ट मान स्पेस होता है।
• header पैरामीटर उस रो की संख्या निर्दिष्ट करता है जिसके मान कॉलम नामों के रूप में इस्तेमाल किए जाएंगे। यह डेटा लाने की शुरुआत को भी चिह्नित करता है। header $=0$ का अर्थ है कि कॉलम नाम फ़ाइल की पहली लाइन से लिए जाते हैं। डिफ़ॉल्ट रूप से, header $=0$ होता है।

हम read_csv() फंक्शन का उपयोग करके DataFrame बनाते समय names पैरामीटर का उपयोग करके विशेष रूप से कॉलम नाम निर्दिष्ट कर सकते हैं। उदाहरण के लिए, निम्नलिखित स्टेटमेंट में, marks1 DataFrame के कॉलमों के लिए लेबल निर्दिष्ट करने के लिए names पैरामीटर का उपयोग किया गया है:

>>> marks1 = pd.read_csv(“C:/NCERT/ResultData1.
csv”,sep=",",
names=[‘RNo’,‘StudentName’, ‘Sub1’, ‘Sub2’])
>>> marks1

	Roll No	StudentName	Sub1	Sub2
0	1	Arnab	18	57
1	2	Kritika	23	45
2	3	Divyam	51	37
3	4	Vivaan	40	60
4	5	Aaroosh	18	27

2.4.2 DataFrame को CSV फ़ाइल में एक्सपोर्ट करना

हम DataFrame को टेक्स्ट या csv फ़ाइल में सेव करने के लिए to_csv() फंक्शन का उपयोग कर सकते हैं। उदाहरण के लिए, पिछले सेक्शन में बनाए गए DataFrame ResultDF को सेव करने के लिए हम निम्नलिखित स्टेटमेंट का उपयोग कर सकते हैं:[^1]

	अर्नब	रमित	समृद्धि	रिया	मल्लिका
गणित	90	92	89	81	94
विज्ञान	91	81	91	71	95
हिन्दी	97	96	88	67	99

>>> ResultDF.to_csv(path_or_buf=‘c:/NCERT/ resultout. csv’, sep $=$ ‘, ‘)

कॉमा-सेपरेटेड वैल्यू (CSV) फ़ाइल एक टेक्स्ट फ़ाइल होती है जिसमें मान कॉमा से अलग होते हैं। प्रत्येक पंक्ति एक रिकॉर्ड (पंक्ति) को दर्शाती है। प्रत्येक पंक्ति एक या अधिक फ़ील्ड (स्तंभ) से बनी होती है। इन्हें स्प्रेडशीट एप्लिकेशन के माध्यम से आसानी से संभाला जा सकता है

यह हार्ड डिस्क पर C:/NCERT फ़ोल्डर में resultout.csv नाम की फ़ाइल बनाता है। जब हम इस फ़ाइल को किसी टेक्स्ट एडिटर या स्प्रेडशीट में खोलते हैं, तो हमें उपरोक्त डेटा के साथ-साथ पंक्ति लेबल और स्तंभ हेडर कॉमा से अलग-अलग मिलेंगे।

यदि हम नहीं चाहते कि स्तंभ नाम फ़ाइल में सहेजे जाएं तो हम पैरामीटर header=False का उपयोग कर सकते हैं। एक अन्य पैरामीटर index=False का उपयोग तब किया जाता है जब हम नहीं चाहते कि पंक्ति लेबल डिस्क पर फ़ाइल में लिखे जाएं। उदाहरण के लिए:

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

read_csv() फ़ंक्शन के साथ और कौन-से पैरामीटर उपयोग किए जा सकते हैं? आप https://pandas.pydata.org से अन्वेषण कर सकते हैं।

>>> ResultDF.to_CSv( ‘C:/NCERT/resultonly.txt’, sep = ’ @’, header = False, index= Falsel

यदि हम फ़ाइल resultonly.txt खोलते हैं, तो हमें निम्नलिखित सामग्री मिलेगी:

$90 @ 92 @ 89 @ 81 @ 94$

$91 @ 81 @ 91 @ 71 @ 95$

$97 @ 96 @88 @67@99$

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

कॉमा के अलावा, और कौन-से वर्णों का प्रयोग CSV फ़ाइल को DataFrame से बनाते समय विभाजक (separator) के रूप में किया जा सकता है?

2.5 Pandas Series बनाम NumPy ndarray

Pandas गैर-अद्वितीय (non-unique) इंडेक्स मानों का समर्थन करता है। यदि कोई ऐसा संचालन किया जाता है जो दोहराए गए इंडेक्स मानों का समर्थन नहीं करता, तो उस समय एक अपवाद (exception) उत्पन्न होगा।

Series और ndarray के बीच एक मूलभूत अंतर यह है कि Series के बीच संचालन स्वचालित रूप से लेबल के आधार पर डेटा को संरेखित (align) करते हैं। इस प्रकार, हम गणनाएँ लिख सकते हैं बिना यह सोचे कि सभी Series में समान लेबल हैं भी या नहीं।

गैर-संरेखित Series (जहाँ संगत लेबल समान नहीं हैं या समान क्रम में नहीं हैं) के बीच संचालन का परिणाम संलग्न इंडेक्सेस का यूनियन (union) होगा। यदि कोई लेबल किसी एक Series में नहीं मिलता, तो परिणाम में उसे गायब NaN के रूप में चिह्नित किया जाएगा। बिना किसी स्पष्ट डेटा संरेखण के कोड लिख पाने की क्षमता इंटरैक्टिव डेटा विश्लेषण और अनुसंधान में अपार स्वतंत्रता और लचीलापन प्रदान करती है।

तालिका 2.5 Pandas Series और NumPy Arrays के बीच अंतर

Pandas Series	NumPy Arrays
सीरीज़ में हम सरण्य के अवयवों तक पहुँचने के लिए अपना खुद का लेबल वाला इंडेक्स परिभाषित कर सकते हैं। ये संख्याएँ या अक्षर हो सकते हैं	NumPy सरण्यों तक पहुँच केवल संख्याओं द्वारा उनके पूर्णांक स्थान का उपयोग करके की जाती है।
अवयवों को अवरोही क्रम में भी इंडेक्स किया जा सकता है।	इंडेक्सिंग पहले अवयव के लिए शून्य से शुरू होती है और इंडेक्स निश्चित होता है।
यदि दो सीरीज़ संरेखित नहीं हैं, तो NaN या लापता मान उत्पन्न होते हैं।	NaN मानों की कोई संकल्पना नहीं है और यदि सरण्यों में मिलान मान नहीं हैं, तो संरेखण विफल हो जाता है।
सीरीज़ को अधिक स्मृति की आवश्यकता होती है।	NumPy कम स्मृति घेरता है।

सारांश

• NumPy, Pandas और Matplotlib वैज्ञानिक और विश्लेषणात्मक उपयोग के लिए Python लाइब्रेरी हैं।
• pip install pandas Pandas लाइब्रेरी इंस्टॉल करने का कमांड है।
• एक डेटा संरचना डेटा मानों का संग्रह और उस डेटा पर लागू किए जा सकने वाले संचालन होती है। यह डेटा को कुशलता से संग्रहीत, पुनः प्राप्त और संशोधित करने में सक्षम बनाती है।
• Pandas लाइब्रेरी की दो मुख्य डेटा संरचनाएँ Series और DataFrame हैं। इन डेटा संरचनाओं का उपयोग करने के लिए हमें पहले Pandas लाइब्रेरी आयात करनी होती है।
• एक Series एक एक-आयामी ऐरे है जिसमें मानों का क्रम होता है। प्रत्येक मान के साथ एक डेटा लेबल जुड़ा होता है जिसे इंडेक्स भी कहा जाता है।
• Series के तत्वों को एक्सेस करने के दो सामान्य तरीके इंडेक्सिंग और स्लाइसिंग हैं।
• दो प्रकार के इंडेक्स होते हैं: पोज़िशनल इंडेक्स और लेबल्ड इंडेक्स। पोज़िशनल इंडेक्स एक पूर्णांक मान लेता है जो Series में उसकी स्थिति से मेल खाता है, 0 से शुरू होता है, जबकि लेबल्ड इंडेक्स कोई उपयोगकर्ता-परिभाषित लेबल इंडेक्स के रूप में लेता है।
• जब पोज़िशनल इंडेक्स स्लाइसिंग के लिए उपयोग किए जाते हैं, तो अंत इंडेक्स स्थिति पर मान को छोड़ा जाता है, यानी केवल (end - start) संख्या के डेटा मान Series से निकाले जाते हैं। हालाँकि लेबल्ड इंडेक्स के साथ अंत इंडेक्स लेबल पर मान को भी आउटपुट में शामिल किया जाता है।
• सभी बुनियादी गणितीय संचालन Series पर ऑपरेटर का उपयोग करके या Series ऑब्जेक्ट की उपयुक्त विधियों का उपयोग करके किए जा सकते हैं।
• गणितीय संचालन करते समय इंडेक्स मिलान लागू किया जाता है और यदि संरेखण के दौरान कोई मिलान इंडेक्स नहीं मिलता है, तो Pandas NaN लौटाता है ताकि संचालन विफल न हो।
• एक DataFrame एक द्वि-आयामी लेबल्ड डेटा संरचना है जैसे एक स्प्रेडशीट। इसमें पंक्तियाँ और स्तंभ होते हैं और इसलिए इसमें पंक्ति और स्तंभ दोनों इंडेक्स होते हैं।
• जब DataFrame बनाने के लिए डिक्शनरी का उपयोग किया जाता है, तो डिक्शनरी की कुंजियाँ DataFrame के स्तंभ लेबल बन जाती हैं। एक DataFrame को सूचियों/Series के डिक्शनरी के रूप में सोचा जा सकता है (सभी Series/स्तंभ एक पंक्ति के लिए समान इंडेक्स लेबल साझा करते हैं)।
• डिस्क पर फ़ाइल से डेटा को DataFrame में Pandas की read_csv फंक्शन का उपयोग करके लोड किया जा सकता है।
• DataFrame में डेटा को डिस्क पर टेक्स्ट फ़ाइल में pandas.DataFrame.to_csv() फंक्शन का उपयोग करके लिखा जा सकता है।
• DataFrame.T एक DataFrame का ट्रांसपोज देता है।
• Pandas के पास कई विधियाँ हैं जो लेबल आधारित इंडेक्सिंग का समर्थन करती हैं लेकिन मांगा गया प्रत्येक लेबल इंडेक्स में होना चाहिए, अन्यथा KeyError उठाया जाएगा।
• DataFrame.loc[] DataFrames में पंक्तियों के लिए लेबल आधारित इंडेक्सिंग के लिए उपयोग किया जाता है।
• Pandas.DataFrame.append() विधि दो DataFrames को मर्ज करने के लिए उपयोग की जाती है।
• Pandas अद्वितीय नहीं इंडेक्स मानों का समर्थन करता है। केवल तभी एक अपवाद उठाया जाता है जब कोई विशेष संचालन जो डुप्लिकेट इंडेक्स मानों का समर्थन नहीं करता है, का प्रयास किया जाता है।
• Pandas Series और NumPy ndarray के बीच बुनियादी अंतर यह है कि Series के बीच संचालन स्वचालित रूप से लेबल के आधार पर डेटा को संरेखित करते हैं। इस प्रकार, हम गणनाएँ लिख सकते हैं बिना यह सोचे कि सभी Series में समान लेबल हैं या नहीं, जबकि ndarray के मामले में यह त्रुटि उठाता है।

अभ्यास

1. Series क्या है और यह 1-D array, list और dictionary से किस प्रकार भिन्न है?
2. DataFrame क्या है और यह 2-D array से किस प्रकार भिन्न है?
3. DataFrames का Series से क्या संबंध है?
4. आप (i) Series और (ii) DataFrame के size से क्या समझते हैं?
5. निम्नलिखित Series बनाएं और निर्दिष्ट संचालन करें:

a) EngAlph, 26 तत्वों वाली Series जिसमें मानों के रूप में वर्णमाला के अक्षर हों और डिफ़ॉल्ट index मान हों।

b) Vowels, 5 तत्वों वाली Series जिसमें index लेबल ’ $a$ ‘, ’ $e$ ‘, ’ $\mathrm{i}$ ‘, ’ $\mathrm{o}$ ’ और ’ $\mathrm{u}$ ’ हों और सभी पांच मान शून्य पर सेट हों। जांचें कि क्या यह एक empty series है।

c) Friends, एक dictionary से बनाई गई Series जिसमें आपके पांच मित्रों के roll numbers डेटा के रूप में हों और उनके पहले नाम keys के रूप में हों।

d) MTseries, एक empty Series। जांचें कि क्या यह एक empty series है।

e) MonthDays, एक numpy array से बनाई गई Series जिसमें वर्ष के 12 महीनों में दिनों की संख्या हो। लेबल 1 से 12 तक महीने के नंबर होने चाहिए।

6. प्रश्न 5 में बनाई गई Series का उपयोग करते हुए, निम्नलिखित के लिए आदेश लिखें:

a) Vowels के सभी मानों को 10 पर सेट करें और Series प्रदर्शित करें।

b) Vowels के सभी मानों को 2 से विभाजित करें और Series प्रदर्शित करें।

c) एक अन्य series Vowels1 बनाएं जिसमें 5 तत्व हों index लेबल ’ $a$ ‘, ’ $e$ ‘, ’ $i$ ‘, ’ $o$ ’ और ’ $u$ ’ के साथ और मान $[2,5,6,3,8]$ क्रमशः हों।

d) Vowels और Vowels1 को जोड़ें और परिणाम को Vowels3 में assign करें।

e) Vowels को Vowels1 से घटाएं, गुणा करें और विभाजित करें।

f) वेल्स 1 के लेबल्स को [‘A’, ’ $E$ ‘, ‘I’, ’ $O$ ‘, ’ $U$ ‘] में बदलें।

7. प्रश्न 5 में बनाई गई सीरीज़ का उपयोग करते हुए, निम्नलिखित के लिए कमांड लिखें:

a) सीरीज़ EngAlph, Vowels, Friends, MTseries, MonthDays की विमाएँ, आकार और मान ज्ञात करें।

b) सीरीज़ MTseries का नाम बदलकर SeriesEmpty रखें।

c) सीरीज़ MonthDays के इंडेक्स का नाम monthno और सीरीज़ Friends का नाम Fname रखें। d) सीरीज़ Friends का 3rd और 2nd मान उसी क्रम में प्रदर्शित करें।

e) सीरीज़ EngAlph से वर्णमाला ’ $e$ ’ से ’ $p$ ’ तक प्रदर्शित करें।

f) सीरीज़ EngAlph के पहले 10 मान प्रदर्शित करें।

g) सीरीज़ EngAlph के अंतिम 10 मान प्रदर्शित करें।

h) MTseries प्रदर्शित करें।

8. प्रश्न 5 में बनाई गई सीरीज़ का उपयोग करते हुए, निम्नलिखित के लिए कमांड लिखें:

a) सीरीज़ MonthDays से मार्च से जुलाई तक के महीनों के नाम प्रदर्शित करें।

b) सीरीज़ MonthDays को उलटे क्रम में प्रदर्शित करें।

9. निम्नलिखित डेटाफ्रेम Sales बनाएँ जिसमें पाँच सेल्सपर्सन का वर्षवार बिक्री आंकड़ा INR में हो। वर्षों को कॉलम लेबल्स के रूप में और सेल्सपर्सन के नामों को पंक्ति लेबल्स के रूप में उपयोग करें।

	$\mathbf{2 0 1 4}$	$\mathbf{2 0 1 5}$	$\mathbf{2 0 1 6}$	$\mathbf{2 0 1 7}$
Madhu	100.5	12000	20000	50000
Kusum	150.8	18000	50000	60000
Kinshuk	200.9	22000	70000	70000
Ankit	30000	30000	100000	80000
Shruti	40000	45000	125000	90000

10. उपरोक्त प्रश्न 9 में बनाए गए डेटाफ्रेम का उपयोग करते हुए निम्नलिखित करें:

a) Sales के पंक्ति लेबल प्रदर्शित करें।

b) Sales के स्तंभ लेबल प्रदर्शित करें।

c) Sales के प्रत्येक स्तंभ के डेटा प्रकार प्रदर्शित करें।

d) Sales की विमाएँ, आकृति, आकार और मान प्रदर्शित करें।

e) Sales की अंतिम दो पंक्तियाँ प्रदर्शित करें।

f) Sales के पहले दो स्तंभ प्रदर्शित करें।

g) निम्नलिखित डेटा का उपयोग करके एक शब्दकोश बनाएँ। इस शब्दकोश का उपयोग करके एक डेटाफ्रेम Sales2 बनाएँ।

	2018
Madhu	160000
Kusum	110000
Kinshuk	500000
Ankit	340000
Shruti	900000

h) जाँच करें कि Sales2 खाली है या इसमें डेटा है।

11. ऊपर प्रश्न 9 में बनाए गए डेटाफ्रेम का उपयोग करके निम्नलिखित करें:

a) डेटाफ्रेम Sales2 को डेटाफ्रेम Sales में जोड़ें।

b) डेटाफ्रेम Sales को इस प्रकार बदलें कि वह अपना ट्रांसपोज़ बन जाए।

c) वर्ष 2017 में सभी सेल्स पर्सन द्वारा किए गए बिक्री प्रदर्शित करें।

d) वर्ष 2017 और 2018 में Madhu और Ankit द्वारा किए गए बिक्री प्रदर्शित करें।

e) वर्ष 2016 में Shruti द्वारा किए गए बिक्री प्रदर्शित करें।

f) Sales में Sumeet सेल्समैन के लिए डेटा जोड़ें जहाँ बिक्री [196.2, 37800, 52000, 78438, 38852] है वर्षों $[2014,2015,2016,2017$, 2018] में क्रमशः।

g) डेटाफ्रेम Sales से वर्ष 2014 के डेटा को हटा दें।

h) डेटाफ्रेम Sales से सेल्समैन Kinshuk के डेटा को हटा दें।

i) सेल्सपर्सन Ankit का नाम Vivaan और Madhu का नाम Shailesh में बदलें।

j) वर्ष 2018 में Shailesh द्वारा की गई बिक्री को 100000 अपडेट करें।

k) DataFrame Sales के मानों को डिस्क पर एक अल्पविराम से अलग की गई फ़ाइल SalesFigures.csv में लिखें। पंक्ति लेबल और स्तंभ लेबल न लिखें।

1. फ़ाइल SalesFigures.csv में मौजूद डेटा को DataFrame SalesRetrieved में पढ़ें और उसे प्रदर्शित करें। अब SalesRetrieved के पंक्ति लेबल और स्तंभ लेबल को Sales के समान अद्यतन करें।