एक संपूर्ण लेख जिसे आप दिन के समय अपना पसंदीदा टीवी देखते हुए पढ़ सकते हैं, लेकिन वास्तव में काम पूरा करने के लिए आपको वह सब कुछ सिखाने के लिए पर्याप्त है जो आपको जानना आवश्यक है।

शुरू करना

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

आरंभ करने के लिए, पहले सुनिश्चित करें कि आपके सिस्टम में Python, NumPy और पांडा हैं। आप इसे कैसे प्राप्त करते हैं यह आपके सिस्टम और आपकी वरीयता के आईडीई पर निर्भर करता है, लेकिन मैं एनाकोंडा की अनुशंसा करता हूं। बुनियादी एनाकोंडा इंस्टॉलेशन के साथ आप बस टर्मिनल पर जा सकते हैं और "कोंडा इंस्टाल नम्पी" चला सकते हैं, और फिर "कोंडा इंस्टाल पांडा" और वोइला!

अब, काम शुरू करने के लिए एक example.py फाइल बनाते हैं।

नोट: यदि हम काम करने के लिए एक एकल उदाहरण फ़ाइल के बजाय एक प्रोजेक्ट बनाना चाहते हैं, तो हमें इसके अंदर एक निर्देशिका और एक __init__.py फ़ाइल बनानी होगी।

फ़ाइल के भीतर पंडों के साथ काम करने में सक्षम होने के लिए आपको फ़ाइल के शीर्ष पर निम्न पंक्तियाँ जोड़नी चाहिए।

Numpy को np के रूप में आयात करें

पीडी के रूप में पांडा आयात करें

नोट: हम आमतौर पर NumPy को np के रूप में और पांडा को pd के रूप में आयात करते हैं ताकि हमें हर बार पुस्तकालयों से किसी फ़ंक्शन को कॉल करने के लिए numpy और pandas टाइप न करना पड़े। ध्यान रखें कि बिल्कुल बदला जा सकता है, एनपी और पीडी सामान्य सम्मेलन हैं ।

उसके बाद, आप केवल टर्मिनल पर जाकर और कमांड चलाकर उदाहरण फ़ाइल के भीतर कोड चला सकते हैं:

अजगर example.py

श्रृंखला

जिस तरह किसी भी प्रोग्रामिंग लैंग्वेज में सरणियाँ होती हैं, उसी तरह NumPy में मैट्रिसेस कैसे होते हैं, हमें पंडों में सीरीज़ मिलती है। श्रृंखला और साधारण आव्यूह/सरणियों के बीच मुख्य अंतर यह है कि श्रृंखला के भीतर की वस्तुओं में उस मूल्य तक पहुँचने के लिए सूचकांक संख्या या कुंजियाँ हो सकती हैं। इसे JSON डेटा जैसे की-वैल्यू पेयर की सूची के रूप में सोचें।

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

आप पायथन डिक्शनरी से पंडों की एक श्रृंखला बना सकते हैं:

myDictionary = {"जॉन" : 35, "जेन" : 40}

pd.Series(myDictionary) // रिटर्न जॉन 35, जेन 40

यदि आप एक शब्दकोश के बजाय एक सरणी जोड़ना चाहते थे, तो श्रृंखला के आइटमों में कुंजी के रूप में पूर्णांक होंगे:

myArray = [35, 40]

pd.Series(myArray) // रिटर्न 0 35, 1 40

आप दो सरणियों को एक साथ जोड़ सकते हैं और उनमें से एक श्रृंखला बना सकते हैं:

myArray1 = [35, 40]

myArray2 = ["जॉन", "जेन"]

pd.Series (डेटा = myArray1, index = myArray2) // रिटर्न जॉन 35, जेन 40

यदि एक ही कुंजी के साथ दो अलग-अलग श्रृंखलाएं हैं, तो आप उन पर गणितीय कार्य कर सकते हैं:

सीरीज़ 1 = पीडी. सीरीज़ ({"जॉन" : 35, "जेन" : 40})

श्रृंखला 2 = पीडी। श्रृंखला ({"जॉन": 100, "जेन": 50})

सीरीज़सम = सीरीज़ 1 + सीरीज़ 2 // रिटर्न जॉन 135, जेन 90

नोट: विभिन्न कुंजियों के साथ श्रृंखला पर एक गणितीय ऑपरेशन करते समय, मेल खाने वाली कुंजियों के ऑपरेशन का परिणाम उनके मान के रूप में होगा, लेकिन नॉट-मेचिंग कुंजियों में NaN का मान होगा क्योंकि इन कुंजियों के लिए कोई परिणाम नहीं होगा।

डेटा फ्रेम्स

डेटा फ़्रेम को एक श्रृंखला के रूप में माना जा सकता है लेकिन मैट्रिसेस के लिए। मूल रूप से, एक मैट्रिक्स जहां इंडेक्स कुंजी हैं और पूरी चीज एक कुंजी-मूल्य जोड़ी है, डेटा फ्रेम कहलाती है।

आप किसी भी सरणी या मैट्रिक्स से डेटा फ़्रेम बना सकते हैं:

myMatrix = [[10, 20, 30], [100, 200, 300]]

dataFrame = pd.DataFrame (myMatrix)

आप स्तंभों और पंक्तियों की कुंजियों को इस प्रकार असाइन कर सकते हैं:

myMatrix = [[1, 2, 3], [10, 20, 30], [100, 200, 300]]

पंक्तियाँ = ["जॉन", "जेन", "सारा"]

कॉलम = ["टेनिस", "बास्केटबॉल", "पिंगपोंग"]

dataFrame = pd.DataFrame (myMatrix, index = Rows, column = column)

आप डेटा फ्रेम से एक निश्चित कॉलम को इस प्रकार कॉल कर सकते हैं:

डेटाफ्रेम ["टेनिस"]

यदि आप ऊपर दिखाए गए कुंजी के साथ एक पंक्ति को कॉल करना चाहते हैं, हालांकि, यह एक त्रुटि फेंक देगा। आप कुंजी के साथ एक पंक्ति को कॉल कर सकते हैं:

dataFrame.loc ["जॉन"]

तथ्य यह है कि कॉलम और पंक्तियों को कॉल करने के लिए कुंजियाँ हैं, इसका मतलब यह नहीं है कि कोई अनुक्रमणिका नहीं है। मेट्रिसेस की तरह ही, इंडेक्स अभी भी मौजूद हैं। उदाहरण के लिए, आप पहली पंक्ति को इस प्रकार कॉल कर सकते हैं:

dataFrame.iloc [1] // पंक्ति जेन को 2, 20, 200 मानों के साथ लौटाता है

आप डेटा फ्रेम में एक नया कॉलम इस प्रकार जोड़ सकते हैं:

डेटाफ्रेम ["फुटबॉल"] = [1000, 2000, 3000]

इसके विपरीत, आप डेटा फ्रेम से कॉलम या पंक्ति को इस प्रकार हटा सकते हैं:

dataFrame.drop ("फुटबॉल", एक्सिस = 1, इनप्लेस = ट्रू) // एक कॉलम को हटाने के लिए आपको एक्सिस को 1 पर सेट करना होगा

dataFrame.drop ("जॉन", अक्ष = 0, इनप्लेस = ट्रू) // एक पंक्ति को हटाने के लिए आपको अक्ष को 0 पर सेट करना होगा

नोट: पांडा नहीं चाहते कि आप गलती से पूरे कॉलम या पंक्ति को बदल दें। हो सकता है कि आप एक और डेटा फ्रेम बनाने की कोशिश कर रहे हों और पुराने डेटा फ्रेम को वास्तव में पुराने को बदलने के बजाय एक कॉलम गायब कर दें? इसलिए यह सुनिश्चित करने के लिए कि आप वास्तव में स्वयं डेटा फ़्रेम बदल रहे हैं, हम फ़ंक्शन के भीतर inPlace=True पैरामीटर डालते हैं।

आप सेल वैल्यू को इस रूप में कॉल कर सकते हैं:

dataFrame.loc ["जॉन", "टेनिस"]

आप डेटा फ्रेम के भीतर समाप्त कर सकते हैं:

डेटाफ्रेम [डेटाफ्रेम ["टेनिस"]> 5]

// उन पंक्तियों को हटा देगा जहां टेनिस कॉलम का मान 5 से कम है, इसलिए, पंक्ति जॉन को हटा देगा

डेटा फ्रेम के भीतर इंडेक्स को बदलने के लिए, पहले आपको नए इंडेक्स सरणी को पुराने डेटा फ्रेम में कॉलम के रूप में जोड़ना होगा। फिर, आप इसे कॉलम नाम से कैप्चर कर सकते हैं और इसके मानों को नए इंडेक्स के रूप में असाइन कर सकते हैं:

dataFrame.set_indexes ("नया इंडेक्स कॉलम", इनप्लेस = ट्रू)

एक्सेल में मल्टी-इंडेक्स डेटा फ्रेम इस तरह दिखता है:

यहां पंक्तियों के लिए दो इंडेक्स हैं, फल और सब्जी और उत्पाद का नाम। हम पंडों के माध्यम से इस तरह के मल्टी-इंडेक्स भी बना सकते हैं। ऐसा करने के लिए आपको चाहिए:

• बाहरी अनुक्रमणिका और आंतरिक अनुक्रमणिका की दो सूचियों को परिभाषित करें, और फिर इन दोनों को एक टपल यूज़िंग सूची और ज़िप विधियों में संयोजित करें।
• फिर टपल को मल्टी-इंडेक्स में बदलने के लिए MultiIndex.from_tuples() विधि का उपयोग करें।
• फिर स्तंभों की एक सूची बनाएँ।
• उसके बाद, मैट्रिक्स के रूप में डेटा की एक सूची बनाएं और वास्तव में इसे np.array() विधि का उपयोग करके मैट्रिक्स में बदल दें।
• अंत में, मल्टी-इंडेक्स के साथ डेटा फ़्रेम बनाने के लिए पांडा के DataFrame() फ़ंक्शन का उपयोग करें।

आउटरइंडेक्स = ["सब्जियां", "सब्जियां", "फ्रूटिस", "फल"]

innerIndexes = ["टमाटर", "खीरे", "संतरे", "ब्लूबेरी"]

संयुक्त इंडेक्स = सूची (ज़िप (बाहरी इंडेक्स, आंतरिक इंडेक्स))

संयुक्त इंडेक्स = pd.MultiIndex.from_tuples (संयुक्त इंडेक्स)

listAmountPrice = [[ 2 यूएसडी, 5 एलबीएस], [ 1 यूएसडी, 3 एलबीएस], [ 2 यूएसडी, 3 एलबीएस], [ 3 यूएसडी, 2 एलबीएस] ]

numpySeriesAmountPrice = np.array (listAmountPrice)

myColumns = ["कीमत", "राशि"]

multiIndexDataFrame = pd.DataFrame (numpySeriesAmountPrice, index = CombinedIndexes, column = myColumns)

और फिर, आप ब्लूबेरी की राशि और कीमत को इस प्रकार कॉल कर सकते हैं:

multiIndexDataFrame.loc ["फल"] .loc ["ब्लूबेरी"]

आप मल्टी-इंडेक्स कॉलम को कुछ नाम भी दे सकते हैं, जैसे:

multiIndexDataFrame.index.names = ["गलियारा", "उत्पाद का नाम"]

संचालन

• मूल डेटा फ़्रेम से उन पंक्तियों के साथ डेटा फ़्रेम वापस करने के लिए जिनमें NaN मान हटाए गए हैं:

• मूल डेटा फ़्रेम से डेटा फ़्रेम को वापस करने के लिए जिसमें NaN मान हटाए गए कॉलम हैं:

• मूल डेटा फ़्रेम से उन पंक्तियों के साथ डेटा फ़्रेम वापस करने के लिए जिनमें दो से अधिक NaN मान हटाए गए हैं:

• मूल डेटा फ़्रेम से डेटा फ़्रेम को वापस करने के लिए, जिसमें NaN मान वाले सेल को एक निश्चित मान में बदल दिया जाता है, मान लीजिए, पूर्णांक 20:

• ऑपरेशन चलाने के लिए और कॉलम के आधार पर डेटा फ्रेम के बारे में डेटा इकट्ठा करने के लिए, आपको ग्रुपबी का उपयोग करके डेटा फ्रेम को उस कॉलम के संबंध में समूहित करना चाहिए। फिर आप डेटा को गिनने के लिए संचालन कर सकते हैं, मूल्यों का मतलब प्राप्त कर सकते हैं आदि।

group.mean() // तालिका के भीतर वेतन का माध्य प्राप्त करता है

group.count() // गणना करता है कि कितने कर्मचारियों को प्रत्येक वेतन के लिए एक निश्चित वेतन मिलता है

group.describe () // समूहीकृत "वेतन" कॉलम के सापेक्ष उस डेटा फ़्रेम के लिए माध्य, अधिकतम और न्यूनतम मान आदि जैसे कुछ सांख्यिकीय विश्लेषण परिणाम लाता है

• यदि आपके पास दो या दो से अधिक डेटा फ़्रेम हैं जिनमें समान कॉलम हैं, तो आप उन्हें एक साथ (एक के नीचे एक) इस तरह इकट्ठा कर सकते हैं:

• इसी तरह, यदि आपके पास दो या दो से अधिक डेटा फ़्रेम हैं जिनमें समान पंक्तियाँ हैं, तो आप उन्हें एक साथ (एक के नीचे एक) इस तरह इकट्ठा कर सकते हैं:

• यदि आप विभिन्न स्तंभों के साथ दो या अधिक डेटा फ़्रेम प्राप्त करना चाहते हैं, हालाँकि, आप नीचे मर्ज विधि का उपयोग करेंगे। लेकिन ध्यान रखें, ऐसा करने में सक्षम होने के लिए, आपके द्वारा मर्ज किए जाने वाले सभी डेटा फ़्रेमों में कम से कम एक कॉलम उभयनिष्ठ होना चाहिए।

• आप डेटाबेस में एक कॉलम के भीतर केवल अद्वितीय मान ला सकते हैं:

• आप गणना कर सकते हैं कि डेटा फ्रेम में कॉलम के भीतर कितने अद्वितीय मान हैं:

• आप एक फ़ंक्शन को परिभाषित कर सकते हैं और इसे .apply() फ़ंक्शन के साथ डेटा फ़्रेम में प्रत्येक मान पर लागू कर सकते हैं। एक उदाहरण में आगे समझाने के लिए:

रिटर्न कीमत * 1.33//फ़ंक्शन जो मूल कीमत में 33% टैक्स जोड़ता है

priceDataFrame ["मूल्य"]।

पंडों के साथ एक्सेल

भले ही हमने उपरोक्त डेटा फ्रेम और श्रृंखला के साथ काम किया हो, वास्तविक जीवन डेटा आपको एक्सेल फ़ाइल के रूप में सौंपे जाने की संभावना है।

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

myDataFrame = pd.read_excel ("myExcelFile.xlsx")

Excel फ़ाइलें डिफ़ॉल्ट रूप से DataFrame प्रकार के रूप में आयात की जाएंगी, इसलिए आप जाने के लिए तैयार हैं!

निष्कर्ष

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