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 'main'
${ noResults }
Data-Science-For-Beginners/translations/ne/2-Working-With-Data/08-data-preparation/notebook.ipynb

3689 lines
131 KiB
Raw Permalink Blame History Escape

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

{
"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` मा ६०,००० पङ्क्तिहरू र ४०० स्तम्भहरू छन् भने, तपाईंले काम गर्न लागेको डाटाको बारेमा कसरी थाहा पाउनुहुन्छ? सौभाग्यवश, pandas ले `DataFrame` को समग्र जानकारी हेर्नका लागि साथै पहिलो केही र अन्तिम केही पङ्क्तिहरू हेर्नका लागि केही सुविधाजनक उपकरणहरू प्रदान गर्दछ।\n",
"\n",
"यस कार्यक्षमता अन्वेषण गर्नका लागि, हामी Python को scikit-learn लाइब्रेरी आयात गर्नेछौं र एउटा प्रसिद्ध डाटासेट प्रयोग गर्नेछौं जुन हरेक डेटा वैज्ञानिकले सयौं पटक देखेका छन्: बेलायती जीवविज्ञानी रोनाल्ड फिशरको *Iris* डाटासेट, जुन उनले १९३६ मा \"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": [
"त्यसैले, हामीसँग १५० पङ्क्ति र ४ स्तम्भको डाटा छ। प्रत्येक पङ्क्तिले एउटा डाटापोइन्टलाई प्रतिनिधित्व गर्छ र प्रत्येक स्तम्भले डाटा फ्रेमसँग सम्बन्धित एउटा विशेषता देखाउँछ। त्यसैले आधारभूत रूपमा, त्यहाँ १५० डाटापोइन्टहरू छन्, जसमा प्रत्येकमा ४ विशेषताहरू छन्।\n",
"\n",
"`shape` यहाँ डाटा फ्रेमको एउटा गुण हो, कार्य (function) होइन, त्यसैले यसले जोडी कोष्ठकहरूमा अन्त्य गर्दैन।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "d3AZKs0PinGP"
},
"source": [
"### `DataFrame.columns`\n",
"अब हामी डाटाका ४ स्तम्भहरूतर्फ जाऔं। यी प्रत्येकले के प्रतिनिधित्व गर्छन्? `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": [
"जसरी हामी देख्न सक्छौं, त्यहाँ चार(४) वटा स्तम्भहरू छन्। `columns` विशेषताले हामीलाई स्तम्भहरूको नाम बताउँछ र मूलतः अरू केही होइन। यो विशेषता महत्त्वपूर्ण हुन्छ जब हामी कुनै डेटासेटमा भएका विशेषताहरू पहिचान गर्न चाहन्छौं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2UTlvkjmgRrs"
},
"source": [
"### `DataFrame.info`\n",
"डाटाको मात्रा (`shape` attribute ले दिएको) र विशेषता वा स्तम्भहरूको नाम (`columns` attribute ले दिएको) ले हामीलाई डेटासेटको बारेमा केही जानकारी दिन्छ। अब, हामी डेटासेटमा अझ गहिरो रूपमा जान चाहन्छौं। `DataFrame.info()` function यसका लागि निकै उपयोगी छ।\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": [
"उपरोक्त परिणामले प्रत्येक स्तम्भको कुल डाटा बिन्दुहरूको संख्या, औसत, मानक विचलन, न्यूनतम, तल्लो चतुर्थांश (२५%), माध्यिका (५०%), माथिल्लो चतुर्थांश (७५%) र अधिकतम मान देखाउँछ।\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": [
"आउटपुटमा, हामीले डेटासेटका पाँच(५) इन्ट्रीहरू देख्न सक्छौं। यदि हामी बायाँतिरको इन्डेक्स हेर्छौं भने, यी पहिलो पाँच पंक्तिहरू हुन् भन्ने पत्ता लगाउन सक्छौं।\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",
"माथि कोड उदाहरणहरूको मद्दतले देखाइएका सबै functions र attributes ले हामीलाई डेटा हेर्न र महसुस गर्न मद्दत गर्छ।\n",
"\n",
"> **मुख्य कुरा:** केवल `DataFrame` मा भएको जानकारीको metadata हेरेर वा यसको पहिलो र अन्तिम केही मानहरू हेरेर पनि, तपाईंले तपाईंले काम गरिरहेको डेटा कस्तो आकार, आकार, र सामग्रीको हो भन्ने बारे तुरुन्तै धारणा बनाउन सक्नुहुन्छ।\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()` जस्ता समग्र गणनाहरू प्रयोग गर्दा, यदि array मा ``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": []
},
{
"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": []
},
{
"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": []
},
{
"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": []
},
{
"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` हरूमा डेटा प्रकारहरूको समानता कायम गर्न अपकास्टिङ गर्दा, पाण्डासले हराएका मानहरूलाई `None` र `NaN` बीच सजिलै परिवर्तन गर्न सक्छ। यस डिजाइन सुविधाका कारण, पाण्डासमा `None` र `NaN` लाई \"null\" का दुई फरक प्रकारका रूपमा सोच्नु उपयोगी हुन सक्छ। वास्तवमा, पाण्डासमा हराएका मानहरूलाई व्यवस्थापन गर्न प्रयोग गरिने केही मुख्य विधिहरूले यो विचारलाई आफ्ना नामहरूमा झल्काउँछन्:\n",
"\n",
"- `isnull()`: हराएका मानहरूलाई जनाउने बूलियन मास्क उत्पन्न गर्छ\n",
"- `notnull()`: `isnull()` को विपरीत\n",
"- `dropna()`: डेटा को फिल्टर गरिएको संस्करण फिर्ता दिन्छ\n",
"- `fillna()`: हराएका मानहरू भरेर वा अनुमान गरेर डेटा को प्रतिलिपि फिर्ता दिन्छ\n",
"\n",
"यी विधिहरूलाई राम्रोसँग बुझ्न र सहज हुन सिक्नु महत्त्वपूर्ण छ, त्यसैले हामी यी प्रत्येकलाई विस्तारमा बुझ्ने प्रयास गरौं।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Yh5ifd9FgRsB"
},
"source": [
"### नल मानहरू पत्ता लगाउँदै\n",
"\n",
"अब हामीले हराएका मानहरूको महत्त्व बुझेका छौं, तिनीहरूलाई व्यवस्थापन गर्नुअघि हाम्रो डेटासेटमा तिनीहरू पत्ता लगाउन आवश्यक छ। \n",
"`isnull()` र `notnull()` दुबै नल डाटालाई पत्ता लगाउनका लागि तपाईंका मुख्य विधिहरू हुन्। यी दुबैले तपाईंको डाटामा बूलियन मास्कहरू फिर्ता गर्छन्।\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 ले यसलाई त्यस्तै व्यवहार गर्छ। `''` अलि बढी सूक्ष्म छ। जबकि हामीले यसलाई खण्ड १ मा खाली स्ट्रिङ मानको रूपमा प्रयोग गरेका थियौं, यो अझै पनि स्ट्रिङ वस्तु हो र 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": []
},
{
"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()` विधिहरूले समान परिणाम उत्पादन गर्छन् जब तपाईं तिनीहरूलाई DataFrames मा प्रयोग गर्नुहुन्छ: तिनीहरूले परिणामहरू र ती परिणामहरूको सूचकांक देखाउँछन्, जसले तपाईंलाई तपाईंको डाटासँग संघर्ष गर्दा अत्यधिक मद्दत गर्नेछ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BvnoojWsgRr4"
},
"source": [
"### हराएको डाटासँग व्यवहार गर्ने\n",
"\n",
"> **शिक्षण लक्ष्य:** यो उपविभागको अन्त्यसम्ममा, तपाईंले DataFrames बाट null मानहरू कहिले र कसरी प्रतिस्थापन गर्ने वा हटाउने भन्ने जान्नुहुनेछ।\n",
"\n",
"Machine Learning मोडेलहरूले आफैंले हराएको डाटासँग व्यवहार गर्न सक्दैनन्। त्यसैले, डाटालाई मोडेलमा पठाउनु अघि, हामीले यी हराएका मानहरूसँग व्यवहार गर्नुपर्छ।\n",
"\n",
"हराएको डाटालाई कसरी व्यवस्थापन गरिन्छ भन्ने कुराले सूक्ष्म सम्झौता (tradeoffs) ल्याउँछ, जसले तपाईंको अन्तिम विश्लेषण र वास्तविक संसारको नतिजामा प्रभाव पार्न सक्छ।\n",
"\n",
"हराएको डाटासँग व्यवहार गर्ने मुख्यतः दुई तरिकाहरू छन्:\n",
"\n",
"1. हराएको मान भएको पङ्क्ति (row) हटाउनुहोस् \n",
"2. हराएको मानलाई कुनै अन्य मानले प्रतिस्थापन गर्नुहोस् \n",
"\n",
"हामी यी दुवै विधिहरू र तिनका फाइदा र बेफाइदाहरू विस्तारमा छलफल गर्नेछौं। \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3VaYC1TvgRsD"
},
"source": [
"### नल मानहरू हटाउने\n",
"\n",
"हामीले हाम्रो मोडेललाई दिने डाटाको परिमाणले यसको प्रदर्शनमा प्रत्यक्ष प्रभाव पार्छ। नल मानहरू हटाउनुको अर्थ हो कि हामी डाटापोइन्टहरूको संख्या घटाउँदैछौं, जसले गर्दा डेटासेटको आकार पनि घट्छ। त्यसैले, जब डेटासेट धेरै ठूलो हुन्छ, नल मान भएका पङ्क्तिहरू हटाउनु सल्लाहयोग्य हुन्छ।\n",
"\n",
"अर्को उदाहरण हुन सक्छ कि कुनै निश्चित पङ्क्ति वा स्तम्भमा धेरै हराएका मानहरू छन्। त्यस अवस्थामा, ती पङ्क्ति वा स्तम्भलाई हटाउन सकिन्छ किनभने ती हाम्रो विश्लेषणमा धेरै मूल्य थप्दैनन्, किनभने अधिकांश डाटा हराएको हुन्छ।\n",
"\n",
"हराएका मानहरू पहिचान गर्न बाहेक, pandas ले `Series` र `DataFrame`s बाट नल मानहरू हटाउनको लागि सुविधाजनक उपाय प्रदान गर्दछ। यसलाई व्यवहारमा हेर्नको लागि, हामी `example3` मा फर्कौं। `DataFrame.dropna()` function ले नल मान भएका पङ्क्तिहरू हटाउन मद्दत गर्दछ।\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 समायोजन गर्न दुई स्तम्भहरूलाई floats मा परिवर्तन गर्यो?)\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 मानहरू हटाउनु राम्रो विचार हो, तर मात्र तब जब dataset पर्याप्त ठूलो छ। \n",
"2. यदि पंक्ति वा स्तम्भमा अधिकांश डाटा हराइरहेको छ भने, ती पूर्ण रूपमा हटाउन सकिन्छ। \n",
"3. `DataFrame.dropna(axis=)` विधिले null मानहरू हटाउन मद्दत गर्छ। `axis` तर्कले पंक्ति हटाउने हो वा स्तम्भ भन्ने जनाउँछ। \n",
"4. `how` तर्क पनि प्रयोग गर्न सकिन्छ। यो डिफल्ट रूपमा `any` मा सेट गरिएको हुन्छ। त्यसैले, यसले त्यस्ता पंक्ति/स्तम्भ मात्र हटाउँछ जसमा कुनै पनि null मानहरू हुन्छन्। यसलाई `all` मा सेट गर्न सकिन्छ, जसले गर्दा हामी त्यस्ता पंक्ति/स्तम्भ मात्र हटाउँछौं जहाँ सबै मानहरू null छन्। \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oXXSfQFHgRsF"
},
"source": []
},
{
"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": []
},
{
"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` द्वारा प्रतिस्थापन गर्छौं। मानौं, हामीसँग १०० डेटा बिन्दुहरू छन् र ९० ले सत्य भनेका छन्, ८ ले असत्य भनेका छन् र २ ले भरेका छैनन्। त्यसो भए, हामी ती २ लाई सत्यले भरिदिन सक्छौं, सम्पूर्ण स्तम्भलाई विचार गर्दै।\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": []
},
{
"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": []
},
{
"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": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "heYe1I0dOmQ_"
},
"source": [
"### संख्यात्मक डेटा\n",
"अब, संख्यात्मक डेटा तर्फ जाऔं। यहाँ, हराएको मानहरूलाई प्रतिस्थापन गर्ने दुई सामान्य तरिका छन्:\n",
"\n",
"1. पंक्तिको माध्यक (Median) प्रयोग गरेर प्रतिस्थापन गर्नुहोस् \n",
"2. पंक्तिको औसत (Mean) प्रयोग गरेर प्रतिस्थापन गर्नुहोस् \n",
"\n",
"यदि डेटा असमान छ र बाहिरका मानहरू (outliers) छन् भने, हामी माध्यक प्रयोग गरेर प्रतिस्थापन गर्छौं। यसको कारण, माध्यक बाहिरका मानहरू प्रति संवेदनशील हुँदैन।\n",
"\n",
"जब डेटा सामान्यीकृत (normalized) हुन्छ, हामी औसत प्रयोग गर्न सक्छौं, किनकि त्यस अवस्थामा औसत र माध्यक एक-अर्कासँग नजिक हुन्छन्।\n",
"\n",
"पहिला, एउटा स्तम्भ लिऔं जुन सामान्य वितरणमा छ, र त्यस स्तम्भको हराएको मानलाई औसत प्रयोग गरेर भर्नुहोस्।\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": []
},
{
"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": []
},
{
"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": []
},
{
"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. श्रेणीगत (Categorical) डाटाका लागि, प्रायः हराएका मानहरू स्तम्भको मोड (mode) ले प्रतिस्थापन गरिन्छ। \n",
"4. संख्यात्मक (Numeric) डाटाका लागि, हराएका मानहरू सामान्यतया स्तम्भहरूको औसत (normalized datasets का लागि) वा माध्यिका (median) ले भर्ने गरिन्छ। \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FI9MmqFJgRsH"
},
"source": []
},
{
"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": []
},
{
"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": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "eeAoOU0RgRsJ"
},
"source": []
},
{
"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": [
"ध्यान दिनुहोस् कि स्तम्भ ३ अझै खाली छ: डिफल्ट दिशा पङ्क्ति अनुसार मानहरू भर्नु हो।\n",
"\n",
"> **मुख्य कुरा:** तपाईंसँगको डाटासेटमा हराइरहेका मानहरूलाई व्यवस्थापन गर्न धेरै तरिकाहरू छन्। तपाईले कुन विशेष रणनीति प्रयोग गर्नुहुन्छ (तिनीहरूलाई हटाउने, प्रतिस्थापन गर्ने, वा कसरी प्रतिस्थापन गर्ने) त्यो डाटाको विशेषताहरूले निर्धारण गर्नुपर्छ। जति धेरै तपाई डाटासेटहरूलाई व्यवस्थापन र अन्तरक्रिया गर्नुहुन्छ, हराइरहेका मानहरूलाई कसरी व्यवस्थापन गर्ने भन्ने राम्रो ज्ञान विकास हुनेछ।\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bauDnESIl9FH"
},
"source": [
"### श्रेणीगत डाटा एनकोडिङ\n",
"\n",
"मेसिन लर्निङ मोडेलहरूले मात्र संख्यात्मक डाटासँग काम गर्छन्। यसले \"हो\" र \"होइन\" बीचको भिन्नता बुझ्न सक्दैन, तर यसले 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",
"उदाहरणका लागि, हामी उही हवाईजहाजको श्रेणीको उदाहरण लिऔं। श्रेणीहरू थिए: ['business class', 'economy class', 'first class']। त्यसैले, यदि हामी वन हट इन्कोडिङ गर्छौं भने, निम्न तीन स्तम्भहरू डाटासेटमा थपिनेछन्: ['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` विधि प्रयोग गरेर सजिलै डुप्लिकेट मानहरू पत्ता लगाउन सक्नुहुन्छ, जसले `DataFrame` मा कुनै इन्ट्री पहिलेको इन्ट्रीको डुप्लिकेट हो कि होइन भनेर जनाउने Boolean मास्क फिर्ता गर्छ। यसलाई व्यवहारमा हेर्नको लागि अर्को उदाहरण `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": []
},
{
"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": "8533b3a2230311943339963fc7f04c21",
"translation_date": "2025-09-02T07:22:18+00:00",
"source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
"language_code": "ne"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
Reference in new issue View Git Blame Copy Permalink