msb-public
/
Data-Science-For-Beginners
mirror of https://github.com/microsoft/Data-Science-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'copilot/implement-changes-from-issue-724'
${ noResults }
Data-Science-For-Beginners/translations/hi/2-Working-With-Data/08-data-preparation/notebook.ipynb

4241 lines
157 KiB
Raw Permalink Blame History

{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "rQ8UhzFpgRra"
},
"source": [
"# डेटा तैयारी\n",
"\n",
"[मूल नोटबुक स्रोत *डेटा साइंस: डेटा साइंस के लिए मशीन लर्निंग का परिचय, पायथन और मशीन लर्निंग स्टूडियो* ली स्टॉट द्वारा](https://github.com/leestott/intro-Datascience/blob/master/Course%20Materials/4-Cleaning_and_Manipulating-Reference.ipynb)\n",
"\n",
"## `DataFrame` जानकारी का अन्वेषण\n",
"\n",
"> **लक्ष्य:** इस उपखंड के अंत तक, आपको pandas DataFrames में संग्रहीत डेटा के बारे में सामान्य जानकारी प्राप्त करने में सहज होना चाहिए।\n",
"\n",
"जब आपने अपना डेटा pandas में लोड कर लिया है, तो यह अधिक संभावना है कि यह `DataFrame` में होगा। हालांकि, यदि आपके `DataFrame` में 60,000 पंक्तियाँ और 400 स्तंभ हैं, तो आप यह समझना कैसे शुरू करेंगे कि आप किसके साथ काम कर रहे हैं? सौभाग्य से, pandas कुछ सुविधाजनक उपकरण प्रदान करता है जो `DataFrame` की समग्र जानकारी के साथ-साथ शुरुआती और अंतिम कुछ पंक्तियों को जल्दी से देखने में मदद करते हैं।\n",
"\n",
"इस कार्यक्षमता का अन्वेषण करने के लिए, हम Python scikit-learn लाइब्रेरी को आयात करेंगे और एक प्रसिद्ध डेटा सेट का उपयोग करेंगे जिसे हर डेटा वैज्ञानिक ने सैकड़ों बार देखा है: ब्रिटिश जीवविज्ञानी रोनाल्ड फिशर का *Iris* डेटा सेट, जो उनकी 1936 की पेपर \"The use of multiple measurements in taxonomic problems\" में उपयोग किया गया था:\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": true,
"id": "hB1RofhdgRrp",
"trusted": false
},
"outputs": [],
"source": [
"import pandas as pd\n",
"from sklearn.datasets import load_iris\n",
"\n",
"iris = load_iris()\n",
"iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AGA0A_Y8hMdz"
},
"source": [
"### `DataFrame.shape`\n",
"हमने Iris Dataset को `iris_df` नामक वेरिएबल में लोड किया है। डेटा में गहराई से जाने से पहले, यह जानना महत्वपूर्ण होगा कि हमारे पास कितने डेटा पॉइंट्स हैं और पूरे डेटासेट का आकार क्या है। यह देखना उपयोगी होता है कि हम कितने डेटा की मात्रा के साथ काम कर रहे हैं।\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LOe5jQohhulf",
"outputId": "fb0577ac-3b4a-4623-cb41-20e1b264b3e9"
},
"outputs": [
{
"data": {
"text/plain": [
"(150, 4)"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.shape"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "smE7AGzOhxk2"
},
"source": [
"तो, हम 150 पंक्तियों और 4 स्तंभों के डेटा से निपट रहे हैं। प्रत्येक पंक्ति एक डेटा पॉइंट का प्रतिनिधित्व करती है और प्रत्येक स्तंभ डेटा फ्रेम से जुड़े एकल फीचर का प्रतिनिधित्व करता है। तो मूल रूप से, 150 डेटा पॉइंट हैं, जिनमें प्रत्येक में 4 फीचर शामिल हैं।\n",
"\n",
"`shape` यहाँ डेटा फ्रेम का एक गुण है और कोई फ़ंक्शन नहीं है, यही कारण है कि यह कोष्ठकों की एक जोड़ी के साथ समाप्त नहीं होता।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "d3AZKs0PinGP"
},
"source": [
"### `DataFrame.columns`\n",
"अब हम डेटा की 4 कॉलम्स पर ध्यान देते हैं। इनमें से प्रत्येक वास्तव में क्या दर्शाती है? `columns` एट्रिब्यूट हमें डेटा फ्रेम में कॉलम्स के नाम देगा।\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "YPGh_ziji-CY",
"outputId": "74e7a43a-77cc-4c80-da56-7f50767c37a0"
},
"outputs": [
{
"data": {
"text/plain": [
"Index(['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)',\n",
" 'petal width (cm)'],\n",
" dtype='object')"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.columns"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TsobcU_VjCC_"
},
"source": [
"जैसा कि हम देख सकते हैं, यहाँ चार(4) कॉलम हैं। `columns` एट्रिब्यूट हमें कॉलम के नाम बताता है और मूल रूप से कुछ और नहीं। यह एट्रिब्यूट तब महत्वपूर्ण हो जाता है जब हम यह पहचानना चाहते हैं कि किसी डेटासेट में कौन-कौन से फीचर्स शामिल हैं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2UTlvkjmgRrs"
},
"source": [
"### `DataFrame.info`\n",
"डेटा की मात्रा (`shape` attribute द्वारा दी गई) और फीचर्स या कॉलम के नाम (`columns` attribute द्वारा दिए गए) हमें डेटासेट के बारे में कुछ जानकारी देते हैं। अब, हम डेटासेट में और गहराई से जाना चाहेंगे। `DataFrame.info()` फ़ंक्शन इसके लिए काफी उपयोगी है।\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "dHHRyG0_gRrt",
"outputId": "d8fb0c40-4f18-4e19-da48-c8db77d1d3a5",
"trusted": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'pandas.core.frame.DataFrame'>\n",
"RangeIndex: 150 entries, 0 to 149\n",
"Data columns (total 4 columns):\n",
" # Column Non-Null Count Dtype \n",
"--- ------ -------------- ----- \n",
" 0 sepal length (cm) 150 non-null float64\n",
" 1 sepal width (cm) 150 non-null float64\n",
" 2 petal length (cm) 150 non-null float64\n",
" 3 petal width (cm) 150 non-null float64\n",
"dtypes: float64(4)\n",
"memory usage: 4.8 KB\n"
]
}
],
"source": [
"iris_df.info()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1XgVMpvigRru"
},
"source": [
"यहां से, हम कुछ टिप्पणियां कर सकते हैं:\n",
"1. प्रत्येक कॉलम का डेटा प्रकार: इस डेटा सेट में, सभी डेटा 64-बिट फ्लोटिंग-पॉइंट नंबर के रूप में संग्रहीत हैं।\n",
"2. नॉन-नल मानों की संख्या: नल मानों को संभालना डेटा तैयारी में एक महत्वपूर्ण कदम है। इसे नोटबुक में बाद में संभाला जाएगा।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IYlyxbpWFEF4"
},
"source": [
"### DataFrame.describe()\n",
"मान लीजिए हमारे डेटा सेट में बहुत सारा संख्यात्मक डेटा है। एकविवरणात्मक सांख्यिकीय गणनाएँ जैसे औसत, माध्यिका, चतुर्थांश आदि प्रत्येक कॉलम पर अलग-अलग की जा सकती हैं। `DataFrame.describe()` फ़ंक्शन हमें डेटा सेट के संख्यात्मक कॉलम का सांख्यिकीय सारांश प्रदान करता है।\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 297
},
"id": "tWV-CMstFIRA",
"outputId": "4fc49941-bc13-4b0c-a412-cb39e7d3f289"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>count</th>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>mean</th>\n",
" <td>5.843333</td>\n",
" <td>3.057333</td>\n",
" <td>3.758000</td>\n",
" <td>1.199333</td>\n",
" </tr>\n",
" <tr>\n",
" <th>std</th>\n",
" <td>0.828066</td>\n",
" <td>0.435866</td>\n",
" <td>1.765298</td>\n",
" <td>0.762238</td>\n",
" </tr>\n",
" <tr>\n",
" <th>min</th>\n",
" <td>4.300000</td>\n",
" <td>2.000000</td>\n",
" <td>1.000000</td>\n",
" <td>0.100000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>25%</th>\n",
" <td>5.100000</td>\n",
" <td>2.800000</td>\n",
" <td>1.600000</td>\n",
" <td>0.300000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>50%</th>\n",
" <td>5.800000</td>\n",
" <td>3.000000</td>\n",
" <td>4.350000</td>\n",
" <td>1.300000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>75%</th>\n",
" <td>6.400000</td>\n",
" <td>3.300000</td>\n",
" <td>5.100000</td>\n",
" <td>1.800000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>max</th>\n",
" <td>7.900000</td>\n",
" <td>4.400000</td>\n",
" <td>6.900000</td>\n",
" <td>2.500000</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"count 150.000000 150.000000 150.000000 150.000000\n",
"mean 5.843333 3.057333 3.758000 1.199333\n",
"std 0.828066 0.435866 1.765298 0.762238\n",
"min 4.300000 2.000000 1.000000 0.100000\n",
"25% 5.100000 2.800000 1.600000 0.300000\n",
"50% 5.800000 3.000000 4.350000 1.300000\n",
"75% 6.400000 3.300000 5.100000 1.800000\n",
"max 7.900000 4.400000 6.900000 2.500000"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.describe()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zjjtW5hPGMuM"
},
"source": [
"ऊपर दिया गया आउटपुट प्रत्येक कॉलम के कुल डेटा पॉइंट्स, औसत, मानक विचलन, न्यूनतम, निचला चतुर्थक (25%), माध्य (50%), ऊपरी चतुर्थक (75%) और अधिकतम मान को दिखाता है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-lviAu99gRrv"
},
"source": [
"### `DataFrame.head`\n",
"ऊपर दिए गए सभी फ़ंक्शन्स और एट्रिब्यूट्स के साथ, हमने डेटासेट का एक उच्च-स्तरीय दृष्टिकोण प्राप्त कर लिया है। हमें पता है कि कितने डेटा पॉइंट्स हैं, कितनी विशेषताएँ हैं, प्रत्येक विशेषता का डेटा प्रकार क्या है और प्रत्येक विशेषता के लिए कितने नॉन-नल वैल्यूज़ हैं।\n",
"\n",
"अब समय है डेटा को खुद देखने का। चलिए देखते हैं कि हमारे `DataFrame` की शुरुआती कुछ पंक्तियाँ (शुरुआती कुछ डेटा पॉइंट्स) कैसी दिखती हैं:\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "DZMJZh0OgRrw",
"outputId": "d9393ee5-c106-4797-f815-218f17160e00",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>5.1</td>\n",
" <td>3.5</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>4.9</td>\n",
" <td>3.0</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>4.7</td>\n",
" <td>3.2</td>\n",
" <td>1.3</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>4.6</td>\n",
" <td>3.1</td>\n",
" <td>1.5</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>5.0</td>\n",
" <td>3.6</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"0 5.1 3.5 1.4 0.2\n",
"1 4.9 3.0 1.4 0.2\n",
"2 4.7 3.2 1.3 0.2\n",
"3 4.6 3.1 1.5 0.2\n",
"4 5.0 3.6 1.4 0.2"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EBHEimZuEFQK"
},
"source": [
"आउटपुट में, हम डेटा सेट के पाँच (5) प्रविष्टियाँ देख सकते हैं। यदि हम बाईं ओर के इंडेक्स को देखें, तो पता चलता है कि ये पहली पाँच पंक्तियाँ हैं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oj7GkrTdgRry"
},
"source": [
"### अभ्यास:\n",
"\n",
"ऊपर दिए गए उदाहरण से यह स्पष्ट है कि डिफ़ॉल्ट रूप से `DataFrame.head` एक `DataFrame` की पहली पांच पंक्तियाँ लौटाता है। नीचे दिए गए कोड सेल में, क्या आप यह पता लगा सकते हैं कि पाँच से अधिक पंक्तियाँ कैसे प्रदर्शित की जाएं?\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": true,
"id": "EKRmRFFegRrz",
"trusted": false
},
"outputs": [],
"source": [
"# Hint: Consult the documentation by using iris_df.head?"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BJ_cpZqNgRr1"
},
"source": [
"### `DataFrame.tail`\n",
"डेटा को देखने का एक और तरीका अंत से हो सकता है (शुरुआत के बजाय)। `DataFrame.head` का उल्टा `DataFrame.tail` है, जो `DataFrame` की आखिरी पांच पंक्तियाँ लौटाता है:\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "heanjfGWgRr2",
"outputId": "6ae09a21-fe09-4110-b0d7-1a1fbf34d7f3",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>145</th>\n",
" <td>6.7</td>\n",
" <td>3.0</td>\n",
" <td>5.2</td>\n",
" <td>2.3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>146</th>\n",
" <td>6.3</td>\n",
" <td>2.5</td>\n",
" <td>5.0</td>\n",
" <td>1.9</td>\n",
" </tr>\n",
" <tr>\n",
" <th>147</th>\n",
" <td>6.5</td>\n",
" <td>3.0</td>\n",
" <td>5.2</td>\n",
" <td>2.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>148</th>\n",
" <td>6.2</td>\n",
" <td>3.4</td>\n",
" <td>5.4</td>\n",
" <td>2.3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>149</th>\n",
" <td>5.9</td>\n",
" <td>3.0</td>\n",
" <td>5.1</td>\n",
" <td>1.8</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"145 6.7 3.0 5.2 2.3\n",
"146 6.3 2.5 5.0 1.9\n",
"147 6.5 3.0 5.2 2.0\n",
"148 6.2 3.4 5.4 2.3\n",
"149 5.9 3.0 5.1 1.8"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.tail()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "31kBWfyLgRr3"
},
"source": [
"व्यवहार में, यह उपयोगी होता है कि आप आसानी से `DataFrame` की शुरुआती कुछ पंक्तियों या अंतिम कुछ पंक्तियों की जांच कर सकें, खासकर जब आप क्रमबद्ध डेटा सेट में असामान्य मान खोज रहे हों।\n",
"\n",
"ऊपर दिखाए गए सभी फ़ंक्शन और गुण, कोड उदाहरणों की मदद से, हमें डेटा की झलक और अनुभव प्राप्त करने में मदद करते हैं।\n",
"\n",
"> **मुख्य बात:** केवल `DataFrame` में जानकारी के मेटाडेटा को देखकर या इसकी शुरुआती और अंतिम कुछ मानों को देखकर, आप जिस डेटा से निपट रहे हैं उसकी आकार, संरचना और सामग्री के बारे में तुरंत एक विचार प्राप्त कर सकते हैं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TvurZyLSDxq_"
},
"source": [
"### डेटा की कमी\n",
"आइए डेटा की कमी के बारे में जानें। डेटा की कमी तब होती है, जब कुछ कॉलम में कोई मान संग्रहीत नहीं होता है।\n",
"\n",
"एक उदाहरण लेते हैं: मान लीजिए कोई व्यक्ति अपने वजन को लेकर सचेत है और सर्वेक्षण में वजन वाले फील्ड को नहीं भरता है। तो उस व्यक्ति के लिए वजन का मान गायब होगा।\n",
"\n",
"अधिकतर समय, वास्तविक दुनिया के डेटासेट्स में, मान गायब होने की समस्या होती है।\n",
"\n",
"**Pandas डेटा की कमी को कैसे संभालता है**\n",
"\n",
"Pandas दो तरीकों से गायब मानों को संभालता है। पहला तरीका आपने पहले के सेक्शन्स में देखा होगा: `NaN`, या Not a Number। यह वास्तव में IEEE फ्लोटिंग-पॉइंट स्पेसिफिकेशन का एक विशेष मान है और इसे केवल गायब फ्लोटिंग-पॉइंट मानों को इंगित करने के लिए उपयोग किया जाता है।\n",
"\n",
"फ्लोट्स के अलावा गायब मानों के लिए, pandas Python के `None` ऑब्जेक्ट का उपयोग करता है। हालांकि यह थोड़ा भ्रमित करने वाला लग सकता है कि आपको दो अलग-अलग प्रकार के मान मिलते हैं जो मूल रूप से एक ही बात कहते हैं, लेकिन इस डिज़ाइन विकल्प के पीछे ठोस प्रोग्रामेटिक कारण हैं। और व्यवहार में, इस रास्ते पर जाने से pandas अधिकांश मामलों के लिए एक अच्छा संतुलन प्रदान करने में सक्षम होता है। इसके बावजूद, `None` और `NaN` दोनों में कुछ सीमाएँ होती हैं जिनके बारे में आपको सतर्क रहना चाहिए कि उन्हें कैसे उपयोग किया जा सकता है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lOHqUlZFgRr5"
},
"source": [
"### `None`: गैर-फ्लोट गायब डेटा\n",
"क्योंकि `None` Python से आता है, इसे NumPy और pandas के उन arrays में उपयोग नहीं किया जा सकता जिनका डेटा प्रकार `'object'` नहीं है। याद रखें, NumPy arrays (और pandas में डेटा संरचनाएं) केवल एक प्रकार के डेटा को ही समाहित कर सकते हैं। यही कारण है कि वे बड़े पैमाने पर डेटा और गणनात्मक कार्यों के लिए अत्यधिक शक्तिशाली हैं, लेकिन यह उनकी लचीलापन को भी सीमित करता है। ऐसे arrays को \"न्यूनतम सामान्य भाजक\" में बदलना पड़ता है, यानी वह डेटा प्रकार जो array में सब कुछ समाहित कर सके। जब array में `None` होता है, तो इसका मतलब है कि आप Python objects के साथ काम कर रहे हैं।\n",
"\n",
"इसका उदाहरण देखने के लिए, निम्नलिखित array पर विचार करें (इसके `dtype` पर ध्यान दें):\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "QIoNdY4ngRr7",
"outputId": "92779f18-62f4-4a03-eca2-e9a101604336",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([2, None, 6, 8], dtype=object)"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import numpy as np\n",
"\n",
"example1 = np.array([2, None, 6, 8])\n",
"example1"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pdlgPNbhgRr7"
},
"source": [
"अपकास्ट डेटा प्रकारों की वास्तविकता के साथ दो प्रभाव जुड़े होते हैं। पहला, ऑपरेशन्स इंटरप्रेटेड Python कोड के स्तर पर किए जाते हैं, न कि कंपाइल्ड NumPy कोड के स्तर पर। इसका मतलब यह है कि यदि `Series` या `DataFrames` में `None` शामिल है, तो उनसे जुड़े ऑपरेशन्स धीमे होंगे। हालांकि, आप शायद इस प्रदर्शन में गिरावट को महसूस न करें, लेकिन बड़े डेटा सेट्स के लिए यह समस्या बन सकती है।\n",
"\n",
"दूसरा प्रभाव पहले वाले से जुड़ा हुआ है। क्योंकि `None` मूल रूप से `Series` या `DataFrame`s को सामान्य Python की दुनिया में वापस ले जाता है, ऐसे में यदि आप NumPy/pandas एग्रीगेशन जैसे `sum()` या `min()` का उपयोग उन arrays पर करते हैं जिनमें ``None`` मान होता है, तो आमतौर पर एक त्रुटि उत्पन्न होगी:\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 292
},
"id": "gWbx-KB9gRr8",
"outputId": "ecba710a-22ec-41d5-a39c-11f67e645b50",
"trusted": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "ignored",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-10-ce9901ad18bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 45\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m 46\u001b[0m initial=_NoValue, where=True):\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwhere\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n",
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'"
]
}
],
"source": [
"example1.sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LcEwO8UogRr9"
},
"source": [
"**मुख्य निष्कर्ष**: पूर्णांकों और `None` मानों के बीच जोड़ (और अन्य संचालन) अपरिभाषित है, जो उन डेटासेट्स के साथ आपके कार्यों को सीमित कर सकता है जिनमें ये शामिल हैं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pWvVHvETgRr9"
},
"source": [
"### `NaN`: गायब फ्लोट मान\n",
"\n",
"`None` के विपरीत, NumPy (और इसलिए pandas) अपने तेज, वेक्टराइज्ड ऑपरेशन्स और ufuncs के लिए `NaN` का समर्थन करता है। बुरी खबर यह है कि `NaN` पर किया गया कोई भी अंकगणितीय ऑपरेशन हमेशा `NaN` ही देता है। उदाहरण के लिए:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "rcFYfMG9gRr9",
"outputId": "699e81b7-5c11-4b46-df1d-06071768690f",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan + 1"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "BW3zQD2-gRr-",
"outputId": "4525b6c4-495d-4f7b-a979-efce1dae9bd0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan * 0"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fU5IPRcCgRr-"
},
"source": [
"अच्छी खबर: `NaN` वाले ऐरे पर चलने वाले समेकन त्रुटियां उत्पन्न नहीं करते। बुरी खबर: परिणाम समान रूप से उपयोगी नहीं होते:\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LCInVgSSgRr_",
"outputId": "fa06495a-0930-4867-87c5-6023031ea8b5",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"(nan, nan, nan)"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example2 = np.array([2, np.nan, 6, 8]) \n",
"example2.sum(), example2.min(), example2.max()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nhlnNJT7gRr_"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true,
"id": "yan3QRaOgRr_",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you add np.nan and None together?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_iDvIRC8gRsA"
},
"source": [
"याद रखें: `NaN` केवल गायब फ्लोटिंग-पॉइंट मानों के लिए है; पूर्णांक, स्ट्रिंग्स, या बूलियन के लिए कोई `NaN` समकक्ष नहीं है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kj6EKdsAgRsA"
},
"source": [
"### `NaN` और `None`: pandas में null मान\n",
"\n",
"हालांकि `NaN` और `None` का व्यवहार थोड़ा अलग हो सकता है, फिर भी pandas इन्हें एक-दूसरे के स्थान पर संभालने के लिए बनाया गया है। इसे समझने के लिए, आइए एक `Series` के उदाहरण पर विचार करें जिसमें पूर्णांक हैं:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Nji-KGdNgRsA",
"outputId": "36aa14d2-8efa-4bfd-c0ed-682991288822",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 1\n",
"1 2\n",
"2 3\n",
"dtype: int64"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"int_series = pd.Series([1, 2, 3], dtype=int)\n",
"int_series"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WklCzqb8gRsB"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": true,
"id": "Cy-gqX5-gRsB",
"trusted": false
},
"outputs": [],
"source": [
"# Now set an element of int_series equal to None.\n",
"# How does that element show up in the Series?\n",
"# What is the dtype of the Series?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WjMQwltNgRsB"
},
"source": [
"`Series` और `DataFrame` में डेटा की समानता स्थापित करने के लिए डेटा प्रकारों को अपकास्ट करने की प्रक्रिया में, pandas आसानी से गायब मानों को `None` और `NaN` के बीच बदल सकता है। इस डिज़ाइन फीचर के कारण, pandas में `None` और `NaN` को \"null\" के दो अलग-अलग प्रकार के रूप में सोचना उपयोगी हो सकता है। वास्तव में, pandas में गायब मानों को संभालने के लिए उपयोग किए जाने वाले कुछ मुख्य तरीकों के नाम इस विचार को दर्शाते हैं:\n",
"\n",
"- `isnull()`: गायब मानों को इंगित करने वाला एक बूलियन मास्क बनाता है\n",
"- `notnull()`: `isnull()` का विपरीत\n",
"- `dropna()`: डेटा का फ़िल्टर किया हुआ संस्करण लौटाता है\n",
"- `fillna()`: डेटा की एक प्रति लौटाता है जिसमें गायब मान भरे या अनुमानित किए गए हों\n",
"\n",
"ये महत्वपूर्ण विधियां हैं जिन्हें समझना और इनके साथ सहज होना आवश्यक है, इसलिए आइए इन्हें विस्तार से समझते हैं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Yh5ifd9FgRsB"
},
"source": [
"### null मानों का पता लगाना\n",
"\n",
"अब जब हमने गायब मानों के महत्व को समझ लिया है, तो हमें उन्हें संभालने से पहले अपने डेटा सेट में उनका पता लगाना होगा। \n",
"`isnull()` और `notnull()` दोनों null डेटा का पता लगाने के लिए आपके मुख्य तरीके हैं। दोनों आपके डेटा पर Boolean मास्क लौटाते हैं।\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": true,
"id": "e-vFp5lvgRsC",
"trusted": false
},
"outputs": [],
"source": [
"example3 = pd.Series([0, np.nan, '', None])"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "1XdaJJ7PgRsC",
"outputId": "92fc363a-1874-471f-846d-f4f9ce1f51d0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 False\n",
"1 True\n",
"2 False\n",
"3 True\n",
"dtype: bool"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3.isnull()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PaSZ0SQygRsC"
},
"source": [
"आउटपुट को ध्यान से देखें। क्या इसमें कुछ ऐसा है जो आपको चौंकाता है? जबकि `0` एक गणितीय शून्य है, यह फिर भी एक पूरी तरह से मान्य पूर्णांक है और pandas इसे उसी रूप में मानता है। `''` थोड़ा अधिक सूक्ष्म है। हमने इसे सेक्शन 1 में एक खाली स्ट्रिंग मान को दर्शाने के लिए उपयोग किया था, लेकिन pandas के दृष्टिकोण से यह फिर भी एक स्ट्रिंग ऑब्जेक्ट है और इसे null का प्रतिनिधित्व नहीं माना जाता।\n",
"\n",
"अब, इसे उलटते हैं और इन विधियों का उपयोग उस तरीके से करते हैं जैसा आप इन्हें व्यावहारिक रूप से उपयोग करेंगे। आप Boolean मास्क को सीधे ``Series`` या ``DataFrame`` इंडेक्स के रूप में उपयोग कर सकते हैं, जो तब उपयोगी हो सकता है जब आप अलग-अलग गायब (या मौजूद) मानों के साथ काम करने की कोशिश कर रहे हों।\n",
"\n",
"यदि हमें गायब मानों की कुल संख्या चाहिए, तो हम बस `isnull()` विधि द्वारा उत्पन्न मास्क पर एक sum कर सकते हैं।\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "JCcQVoPkHDUv",
"outputId": "001daa72-54f8-4bd5-842a-4df627a79d4d"
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3.isnull().sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PlBqEo3mgRsC"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": true,
"id": "ggDVf5uygRsD",
"trusted": false
},
"outputs": [],
"source": [
"# Try running example3[example3.notnull()].\n",
"# Before you do so, what do you expect to see?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D_jWN7mHgRsD"
},
"source": [
"**मुख्य निष्कर्ष**: `isnull()` और `notnull()` दोनों विधियाँ समान परिणाम उत्पन्न करती हैं जब आप उन्हें डेटा फ्रेम में उपयोग करते हैं: वे परिणाम और उन परिणामों के इंडेक्स दिखाती हैं, जो आपके डेटा के साथ काम करते समय आपको बहुत मदद करेंगे।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BvnoojWsgRr4"
},
"source": [
"### डेटा की कमी से निपटना\n",
"\n",
"> **लक्ष्य:** इस अनुभाग के अंत तक, आप जान जाएंगे कि DataFrames से null मानों को कब और कैसे बदलना या हटाना है।\n",
"\n",
"मशीन लर्निंग मॉडल स्वयं डेटा की कमी को संभाल नहीं सकते। इसलिए, मॉडल में डेटा पास करने से पहले, हमें इन गायब मानों से निपटना होगा।\n",
"\n",
"गायब डेटा को संभालने का तरीका सूक्ष्म समझौतों के साथ आता है, और यह आपके अंतिम विश्लेषण और वास्तविक दुनिया के परिणामों को प्रभावित कर सकता है।\n",
"\n",
"गायब डेटा से निपटने के मुख्यतः दो तरीके हैं:\n",
"\n",
"1. उस पंक्ति को हटा दें जिसमें गायब मान है\n",
"2. गायब मान को किसी अन्य मान से बदल दें\n",
"\n",
"हम इन दोनों तरीकों और उनके फायदे और नुकसान को विस्तार से चर्चा करेंगे।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3VaYC1TvgRsD"
},
"source": [
"### null मानों को हटाना\n",
"\n",
"हमारे मॉडल को दी जाने वाली डेटा की मात्रा उसके प्रदर्शन पर सीधे प्रभाव डालती है। null मानों को हटाने का मतलब है कि हम डेटा पॉइंट्स की संख्या कम कर रहे हैं, और इस प्रकार डेटासेट का आकार भी घटा रहे हैं। इसलिए, जब डेटासेट काफी बड़ा हो, तो null मानों वाली पंक्तियों को हटाना उचित होता है।\n",
"\n",
"एक और स्थिति हो सकती है जब किसी विशेष पंक्ति या कॉलम में बहुत सारे missing values हों। ऐसे में उन्हें हटाया जा सकता है क्योंकि वे हमारे विश्लेषण में ज्यादा मूल्य नहीं जोड़ेंगे, क्योंकि उस पंक्ति/कॉलम के अधिकांश डेटा गायब हैं।\n",
"\n",
"missing values की पहचान करने के अलावा, pandas null मानों को `Series` और `DataFrame`s से हटाने का एक सुविधाजनक तरीका प्रदान करता है। इसे क्रियान्वित होते हुए देखने के लिए, चलिए `example3` पर वापस चलते हैं। `DataFrame.dropna()` फ़ंक्शन null मानों वाली पंक्तियों को हटाने में मदद करता है।\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "7uIvS097gRsD",
"outputId": "c13fc117-4ca1-4145-a0aa-42ac89e6e218",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 0\n",
"2 \n",
"dtype: object"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3 = example3.dropna()\n",
"example3"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hil2cr64gRsD"
},
"source": [
"ध्यान दें कि यह आपके `example3[example3.notnull()]` के आउटपुट जैसा दिखना चाहिए। यहाँ अंतर यह है कि, केवल मास्क किए गए मानों पर इंडेक्सिंग करने के बजाय, `dropna` ने `Series` `example3` से उन गायब मानों को हटा दिया है।\n",
"\n",
"क्योंकि DataFrames दो आयामों वाले होते हैं, वे डेटा को हटाने के लिए अधिक विकल्प प्रदान करते हैं।\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "an-l74sPgRsE",
"outputId": "340876a0-63ad-40f6-bd54-6240cdae50ab",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1.0 NaN 7\n",
"1 2.0 5.0 8\n",
"2 NaN 6.0 9"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4 = pd.DataFrame([[1, np.nan, 7], \n",
" [2, 5, 8], \n",
" [np.nan, 6, 9]])\n",
"example4"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "66wwdHZrgRsE"
},
"source": [
"(क्या आपने देखा कि pandas ने `NaN`s को समायोजित करने के लिए दो कॉलम को फ्लोट्स में अपकास्ट कर दिया?)\n",
"\n",
"आप `DataFrame` से एकल मान को हटा नहीं सकते, इसलिए आपको पूरी पंक्तियाँ या कॉलम हटाने होंगे। जो आप कर रहे हैं उसके आधार पर, आप इनमें से किसी एक को चुन सकते हैं, और इसलिए pandas आपको दोनों विकल्प देता है। क्योंकि डेटा विज्ञान में, कॉलम आमतौर पर चर का प्रतिनिधित्व करते हैं और पंक्तियाँ अवलोकन का, आप अधिक संभावना रखते हैं कि डेटा की पंक्तियाँ हटाएँ; `dropna()` के लिए डिफ़ॉल्ट सेटिंग यह है कि वह सभी पंक्तियाँ हटा देता है जिनमें कोई भी null मान होता है:\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 80
},
"id": "jAVU24RXgRsE",
"outputId": "0b5e5aee-7187-4d3f-b583-a44136ae5f80",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"1 2.0 5.0 8"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TrQRBuTDgRsE"
},
"source": [
"यदि आवश्यक हो, तो आप कॉलम से NA मानों को हटा सकते हैं। ऐसा करने के लिए `axis=1` का उपयोग करें:\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "GrBhxu9GgRsE",
"outputId": "ff4001f3-2e61-4509-d60e-0093d1068437",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>8</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 2\n",
"0 7\n",
"1 8\n",
"2 9"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna(axis='columns')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "KWXiKTfMgRsF"
},
"source": [
"ध्यान दें कि यह बहुत सारे डेटा को हटा सकता है जिसे आप रखना चाह सकते हैं, खासकर छोटे डेटा सेट में। अगर आप केवल उन पंक्तियों या स्तंभों को हटाना चाहते हैं जिनमें कई या सभी null मान हैं, तो आप `dropna` में `how` और `thresh` पैरामीटर सेट कर सकते हैं।\n",
"\n",
"डिफ़ॉल्ट रूप से, `how='any'` होता है (यदि आप इसे स्वयं जांचना चाहते हैं या देखना चाहते हैं कि इस विधि में अन्य कौन-कौन से पैरामीटर हैं, तो एक कोड सेल में `example4.dropna?` चलाएं)। आप वैकल्पिक रूप से `how='all'` निर्दिष्ट कर सकते हैं ताकि केवल उन पंक्तियों या स्तंभों को हटाया जाए जिनमें सभी null मान हों। चलिए हमारे उदाहरण `DataFrame` को अगले अभ्यास में विस्तार से देखते हैं ताकि इसे क्रियान्वित होते हुए देख सकें।\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "Bcf_JWTsgRsF",
"outputId": "72e0b1b8-52fa-4923-98ce-b6fbed6e44b1",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 NaN 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 NaN 6.0 9 NaN"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4[3] = np.nan\n",
"example4"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pNZer7q9JPNC"
},
"source": [
"> मुख्य बातें:\n",
"1. केवल तभी null मानों को हटाना अच्छा विचार है जब डेटा सेट पर्याप्त बड़ा हो।\n",
"2. पूरी पंक्तियाँ या स्तंभ हटाए जा सकते हैं यदि उनमें अधिकांश डेटा गायब हो।\n",
"3. `DataFrame.dropna(axis=)` विधि null मानों को हटाने में मदद करती है। `axis` तर्क यह दर्शाता है कि पंक्तियाँ हटाई जाएँगी या स्तंभ।\n",
"4. `how` तर्क का भी उपयोग किया जा सकता है। डिफ़ॉल्ट रूप से इसे `any` पर सेट किया गया है। इसलिए, यह केवल उन पंक्तियों/स्तंभों को हटाता है जिनमें कोई भी null मान हो। इसे `all` पर सेट किया जा सकता है ताकि केवल उन पंक्तियों/स्तंभों को हटाया जाए जहाँ सभी मान null हों।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oXXSfQFHgRsF"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": true,
"id": "ExUwQRxpgRsF",
"trusted": false
},
"outputs": [],
"source": [
"# How might you go about dropping just column 3?\n",
"# Hint: remember that you will need to supply both the axis parameter and the how parameter.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "38kwAihWgRsG"
},
"source": [
"`thresh` पैरामीटर आपको अधिक सूक्ष्म नियंत्रण देता है: आप यह निर्धारित करते हैं कि किसी पंक्ति या स्तंभ में *गैर-शून्य* मानों की संख्या कितनी होनी चाहिए ताकि उसे बनाए रखा जा सके:\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 80
},
"id": "M9dCNMaagRsG",
"outputId": "8093713a-54d2-4e54-c73f-4eea315cb6f2",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"1 2.0 5.0 8 NaN"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna(axis='rows', thresh=3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fmSFnzZegRsG"
},
"source": [
"यहाँ, पहली और आखिरी पंक्ति को हटा दिया गया है, क्योंकि उनमें केवल दो गैर-शून्य मान हैं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mCcxLGyUgRsG"
},
"source": [
"### खाली मानों को भरना\n",
"\n",
"कभी-कभी यह समझदारी होती है कि गायब मानों को ऐसे मानों से भरा जाए जो वैध हो सकते हैं। खाली मानों को भरने के लिए कुछ तकनीकें हैं। पहली तकनीक है डोमेन ज्ञान (डेटासेट जिस विषय पर आधारित है उसका ज्ञान) का उपयोग करके किसी तरह से गायब मानों का अनुमान लगाना।\n",
"\n",
"आप `isnull` का उपयोग करके इसे सीधे कर सकते हैं, लेकिन यह थकाऊ हो सकता है, खासकर जब आपके पास भरने के लिए बहुत सारे मान हों। चूंकि यह डेटा विज्ञान में एक सामान्य कार्य है, pandas `fillna` प्रदान करता है, जो `Series` या `DataFrame` की एक कॉपी लौटाता है जिसमें गायब मानों को आपके द्वारा चुने गए मानों से बदल दिया गया है। चलिए एक और उदाहरण `Series` बनाते हैं ताकि देख सकें कि यह व्यवहार में कैसे काम करता है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CE8S7louLezV"
},
"source": [
"### श्रेणीबद्ध डेटा (गैर-संख्या)\n",
"पहले हम गैर-संख्या डेटा पर विचार करते हैं। डेटा सेट्स में, हमारे पास श्रेणीबद्ध डेटा वाले कॉलम होते हैं। जैसे, लिंग, सत्य या असत्य आदि।\n",
"\n",
"इनमें से अधिकांश मामलों में, हम गायब मानों को कॉलम के `mode` से बदलते हैं। मान लीजिए, हमारे पास 100 डेटा पॉइंट्स हैं, जिनमें से 90 ने सत्य कहा है, 8 ने असत्य कहा है और 2 ने कुछ नहीं भरा है। तो, हम उन 2 को सत्य से भर सकते हैं, पूरे कॉलम को ध्यान में रखते हुए।\n",
"\n",
"फिर से, यहां हम डोमेन ज्ञान का उपयोग कर सकते हैं। चलिए `mode` से भरने का एक उदाहरण देखते हैं।\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "MY5faq4yLdpQ",
"outputId": "19ab472e-1eed-4de8-f8a7-db2a3af3cb1a"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>None</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 None\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode = pd.DataFrame([[1,2,\"True\"],\n",
" [3,4,None],\n",
" [5,6,\"False\"],\n",
" [7,8,\"True\"],\n",
" [9,10,\"True\"]])\n",
"\n",
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MLAoMQOfNPlA"
},
"source": [
"अब, पहले मोड ढूंढते हैं इससे पहले कि `None` मान को मोड से भरें।\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "WKy-9Y2tN5jv",
"outputId": "8da9fa16-e08c-447e-dea1-d4b1db2feebf"
},
"outputs": [
{
"data": {
"text/plain": [
"True 3\n",
"False 1\n",
"Name: 2, dtype: int64"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode[2].value_counts()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6iNz_zG_OKrx"
},
"source": [
"तो, हम None को True से बदल देंगे\n"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"id": "TxPKteRvNPOs"
},
"outputs": [],
"source": [
"fill_with_mode[2].fillna('True',inplace=True)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "tvas7c9_OPWE",
"outputId": "ec3c8e44-d644-475e-9e22-c65101965850"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 True\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "SktitLxxOR16"
},
"source": [
"जैसा कि हम देख सकते हैं, null मान को बदल दिया गया है। यह कहने की आवश्यकता नहीं है कि हम `'True'` के स्थान पर कुछ भी लिख सकते थे और वह प्रतिस्थापित हो जाता।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "heYe1I0dOmQ_"
},
"source": [
"### संख्यात्मक डेटा\n",
"अब, संख्यात्मक डेटा की बात करते हैं। यहां, गायब मानों को भरने के दो सामान्य तरीके हैं:\n",
"\n",
"1. पंक्ति के माध्यिका (Median) से भरें \n",
"2. पंक्ति के औसत (Mean) से भरें \n",
"\n",
"हम माध्यिका का उपयोग करते हैं, जब डेटा में असंतुलन और बाहरी मान (outliers) होते हैं। इसका कारण यह है कि माध्यिका बाहरी मानों के प्रति संवेदनशील नहीं होती है।\n",
"\n",
"जब डेटा सामान्यीकृत (normalized) होता है, तो हम औसत का उपयोग कर सकते हैं, क्योंकि उस स्थिति में औसत और माध्यिका लगभग समान होते हैं।\n",
"\n",
"पहले, आइए एक ऐसा कॉलम लें जो सामान्य वितरण (normally distributed) में हो और उसमें गायब मान को कॉलम के औसत से भरें।\n"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "09HM_2feOj5Y",
"outputId": "7e309013-9acb-411c-9b06-4de795bbeeff"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2.0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1.0</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1.0</td>\n",
" <td>6</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2.0</td>\n",
" <td>8</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2.0 0 1\n",
"1 -1.0 2 3\n",
"2 NaN 4 5\n",
"3 1.0 6 7\n",
"4 2.0 8 9"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mean = pd.DataFrame([[-2,0,1],\n",
" [-1,2,3],\n",
" [np.nan,4,5],\n",
" [1,6,7],\n",
" [2,8,9]])\n",
"\n",
"fill_with_mean"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ka7-wNfzSxbx"
},
"source": [
"स्तंभ का औसत है\n"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "XYtYEf5BSxFL",
"outputId": "68a78d18-f0e5-4a9a-a959-2c3676a57c70"
},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.mean(fill_with_mean[0])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oBSRGxKRS39K"
},
"source": [
"औसत से भरना\n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "FzncQLmuS5jh",
"outputId": "00f74fff-01f4-4024-c261-796f50f01d2e"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2.0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1.0</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0.0</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1.0</td>\n",
" <td>6</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2.0</td>\n",
" <td>8</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2.0 0 1\n",
"1 -1.0 2 3\n",
"2 0.0 4 5\n",
"3 1.0 6 7\n",
"4 2.0 8 9"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mean[0].fillna(np.mean(fill_with_mean[0]),inplace=True)\n",
"fill_with_mean"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CwpVFCrPTC5z"
},
"source": [
"जैसा कि हम देख सकते हैं, गायब मान को उसके औसत से बदल दिया गया है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "jIvF13a1i00Z"
},
"source": [
"अब आइए एक और डेटा फ्रेम आज़माते हैं, और इस बार हम None मानों को कॉलम के माध्यिका से बदलेंगे।\n"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "DA59Bqo3jBYZ",
"outputId": "85dae6ec-7394-4c36-fda0-e04769ec4a32"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2</td>\n",
" <td>0.0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1</td>\n",
" <td>2.0</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0</td>\n",
" <td>NaN</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1</td>\n",
" <td>6.0</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2</td>\n",
" <td>8.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2 0.0 1\n",
"1 -1 2.0 3\n",
"2 0 NaN 5\n",
"3 1 6.0 7\n",
"4 2 8.0 9"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median = pd.DataFrame([[-2,0,1],\n",
" [-1,2,3],\n",
" [0,np.nan,5],\n",
" [1,6,7],\n",
" [2,8,9]])\n",
"\n",
"fill_with_median"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mM1GpXYmjHnc"
},
"source": [
"दूसरे स्तंभ का माध्यक है\n"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "uiDy5v3xjHHX",
"outputId": "564b6b74-2004-4486-90d4-b39330a64b88"
},
"outputs": [
{
"data": {
"text/plain": [
"4.0"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median[1].median()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "z9PLF75Jj_1s"
},
"source": [
"मध्यिका से भरना\n"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "lFKbOxCMkBbg",
"outputId": "a8bd18fb-2765-47d4-e5fe-e965f57ed1f4"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2</td>\n",
" <td>0.0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1</td>\n",
" <td>2.0</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0</td>\n",
" <td>4.0</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1</td>\n",
" <td>6.0</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2</td>\n",
" <td>8.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2 0.0 1\n",
"1 -1 2.0 3\n",
"2 0 4.0 5\n",
"3 1 6.0 7\n",
"4 2 8.0 9"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median[1].fillna(fill_with_median[1].median(),inplace=True)\n",
"fill_with_median"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8JtQ53GSkKWC"
},
"source": [
"जैसा कि हम देख सकते हैं, NaN मान को कॉलम के माध्यिका से बदल दिया गया है।\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "0ybtWLDdgRsG",
"outputId": "b8c238ef-6024-4ee2-be2b-aa1f0fcac61d",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b NaN\n",
"c 2.0\n",
"d NaN\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n",
"example5"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "yrsigxRggRsH"
},
"source": [
"आप सभी रिक्त प्रविष्टियों को एक ही मान, जैसे `0`, से भर सकते हैं:\n"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "KXMIPsQdgRsH",
"outputId": "aeedfa0a-a421-4c2f-cb0d-183ce8f0c91d",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 0.0\n",
"c 2.0\n",
"d 0.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "RRlI5f_hkfKe"
},
"source": [
"> मुख्य बातें:\n",
"1. गायब मानों को भरना तब किया जाना चाहिए जब डेटा कम हो या गायब डेटा को भरने की कोई रणनीति हो।\n",
"2. डोमेन ज्ञान का उपयोग करके गायब मानों को अनुमानित करके भरा जा सकता है।\n",
"3. श्रेणीबद्ध डेटा के लिए, आमतौर पर गायब मानों को कॉलम के मोड से प्रतिस्थापित किया जाता है।\n",
"4. संख्यात्मक डेटा के लिए, गायब मानों को आमतौर पर कॉलम के औसत (सामान्यीकृत डेटासेट के लिए) या माध्यिका से भरा जाता है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FI9MmqFJgRsH"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": true,
"id": "af-ezpXdgRsH",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you try to fill null values with a string, like ''?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kq3hw1kLgRsI"
},
"source": [
"आप null मानों को **forward-fill** कर सकते हैं, जिसका अर्थ है अंतिम मान्य मान का उपयोग करके null को भरना:\n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "vO3BuNrggRsI",
"outputId": "e2bc591b-0b48-4e88-ee65-754f2737c196",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 1.0\n",
"c 2.0\n",
"d 2.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(method='ffill')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nDXeYuHzgRsI"
},
"source": [
"आप अगले मान्य मान को पीछे की ओर फैलाने के लिए **बैक-फिल** भी कर सकते हैं ताकि एक शून्य को भर सकें:\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "4M5onHcEgRsI",
"outputId": "8f32b185-40dd-4a9f-bd85-54d6b6a414fe",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 2.0\n",
"c 2.0\n",
"d 3.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(method='bfill')"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"id": "MbBzTom5gRsI"
},
"source": [
"जैसा कि आप अनुमान लगा सकते हैं, यह DataFrames के साथ भी उसी तरह काम करता है, लेकिन आप null मानों को भरने के लिए एक `axis` भी निर्दिष्ट कर सकते हैं:\n"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "aRpIvo4ZgRsI",
"outputId": "905a980a-a808-4eca-d0ba-224bd7d85955",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 NaN 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 NaN 6.0 9 NaN"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "VM1qtACAgRsI",
"outputId": "71f2ad28-9b4e-4ff4-f5c3-e731eb489ade",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>1.0</td>\n",
" <td>7.0</td>\n",
" <td>7.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8.0</td>\n",
" <td>8.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9.0</td>\n",
" <td>9.0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 1.0 7.0 7.0\n",
"1 2.0 5.0 8.0 8.0\n",
"2 NaN 6.0 9.0 9.0"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.fillna(method='ffill', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ZeMc-I1EgRsI"
},
"source": [
"ध्यान दें कि जब पिछले मान आगे भरने के लिए उपलब्ध नहीं होता है, तो शून्य मान बना रहता है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eeAoOU0RgRsJ"
},
"source": [
"### व्यायाम:\n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": true,
"id": "e8S-CjW8gRsJ",
"trusted": false
},
"outputs": [],
"source": [
"# What output does example4.fillna(method='bfill', axis=1) produce?\n",
"# What about example4.fillna(method='ffill') or example4.fillna(method='bfill')?\n",
"# Can you think of a longer code snippet to write that can fill all of the null values in example4?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "YHgy0lIrgRsJ"
},
"source": [
"आप `fillna` का उपयोग करने के तरीके के बारे में रचनात्मक हो सकते हैं। उदाहरण के लिए, चलिए फिर से `example4` को देखते हैं, लेकिन इस बार चलिए `DataFrame` में सभी मानों के औसत से गायब मानों को भरते हैं:\n"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "OtYVErEygRsJ",
"outputId": "708b1e67-45ca-44bf-a5ee-8b2de09ece73",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>5.5</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>1.5</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 5.5 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 1.5 6.0 9 NaN"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.fillna(example4.mean())"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zpMvCkLSgRsJ"
},
"source": [
"ध्यान दें कि कॉलम 3 अभी भी खाली है: डिफ़ॉल्ट दिशा पंक्तियों के अनुसार मान भरने की है।\n",
"\n",
"> **मुख्य बात:** आपके डेटा सेट में गायब मानों को संभालने के कई तरीके हैं। आप जो विशेष रणनीति अपनाते हैं (उन्हें हटाना, बदलना, या यहां तक कि कैसे बदलना है) वह उस डेटा की विशेषताओं पर निर्भर होनी चाहिए। जैसे-जैसे आप अधिक डेटा सेट के साथ काम करेंगे और उनका विश्लेषण करेंगे, गायब मानों को संभालने का बेहतर तरीका समझ में आएगा।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bauDnESIl9FH"
},
"source": [
"### श्रेणीबद्ध डेटा को एन्कोड करना\n",
"\n",
"मशीन लर्निंग मॉडल केवल संख्याओं और किसी भी प्रकार के संख्यात्मक डेटा के साथ काम करते हैं। यह Yes और No के बीच का अंतर नहीं समझ पाएगा, लेकिन यह 0 और 1 के बीच का अंतर पहचान सकता है। इसलिए, गायब मानों को भरने के बाद, हमें श्रेणीबद्ध डेटा को किसी संख्यात्मक रूप में एन्कोड करना होगा ताकि मॉडल इसे समझ सके।\n",
"\n",
"एन्कोडिंग दो तरीकों से की जा सकती है। हम अगले भाग में इन तरीकों पर चर्चा करेंगे।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "uDq9SxB7mu5i"
},
"source": [
"**लेबल एन्कोडिंग**\n",
"\n",
"लेबल एन्कोडिंग मूल रूप से प्रत्येक श्रेणी को एक संख्या में बदलने की प्रक्रिया है। उदाहरण के लिए, मान लीजिए हमारे पास एयरलाइन यात्रियों का एक डेटासेट है और उसमें एक कॉलम है जिसमें उनकी श्रेणी ['बिजनेस क्लास', 'इकोनॉमी क्लास', 'फर्स्ट क्लास'] दी गई है। यदि इस पर लेबल एन्कोडिंग की जाती है, तो इसे [0,1,2] में परिवर्तित किया जाएगा। आइए इसे कोड के माध्यम से एक उदाहरण के रूप में देखें। चूंकि हम आगामी नोटबुक्स में `scikit-learn` सीखने वाले हैं, इसलिए हम इसे यहां उपयोग नहीं करेंगे।\n"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "1vGz7uZyoWHL",
"outputId": "9e252855-d193-4103-a54d-028ea7787b34"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>first class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 business class\n",
"1 20 first class\n",
"2 30 economy class\n",
"3 40 economy class\n",
"4 50 economy class\n",
"5 60 business class"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"label = pd.DataFrame([\n",
" [10,'business class'],\n",
" [20,'first class'],\n",
" [30, 'economy class'],\n",
" [40, 'economy class'],\n",
" [50, 'economy class'],\n",
" [60, 'business class']\n",
"],columns=['ID','class'])\n",
"label"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IDHnkwTYov-h"
},
"source": [
"पहले कॉलम पर लेबल एन्कोडिंग करने के लिए, हमें पहले प्रत्येक वर्ग से एक संख्या तक का मैपिंग वर्णित करना होगा, उसके बाद उसे बदलना होगा।\n"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "ZC5URJG3o1ES",
"outputId": "aab0f1e7-e0f3-4c14-8459-9f9168c85437"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 0\n",
"1 20 2\n",
"2 30 1\n",
"3 40 1\n",
"4 50 1\n",
"5 60 0"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"class_labels = {'business class':0,'economy class':1,'first class':2}\n",
"label['class'] = label['class'].replace(class_labels)\n",
"label"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ftnF-TyapOPt"
},
"source": [
"जैसा कि हम देख सकते हैं, आउटपुट वही है जो हमने सोचा था कि होगा। तो, लेबल एन्कोडिंग का उपयोग कब किया जाता है? लेबल एन्कोडिंग का उपयोग निम्नलिखित में से किसी एक या दोनों मामलों में किया जाता है:\n",
"1. जब श्रेणियों की संख्या अधिक हो\n",
"2. जब श्रेणियां क्रम में हों।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eQPAPVwsqWT7"
},
"source": [
"**वन हॉट एनकोडिंग**\n",
"\n",
"एनकोडिंग का एक और प्रकार वन हॉट एनकोडिंग है। इस प्रकार की एनकोडिंग में, कॉलम की प्रत्येक श्रेणी को एक अलग कॉलम के रूप में जोड़ा जाता है और प्रत्येक डेटा पॉइंट को 0 या 1 मिलता है, इस आधार पर कि उसमें वह श्रेणी है या नहीं। तो, यदि n अलग-अलग श्रेणियां हैं, तो n कॉलम डेटा फ्रेम में जोड़े जाएंगे।\n",
"\n",
"उदाहरण के लिए, चलिए वही हवाई जहाज वर्ग का उदाहरण लेते हैं। श्रेणियां थीं: ['बिजनेस क्लास', 'इकोनॉमी क्लास', 'फर्स्ट क्लास']। तो, यदि हम वन हॉट एनकोडिंग करते हैं, तो निम्नलिखित तीन कॉलम डेटासेट में जोड़े जाएंगे: ['class_business class', 'class_economy class', 'class_first class']।\n"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "ZM0eVh0ArKUL",
"outputId": "83238a76-b3a5-418d-c0b6-605b02b6891b"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>first class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 business class\n",
"1 20 first class\n",
"2 30 economy class\n",
"3 40 economy class\n",
"4 50 economy class\n",
"5 60 business class"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_hot = pd.DataFrame([\n",
" [10,'business class'],\n",
" [20,'first class'],\n",
" [30, 'economy class'],\n",
" [40, 'economy class'],\n",
" [50, 'economy class'],\n",
" [60, 'business class']\n",
"],columns=['ID','class'])\n",
"one_hot"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "aVnZ7paDrWmb"
},
"source": [
"आइए हम पहली स्तंभ पर वन हॉट एनकोडिंग करें।\n"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"id": "RUPxf7egrYKr"
},
"outputs": [],
"source": [
"one_hot_data = pd.get_dummies(one_hot,columns=['class'])"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "TM37pHsFr4ge",
"outputId": "7be15f53-79b2-447a-979c-822658339a9e"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class_business class</th>\n",
" <th>class_economy class</th>\n",
" <th>class_first class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class_business class class_economy class class_first class\n",
"0 10 1 0 0\n",
"1 20 0 0 1\n",
"2 30 0 1 0\n",
"3 40 0 1 0\n",
"4 50 0 1 0\n",
"5 60 1 0 0"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_hot_data"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_zXRLOjXujdA"
},
"source": [
"प्रत्येक वन-हॉट एन्कोडेड कॉलम में 0 या 1 होता है, जो यह निर्दिष्ट करता है कि उस डेटा पॉइंट के लिए वह श्रेणी मौजूद है या नहीं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bDnC4NQOu0qr"
},
"source": [
"हम वन हॉट एनकोडिंग का उपयोग कब करते हैं? वन हॉट एनकोडिंग का उपयोग निम्नलिखित में से किसी एक या दोनों स्थितियों में किया जाता है:\n",
"\n",
"1. जब श्रेणियों की संख्या और डेटा सेट का आकार छोटा हो।\n",
"2. जब श्रेणियों का कोई विशेष क्रम न हो।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XnUmci_4uvyu"
},
"source": [
"> मुख्य बातें:\n",
"1. एनकोडिंग का उपयोग गैर-संख्या डेटा को संख्या डेटा में बदलने के लिए किया जाता है।\n",
"2. एनकोडिंग के दो प्रकार होते हैं: लेबल एनकोडिंग और वन हॉट एनकोडिंग, जिन्हें डेटा सेट की आवश्यकताओं के अनुसार किया जा सकता है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "K8UXOJYRgRsJ"
},
"source": [
"## डुप्लिकेट डेटा हटाना\n",
"\n",
"> **लक्ष्य:** इस उपखंड के अंत तक, आप DataFrames से डुप्लिकेट मानों की पहचान करने और उन्हें हटाने में सहज हो जाएंगे।\n",
"\n",
"गायब डेटा के अलावा, वास्तविक दुनिया के डेटा सेट में अक्सर डुप्लिकेट डेटा का सामना करना पड़ता है। सौभाग्य से, pandas डुप्लिकेट प्रविष्टियों का पता लगाने और उन्हें हटाने का एक आसान तरीका प्रदान करता है।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qrEG-Wa0gRsJ"
},
"source": [
"### डुप्लीकेट पहचानना: `duplicated`\n",
"\n",
"आप pandas में `duplicated` मेथड का उपयोग करके आसानी से डुप्लीकेट मानों को पहचान सकते हैं। यह एक Boolean मास्क लौटाता है जो यह दर्शाता है कि `DataFrame` में कोई प्रविष्टि पहले की प्रविष्टि का डुप्लीकेट है या नहीं। आइए इसे क्रियान्वित करने के लिए एक और उदाहरण `DataFrame` बनाते हैं।\n"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "ZLu6FEnZgRsJ",
"outputId": "376512d1-d842-4db1-aea3-71052aeeecaf",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2\n",
"2 A 1\n",
"3 B 3\n",
"4 B 3"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],\n",
" 'numbers': [1, 2, 1, 3, 3]})\n",
"example6"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "cIduB5oBgRsK",
"outputId": "3da27b3d-4d69-4e1d-bb52-0af21bae87f2",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 False\n",
"1 False\n",
"2 True\n",
"3 False\n",
"4 True\n",
"dtype: bool"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.duplicated()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0eDRJD4SgRsK"
},
"source": [
"### डुप्लिकेट हटाना: `drop_duplicates`\n",
"`drop_duplicates` केवल डेटा की एक कॉपी लौटाता है, जिसमें सभी `duplicated` मान `False` होते हैं:\n"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "w_YPpqIqgRsK",
"outputId": "ac66bd2f-8671-4744-87f5-8b8d96553dea",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2\n",
"3 B 3"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.drop_duplicates()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "69AqoCZAgRsK"
},
"source": [
"`duplicated` और `drop_duplicates` डिफ़ॉल्ट रूप से सभी कॉलमों पर विचार करते हैं लेकिन आप निर्दिष्ट कर सकते हैं कि वे आपके `DataFrame` में केवल कॉलमों के एक उपसमूह की जांच करें:\n"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 111
},
"id": "BILjDs67gRsK",
"outputId": "ef6dcc08-db8b-4352-c44e-5aa9e2bec0d3",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.drop_duplicates(['letters'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "GvX4og1EgRsL"
},
"source": [
"> **निष्कर्ष:** डुप्लिकेट डेटा को हटाना लगभग हर डेटा-साइंस प्रोजेक्ट का एक आवश्यक हिस्सा है। डुप्लिकेट डेटा आपके विश्लेषण के परिणामों को बदल सकता है और आपको गलत परिणाम दे सकता है!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## वास्तविक दुनिया में डेटा गुणवत्ता जांच\n",
"\n",
"> **लक्ष्य:** इस अनुभाग के अंत तक, आप सामान्य वास्तविक दुनिया के डेटा गुणवत्ता मुद्दों का पता लगाने और उन्हें सुधारने में सहज महसूस करेंगे, जिनमें असंगत श्रेणी मान, असामान्य संख्यात्मक मान (आउटलायर), और हल्के बदलावों के साथ डुप्लिकेट संस्थाएं शामिल हैं।\n",
"\n",
"हालांकि गायब मान और सटीक डुप्लिकेट आम समस्याएं हैं, वास्तविक दुनिया के डेटा सेट में अक्सर अधिक सूक्ष्म समस्याएं होती हैं:\n",
"\n",
"1. **असंगत श्रेणी मान**: एक ही श्रेणी का अलग-अलग तरीके से लिखा जाना (जैसे, \"USA\", \"U.S.A\", \"United States\")\n",
"2. **असामान्य संख्यात्मक मान**: अत्यधिक आउटलायर जो डेटा प्रविष्टि त्रुटियों को दर्शाते हैं (जैसे, उम्र = 999)\n",
"3. **निकट-डुप्लिकेट पंक्तियां**: रिकॉर्ड जो हल्के बदलावों के साथ एक ही इकाई का प्रतिनिधित्व करते हैं\n",
"\n",
"आइए इन समस्याओं का पता लगाने और उन्हें संभालने की तकनीकों का अन्वेषण करें।\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### एक नमूना \"गंदा\" डेटा सेट बनाना\n",
"\n",
"सबसे पहले, चलिए एक नमूना डेटा सेट बनाते हैं जिसमें वे समस्याएं शामिल हों जो हम आमतौर पर वास्तविक दुनिया के डेटा में सामना करते हैं:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"# Create a sample dataset with quality issues\n",
"dirty_data = pd.DataFrame({\n",
" 'customer_id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n",
" 'name': ['John Smith', 'Jane Doe', 'John Smith', 'Bob Johnson', \n",
" 'Alice Williams', 'Charlie Brown', 'John Smith', 'Eva Martinez',\n",
" 'Bob Johnson', 'Diana Prince', 'Frank Castle', 'Alice Williams'],\n",
" 'age': [25, 32, 25, 45, 28, 199, 25, 31, 45, 27, -5, 28],\n",
" 'country': ['USA', 'UK', 'U.S.A', 'Canada', 'USA', 'United Kingdom',\n",
" 'United States', 'Mexico', 'canada', 'USA', 'UK', 'usa'],\n",
" 'purchase_amount': [100.50, 250.00, 105.00, 320.00, 180.00, 90.00,\n",
" 102.00, 275.00, 325.00, 195.00, 410.00, 185.00]\n",
"})\n",
"\n",
"print(\"Sample 'Dirty' Dataset:\")\n",
"print(dirty_data)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1. असंगत श्रेणीबद्ध मानों का पता लगाना\n",
"\n",
"ध्यान दें कि `country` कॉलम में एक ही देशों के लिए कई प्रतिनिधित्व हैं। आइए इन असंगतताओं की पहचान करें:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Check unique values in the country column\n",
"print(\"Unique country values:\")\n",
"print(dirty_data['country'].unique())\n",
"print(f\"\\nTotal unique values: {dirty_data['country'].nunique()}\")\n",
"\n",
"# Count occurrences of each variation\n",
"print(\"\\nValue counts:\")\n",
"print(dirty_data['country'].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### श्रेणीबद्ध मानों को मानकीकृत करना\n",
"\n",
"हम इन मानों को मानकीकृत करने के लिए एक मैपिंग बना सकते हैं। एक सरल तरीका है कि उन्हें छोटे अक्षरों में बदलें और एक मैपिंग डिक्शनरी बनाएं:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a standardization mapping\n",
"country_mapping = {\n",
" 'usa': 'USA',\n",
" 'u.s.a': 'USA',\n",
" 'united states': 'USA',\n",
" 'uk': 'UK',\n",
" 'united kingdom': 'UK',\n",
" 'canada': 'Canada',\n",
" 'mexico': 'Mexico'\n",
"}\n",
"\n",
"# Standardize the country column\n",
"dirty_data['country_clean'] = dirty_data['country'].str.lower().map(country_mapping)\n",
"\n",
"print(\"Before standardization:\")\n",
"print(dirty_data['country'].value_counts())\n",
"print(\"\\nAfter standardization:\")\n",
"print(dirty_data[['country_clean']].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**विकल्प: फजी मैचिंग का उपयोग करना**\n",
"\n",
"अधिक जटिल मामलों के लिए, हम `rapidfuzz` लाइब्रेरी का उपयोग करके फजी स्ट्रिंग मैचिंग का उपयोग कर सकते हैं ताकि समान स्ट्रिंग्स को स्वचालित रूप से पहचान सकें:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Please install it with 'pip install rapidfuzz' to use fuzzy matching.\")\n",
" process = None\n",
" fuzz = None\n",
"\n",
"# Get unique countries\n",
"unique_countries = dirty_data['country'].unique()\n",
"\n",
"# For each country, find similar matches\n",
"if process is not None and fuzz is not None:\n",
" print(\"Finding similar country names (similarity > 70%):\")\n",
" for country in unique_countries:\n",
" matches = process.extract(country, unique_countries, scorer=fuzz.ratio, limit=3)\n",
" # Filter matches with similarity > 70 and not identical\n",
" similar = [m for m in matches if m[1] > 70 and m[0] != country]\n",
" if similar:\n",
" print(f\"\\n'{country}' is similar to:\")\n",
" for match, score, _ in similar:\n",
" print(f\" - '{match}' (similarity: {score}%)\")\n",
"else:\n",
" print(\"Skipping fuzzy matching because rapidfuzz is not available.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. असामान्य संख्यात्मक मान (आउटलायर) का पता लगाना\n",
"\n",
"`age` कॉलम को देखते हुए, हमारे पास कुछ संदिग्ध मान हैं जैसे 199 और -5। चलिए इन आउटलायर का पता लगाने के लिए सांख्यिकीय विधियों का उपयोग करते हैं।\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Display basic statistics\n",
"print(\"Age column statistics:\")\n",
"print(dirty_data['age'].describe())\n",
"\n",
"# Identify impossible values using domain knowledge\n",
"print(\"\\nRows with impossible age values (< 0 or > 120):\")\n",
"impossible_ages = dirty_data[(dirty_data['age'] < 0) | (dirty_data['age'] > 120)]\n",
"print(impossible_ages[['customer_id', 'name', 'age']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### IQR (इंटरक्वारटाइल रेंज) विधि का उपयोग करना\n",
"\n",
"IQR विधि एक मजबूत सांख्यिकीय तकनीक है जो बाहरी मानों का पता लगाने के लिए उपयोग की जाती है और यह चरम मानों के प्रति कम संवेदनशील होती है:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Calculate IQR for age (excluding impossible values)\n",
"valid_ages = dirty_data[(dirty_data['age'] >= 0) & (dirty_data['age'] <= 120)]['age']\n",
"\n",
"Q1 = valid_ages.quantile(0.25)\n",
"Q3 = valid_ages.quantile(0.75)\n",
"IQR = Q3 - Q1\n",
"\n",
"# Define outlier bounds\n",
"lower_bound = Q1 - 1.5 * IQR\n",
"upper_bound = Q3 + 1.5 * IQR\n",
"\n",
"print(f\"IQR-based outlier bounds for age: [{lower_bound:.2f}, {upper_bound:.2f}]\")\n",
"\n",
"# Identify outliers\n",
"age_outliers = dirty_data[(dirty_data['age'] < lower_bound) | (dirty_data['age'] > upper_bound)]\n",
"print(f\"\\nRows with age outliers:\")\n",
"print(age_outliers[['customer_id', 'name', 'age']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Z-स्कोर विधि का उपयोग करना\n",
"\n",
"Z-स्कोर विधि औसत से मानक विचलन के आधार पर बाहरी मानों की पहचान करती है:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from scipy import stats\n",
"except ImportError:\n",
" print(\"scipy is required for Z-score calculation. Please install it with 'pip install scipy' and rerun this cell.\")\n",
"else:\n",
" # Calculate Z-scores for age, handling NaN values\n",
" age_nonan = dirty_data['age'].dropna()\n",
" zscores = np.abs(stats.zscore(age_nonan))\n",
" dirty_data['age_zscore'] = np.nan\n",
" dirty_data.loc[age_nonan.index, 'age_zscore'] = zscores\n",
"\n",
" # Typically, Z-score > 3 indicates an outlier\n",
" print(\"Rows with age Z-score > 3:\")\n",
" zscore_outliers = dirty_data[dirty_data['age_zscore'] > 3]\n",
" print(zscore_outliers[['customer_id', 'name', 'age', 'age_zscore']])\n",
"\n",
" # Clean up the temporary column\n",
" dirty_data = dirty_data.drop('age_zscore', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### आउटलायर्स का प्रबंधन\n",
"\n",
"एक बार पहचानने के बाद, आउटलायर्स को कई तरीकों से संभाला जा सकता है:\n",
"1. **हटाना**: आउटलायर्स वाली पंक्तियों को हटा दें (यदि वे त्रुटियां हैं)\n",
"2. **सीमित करना**: सीमा मानों से बदलें\n",
"3. **NaN से बदलें**: इसे गायब डेटा मानें और इम्प्यूटेशन तकनीकों का उपयोग करें\n",
"4. **रखें**: यदि वे वैध चरम मान हैं\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a cleaned version by replacing impossible ages with NaN\n",
"dirty_data['age_clean'] = dirty_data['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
")\n",
"\n",
"print(\"Age column before and after cleaning:\")\n",
"print(dirty_data[['customer_id', 'name', 'age', 'age_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3. निकट-डुप्लिकेट पंक्तियों का पता लगाना\n",
"\n",
"ध्यान दें कि हमारे डेटा सेट में \"John Smith\" के लिए कई प्रविष्टियाँ हैं जिनमें थोड़े अलग मान हैं। चलिए नाम की समानता के आधार पर संभावित डुप्लिकेट की पहचान करते हैं।\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# First, let's look at exact name matches (ignoring extra whitespace)\n",
"dirty_data['name_normalized'] = dirty_data['name'].str.strip().str.lower()\n",
"\n",
"print(\"Checking for duplicate names:\")\n",
"duplicate_names = dirty_data[dirty_data.duplicated(['name_normalized'], keep=False)]\n",
"print(duplicate_names.sort_values('name_normalized')[['customer_id', 'name', 'age', 'country']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### फजी मैचिंग के साथ निकट-डुप्लिकेट्स ढूंढना\n",
"\n",
"अधिक उन्नत डुप्लिकेट पहचान के लिए, हम समान नामों को ढूंढने के लिए फजी मैचिंग का उपयोग कर सकते हैं:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"\n",
" # Function to find potential duplicates\n",
" def find_near_duplicates(df, column, threshold=90):\n",
" \"\"\"\n",
" Find near-duplicate entries in a column using fuzzy matching.\n",
" \n",
" Parameters:\n",
" - df: DataFrame\n",
" - column: Column name to check for duplicates\n",
" - threshold: Similarity threshold (0-100)\n",
" \n",
" Returns: List of potential duplicate groups\n",
" \"\"\"\n",
" values = df[column].unique()\n",
" duplicate_groups = []\n",
" checked = set()\n",
" \n",
" for value in values:\n",
" if value in checked:\n",
" continue\n",
" \n",
" # Find similar values\n",
" matches = process.extract(value, values, scorer=fuzz.ratio, limit=len(values))\n",
" similar = [m[0] for m in matches if m[1] >= threshold]\n",
" \n",
" if len(similar) > 1:\n",
" duplicate_groups.append(similar)\n",
" checked.update(similar)\n",
" \n",
" return duplicate_groups\n",
"\n",
" # Find near-duplicate names\n",
" duplicate_groups = find_near_duplicates(dirty_data, 'name', threshold=90)\n",
"\n",
" print(\"Potential duplicate groups:\")\n",
" for i, group in enumerate(duplicate_groups, 1):\n",
" print(f\"\\nGroup {i}:\")\n",
" for name in group:\n",
" matching_rows = dirty_data[dirty_data['name'] == name]\n",
" print(f\" '{name}': {len(matching_rows)} occurrence(s)\")\n",
" for _, row in matching_rows.iterrows():\n",
" print(f\" - Customer {row['customer_id']}: age={row['age']}, country={row['country']}\")\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Skipping fuzzy matching for near-duplicates.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### डुप्लीकेट्स का प्रबंधन\n",
"\n",
"पहचानने के बाद, आपको तय करना होगा कि डुप्लीकेट्स को कैसे संभालना है:\n",
"1. **पहली घटना रखें**: `drop_duplicates(keep='first')` का उपयोग करें\n",
"2. **अंतिम घटना रखें**: `drop_duplicates(keep='last')` का उपयोग करें\n",
"3. **जानकारी को समेकित करें**: डुप्लीकेट पंक्तियों से जानकारी को मिलाएं\n",
"4. **मैन्युअल समीक्षा**: मानव समीक्षा के लिए चिह्नित करें\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Example: Remove duplicates based on normalized name, keeping first occurrence\n",
"cleaned_data = dirty_data.drop_duplicates(subset=['name_normalized'], keep='first')\n",
"\n",
"print(f\"Original dataset: {len(dirty_data)} rows\")\n",
"print(f\"After removing name duplicates: {len(cleaned_data)} rows\")\n",
"print(f\"Removed: {len(dirty_data) - len(cleaned_data)} duplicate rows\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(cleaned_data[['customer_id', 'name', 'age', 'country_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### सारांश: संपूर्ण डेटा सफाई पाइपलाइन\n",
"\n",
"आइए इसे एक व्यापक सफाई पाइपलाइन में एकत्रित करें:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def clean_dataset(df):\n",
" \"\"\"\n",
" Comprehensive data cleaning function.\n",
" \"\"\"\n",
" # Create a copy to avoid modifying the original\n",
" cleaned = df.copy()\n",
" \n",
" # 1. Standardize categorical values (country)\n",
" country_mapping = {\n",
" 'usa': 'USA', 'u.s.a': 'USA', 'united states': 'USA',\n",
" 'uk': 'UK', 'united kingdom': 'UK',\n",
" 'canada': 'Canada', 'mexico': 'Mexico'\n",
" }\n",
" cleaned['country'] = cleaned['country'].str.lower().map(country_mapping)\n",
" \n",
" # 2. Clean abnormal age values\n",
" cleaned['age'] = cleaned['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
" )\n",
" \n",
" # 3. Remove near-duplicate names (normalize whitespace)\n",
" cleaned['name'] = cleaned['name'].str.strip()\n",
" cleaned = cleaned.drop_duplicates(subset=['name'], keep='first')\n",
" \n",
" return cleaned\n",
"\n",
"# Apply the cleaning pipeline\n",
"final_cleaned_data = clean_dataset(dirty_data)\n",
"\n",
"print(\"Before cleaning:\")\n",
"print(f\" Rows: {len(dirty_data)}\")\n",
"print(f\" Unique countries: {dirty_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((dirty_data['age'] < 0) | (dirty_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nAfter cleaning:\")\n",
"print(f\" Rows: {len(final_cleaned_data)}\")\n",
"print(f\" Unique countries: {final_cleaned_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((final_cleaned_data['age'] < 0) | (final_cleaned_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(final_cleaned_data[['customer_id', 'name', 'age', 'country', 'purchase_amount']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 🎯 चुनौती अभ्यास\n",
"\n",
"अब आपकी बारी है! नीचे एक नई पंक्ति दी गई है जिसमें कई गुणवत्ता संबंधी समस्याएं हैं। क्या आप:\n",
"\n",
"1. इस पंक्ति में सभी समस्याओं की पहचान कर सकते हैं\n",
"2. प्रत्येक समस्या को ठीक करने के लिए कोड लिख सकते हैं\n",
"3. साफ की गई पंक्ति को डेटा सेट में जोड़ सकते हैं\n",
"\n",
"यहां समस्याग्रस्त डेटा है:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# New problematic row\n",
"new_row = pd.DataFrame({\n",
" 'customer_id': [13],\n",
" 'name': [' Diana Prince '], # Extra whitespace\n",
" 'age': [250], # Impossible age\n",
" 'country': ['U.S.A.'], # Inconsistent format\n",
" 'purchase_amount': [150.00]\n",
"})\n",
"\n",
"print(\"New row to clean:\")\n",
"print(new_row)\n",
"\n",
"# TODO: Your code here to clean this row\n",
"# Hints:\n",
"# 1. Strip whitespace from the name\n",
"# 2. Check if the name is a duplicate (Diana Prince already exists)\n",
"# 3. Handle the impossible age value\n",
"# 4. Standardize the country name\n",
"\n",
"# Example solution (uncomment and modify as needed):\n",
"# new_row_cleaned = new_row.copy()\n",
"# new_row_cleaned['name'] = new_row_cleaned['name'].str.strip()\n",
"# new_row_cleaned['age'] = np.nan # Invalid age\n",
"# new_row_cleaned['country'] = 'USA' # Standardized\n",
"# print(\"\\nCleaned row:\")\n",
"# print(new_row_cleaned)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### मुख्य बातें\n",
"\n",
"1. **असंगत श्रेणियां** वास्तविक दुनिया के डेटा में आम होती हैं। हमेशा अद्वितीय मानों की जांच करें और उन्हें मैपिंग या फजी मैचिंग का उपयोग करके मानकीकृत करें।\n",
"\n",
"2. **आउटलायर्स** आपके विश्लेषण को काफी प्रभावित कर सकते हैं। इन्हें पहचानने के लिए डोमेन ज्ञान के साथ सांख्यिकीय विधियों (IQR, Z-score) का उपयोग करें।\n",
"\n",
"3. **निकट-डुप्लिकेट्स** को पहचानना सटीक डुप्लिकेट्स की तुलना में कठिन होता है। इन्हें पहचानने के लिए फजी मैचिंग और डेटा को सामान्यीकृत करना (लोअरकेस करना, व्हाइटस्पेस हटाना) पर विचार करें।\n",
"\n",
"4. **डेटा सफाई एक पुनरावृत्त प्रक्रिया है।** आपको कई तकनीकों को लागू करने और परिणामों की समीक्षा करने की आवश्यकता हो सकती है, इससे पहले कि आप अपने साफ किए गए डेटा सेट को अंतिम रूप दें।\n",
"\n",
"5. **अपने निर्णयों का दस्तावेजीकरण करें।** आपने कौन-कौन से सफाई कदम उठाए और क्यों, इसका रिकॉर्ड रखें, क्योंकि यह पुनरुत्पादन और पारदर्शिता के लिए महत्वपूर्ण है।\n",
"\n",
"> **सर्वोत्तम अभ्यास:** हमेशा अपने मूल \"गंदे\" डेटा की एक प्रति रखें। कभी भी अपने स्रोत डेटा फाइलों को अधिलेखित न करें - साफ किए गए संस्करण बनाएं और उन्हें स्पष्ट नामकरण जैसे `data_cleaned.csv` के साथ सहेजें।\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**अस्वीकरण**: \nयह दस्तावेज़ AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) का उपयोग करके अनुवादित किया गया है। जबकि हम सटीकता सुनिश्चित करने का प्रयास करते हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में उपलब्ध मूल दस्तावेज़ को आधिकारिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम जिम्मेदार नहीं हैं।\n"
]
}
],
"metadata": {
"anaconda-cloud": {},
"colab": {
"name": "notebook.ipynb",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.4"
},
"coopTranslator": {
"original_hash": "6301339d1c9a301b00639c635dc9b731",
"translation_date": "2025-10-03T19:35:33+00:00",
"source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
"language_code": "hi"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
Reference in new issue View Git Blame Copy Permalink