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

4244 lines
163 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 ಕಾಲಮ್‌ಗಳ ಡೇಟಾ ಜೊತೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಪ್ರತಿ ಸಾಲು ಒಂದು ಡೇಟಾಪಾಯಿಂಟ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಕಾಲಮ್ ಡೇಟಾ ಫ್ರೇಮ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಒಂದು ವೈಶಿಷ್ಟ್ಯವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ಮೂಲತಃ, 4 ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿರುವ 150 ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳಿವೆ.\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` ಗುಣಲಕ್ಷಣದಿಂದ ನೀಡಲ್ಪಟ್ಟಿದೆ) ಮತ್ತು ವೈಶಿಷ್ಟ್ಯಗಳ ಅಥವಾ ಕಾಲಮ್‌ಗಳ ಹೆಸರುಗಳು (`columns` ಗುಣಲಕ್ಷಣದಿಂದ ನೀಡಲ್ಪಟ್ಟಿದೆ) ನಮಗೆ ಡೇಟಾಸೆಟ್ ಬಗ್ಗೆ ಏನೋ ತಿಳಿಸುತ್ತವೆ. ಈಗ, ನಾವು ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಇನ್ನಷ್ಟು ಆಳವಾಗಿ ಹೋಗಲು ಇಚ್ಛಿಸುತ್ತೇವೆ. `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",
"**ಪಾಂಡಾಸ್ ಕಳೆದುಹೋಗಿದ ಡೇಟಾವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ**\n",
"\n",
"\n",
"ಪಾಂಡಾಸ್ ಕಳೆದುಹೋಗಿದ ಮೌಲ್ಯಗಳನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸುತ್ತದೆ. ಮೊದಲನೆಯದು ನೀವು ಹಿಂದಿನ ವಿಭಾಗಗಳಲ್ಲಿ ನೋಡಿದ್ದೀರಿ: `NaN`, ಅಂದರೆ ನಂಬರ್ ಅಲ್ಲ. ಇದು ವಾಸ್ತವವಾಗಿ IEEE ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸ್ಪೆಸಿಫಿಕೇಶನ್‌ನ ಭಾಗವಾಗಿರುವ ವಿಶೇಷ ಮೌಲ್ಯ ಮತ್ತು ಇದು ಕಳೆದುಹೋಗಿದ ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳನ್ನು ಸೂಚಿಸಲು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ.\n",
"\n",
"ಫ್ಲೋಟ್ಸ್ ಹೊರತುಪಡಿಸಿ ಕಳೆದುಹೋಗಿದ ಮೌಲ್ಯಗಳಿಗೆ, ಪಾಂಡಾಸ್ ಪೈಥಾನ್ `None` ವಸ್ತುವನ್ನು ಬಳಸುತ್ತದೆ. ನೀವು ಎರಡು ವಿಭಿನ್ನ ರೀತಿಯ ಮೌಲ್ಯಗಳನ್ನು ಎದುರಿಸುವುದು ಗೊಂದಲಕಾರಿಯಾಗಬಹುದು, ಆದರೆ ಈ ವಿನ್ಯಾಸ ಆಯ್ಕೆಗೆ ತರ್ಕಬದ್ಧವಾದ ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ಕಾರಣಗಳಿವೆ ಮತ್ತು ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಈ ಮಾರ್ಗವನ್ನು ಅನುಸರಿಸುವುದರಿಂದ ಪಾಂಡಾಸ್ ಬಹುಮಟ್ಟಿನ ಪ್ರಕರಣಗಳಿಗೆ ಉತ್ತಮ ಸಮಾಧಾನವನ್ನು ನೀಡುತ್ತದೆ. ಇದನ್ನು ಬಿಟ್ಟು, `None` ಮತ್ತು `NaN` ಎರಡೂ ಬಳಸುವಾಗ ನೀವು ಜಾಗರೂಕವಾಗಿರಬೇಕಾದ ನಿರ್ಬಂಧಗಳನ್ನು ಹೊಂದಿವೆ.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lOHqUlZFgRr5"
},
"source": [
"### `None`: ಫ್ಲೋಟ್ ಅಲ್ಲದ ಕಾಣೆಯಾದ ಡೇಟಾ \n",
"`None` ಪೈಥಾನ್‌ನಿಂದ ಬರುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದು `'object'` ಡೇಟಾ ಪ್ರಕಾರದಲ್ಲದ NumPy ಮತ್ತು pandas ಅರೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ. ನೆನಪಿಡಿ, NumPy ಅರೆಗಳು (ಮತ್ತು pandas ನಲ್ಲಿ ಡೇಟಾ ರಚನೆಗಳು) ಒಂದೇ ಪ್ರಕಾರದ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಹೊಂದಿರಬಹುದು. ಇದು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾ ಮತ್ತು ಗಣನಾತ್ಮಕ ಕೆಲಸಗಳಿಗೆ ಅದ್ಭುತ ಶಕ್ತಿ ನೀಡುತ್ತದೆ, ಆದರೆ ಇದರ ಲವಚಿಕತೆಯನ್ನು ಕೂಡಾ ಮಿತಿಗೊಳಿಸುತ್ತದೆ. ಇಂತಹ ಅರೆಗಳು \"ಕನಿಷ್ಠ ಸಾಮಾನ್ಯ ಹಂಚಿಕೆದಾರ\" ಗೆ ಅಪ್‌ಕಾಸ್ಟ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಅರೆದಲ್ಲಿರುವ ಎಲ್ಲವನ್ನೂ ಒಳಗೊಂಡಿರುವ ಡೇಟಾ ಪ್ರಕಾರ. ಅರೆಗಳಲ್ಲಿ `None` ಇದ್ದರೆ, ನೀವು ಪೈಥಾನ್ ವಸ್ತುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೀರಿ ಎಂದು ಅರ್ಥ. \n",
"\n",
"ಇದನ್ನು ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ನೋಡಲು, ಕೆಳಗಿನ ಉದಾಹರಣೆಯ ಅರೆ (ಅದರ `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": [
"ಅಪ್ಕಾಸ್ಟ್ ಡೇಟಾ ಪ್ರಕಾರಗಳ ವಾಸ್ತವಿಕತೆ ಎರಡು ಪಾರ್ಶ್ವ ಪರಿಣಾಮಗಳನ್ನು ಹೊಂದಿದೆ. ಮೊದಲನೆಯದಾಗಿ, ಕಾರ್ಯಾಚರಣೆಗಳು ಸಂಯೋಜಿತ NumPy ಕೋಡ್ ಬದಲು ವ್ಯಾಖ್ಯಾನಿತ Python ಕೋಡ್ ಮಟ್ಟದಲ್ಲಿ ನಡೆಸಲಾಗುತ್ತದೆ. ಮೂಲತಃ, ಇದರಿಂದ `None` ಹೊಂದಿರುವ `Series` ಅಥವಾ `DataFrames` ಅನ್ನು ಒಳಗೊಂಡ ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆಗಳು ನಿಧಾನವಾಗುತ್ತವೆ. ನೀವು ಬಹುಶಃ ಈ ಕಾರ್ಯಕ್ಷಮತೆ ಹಾನಿಯನ್ನು ಗಮನಿಸದಿರಬಹುದು, ಆದರೆ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಇದು ಸಮಸ್ಯೆಯಾಗಬಹುದು.\n",
"\n",
"ಎರಡನೆಯ ಪಾರ್ಶ್ವ ಪರಿಣಾಮವು ಮೊದಲನೆಯದರಿಂದ ಉಂಟಾಗುತ್ತದೆ. ಏಕೆಂದರೆ `None` ಮೂಲತಃ `Series` ಅಥವಾ `DataFrame`ಗಳನ್ನು ವನಿಲ್ಲಾ Python ಜಗತ್ತಿಗೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ, `None` ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಅರೆಗಳ ಮೇಲೆ NumPy/pandas ಸಂಗ್ರಹಣಾ ಕಾರ್ಯಗಳು, ಉದಾಹರಣೆಗೆ `sum()` ಅಥವಾ `min()`, ಸಾಮಾನ್ಯವಾಗಿ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತವೆ:\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 ನಲ್ಲಿ ಶೂನ್ಯ ಮೌಲ್ಯಗಳು\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": [
"### ಶೂನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು\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 ಅದನ್ನು ಹಾಗೆಯೇ ಪರಿಗಣಿಸುತ್ತದೆ. `''` ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮವಾಗಿದೆ. ನಾವು ಅದನ್ನು ವಿಭಾಗ 1 ರಲ್ಲಿ ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಬಳಸಿದ್ದರೂ, ಅದು pandas ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಶೂನ್ಯದ ಪ್ರತಿನಿಧನೆ ಅಲ್ಲ, ಅದು ಸ್ಟ್ರಿಂಗ್ ವಸ್ತುವಾಗಿದೆ.\n",
"\n",
"ಈಗ, ಇದನ್ನು ತಿರುಗಿಸಿ, ನೀವು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಬಳಸುವ ರೀತಿಯಲ್ಲಿ ಈ ವಿಧಾನಗಳನ್ನು ಬಳಸೋಣ. ನೀವು Boolean ಮಾಸ್ಕ್‌ಗಳನ್ನು ನೇರವಾಗಿ ``Series`` ಅಥವಾ ``DataFrame`` ಸೂಚ್ಯಂಕವಾಗಿ ಬಳಸಬಹುದು, ಇದು ಪ್ರತ್ಯೇಕವಾಗಿ ಕಾಣೆಯಾದ (ಅಥವಾ ಇರುವ) ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಉಪಯುಕ್ತವಾಗಬಹುದು.\n",
"\n",
"ನಾವು ಒಟ್ಟು ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳ ಸಂಖ್ಯೆಯನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದರೆ, `isnull()` ವಿಧಾನದಿಂದ ಉತ್ಪನ್ನವಾದ ಮಾಸ್ಕ್ ಮೇಲೆ ಸರಳವಾಗಿ ಮೊತ್ತವನ್ನು ಮಾಡಬಹುದು.\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()` ವಿಧಾನಗಳು DataFrames ನಲ್ಲಿ ಬಳಸಿದಾಗ ಸಮಾನ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುತ್ತವೆ: ಅವು ಫಲಿತಾಂಶಗಳನ್ನು ಮತ್ತು ಆ ಫಲಿತಾಂಶಗಳ ಸೂಚ್ಯಂಕವನ್ನು ತೋರಿಸುತ್ತವೆ, ಇದು ನಿಮ್ಮ ಡೇಟಾ ಜೊತೆ ಹೋರಾಡುವಾಗ ನಿಮಗೆ ಬಹಳ ಸಹಾಯ ಮಾಡುತ್ತದೆ.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BvnoojWsgRr4"
},
"source": [
"### ಕಾಣೆಯಾದ ಡೇಟಾವನ್ನು ನಿಭಾಯಿಸುವುದು\n",
"\n",
"> **ಕಲಿಕೆಯ ಗುರಿ:** ಈ ಉಪವಿಭಾಗದ ಕೊನೆಯಲ್ಲಿ, ನೀವು DataFrames ನಿಂದ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೇಗೆ ಮತ್ತು ಯಾವಾಗ ಬದಲಾಯಿಸಬೇಕು ಅಥವಾ ತೆಗೆದುಹಾಕಬೇಕು ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು.\n",
"\n",
"ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳು ತಾವು ಕಾಣೆಯಾದ ಡೇಟಾವನ್ನು ನಿಭಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದ್ದರಿಂದ, ಡೇಟಾವನ್ನು ಮಾದರಿಯಲ್ಲಿ ಹಂಚಿಕೆಯಾಗಿಸುವ ಮೊದಲು, ನಾವು ಈ ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳನ್ನು ನಿಭಾಯಿಸಬೇಕಾಗುತ್ತದೆ.\n",
"\n",
"ಕಾಣೆಯಾದ ಡೇಟಾವನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸಲಾಗುತ್ತದೆ ಎಂಬುದು ಸೂಕ್ಷ್ಮ ವ್ಯವಹಾರಗಳನ್ನು ಹೊಂದಿದೆ, ಇದು ನಿಮ್ಮ ಅಂತಿಮ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ನೈಜ ಜಗತ್ತಿನ ಫಲಿತಾಂಶಗಳನ್ನು ಪ್ರಭಾವಿಸುತ್ತದೆ.\n",
"\n",
"ಕಾಣೆಯಾದ ಡೇಟಾವನ್ನು ನಿಭಾಯಿಸುವ ಎರಡು ಪ್ರಮುಖ ವಿಧಾನಗಳಿವೆ:\n",
"\n",
"\n",
"1. ಕಾಣೆಯಾದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಸಾಲನ್ನು ತೆಗೆದುಹಾಕುವುದು\n",
"2. ಕಾಣೆಯಾದ ಮೌಲ್ಯವನ್ನು ಬೇರೆ ಮೌಲ್ಯದಿಂದ ಬದಲಾಯಿಸುವುದು\n",
"\n",
"ನಾವು ಈ ಎರಡೂ ವಿಧಾನಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ಲಾಭ-ನಷ್ಟಗಳನ್ನು ವಿವರವಾಗಿ ಚರ್ಚಿಸುವೆವು.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3VaYC1TvgRsD"
},
"source": [
"### ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕುವುದು\n",
"\n",
"ನಾವು ನಮ್ಮ ಮಾದರಿಗೆ ನೀಡುವ ಡೇಟಾದ ಪ್ರಮಾಣವು ಅದರ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ನೇರ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ. ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕುವುದು ಎಂದರೆ ನಾವು ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತಿದ್ದೇವೆ, ಮತ್ತು ಆದ್ದರಿಂದ ಡೇಟಾಸೆಟ್‌ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಆದ್ದರಿಂದ, ಡೇಟಾಸೆಟ್ ಬಹಳ ದೊಡ್ಡದಾಗಿದ್ದಾಗ ನಲ್ ಮೌಲ್ಯಗಳಿರುವ ಸಾಲುಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕುವುದು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ.\n",
"\n",
"ಮತ್ತೊಂದು ಉದಾಹರಣೆ ಎಂದರೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಾಲು ಅಥವಾ ಕಾಲಮ್‌ನಲ್ಲಿ ಬಹಳಷ್ಟು ಮಿಸ್ ಆಗಿರುವ ಮೌಲ್ಯಗಳಿರಬಹುದು. ಆಗ ಅವುಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕಬಹುದು ಏಕೆಂದರೆ ಆ ಸಾಲು/ಕಾಲಮ್‌ಗೆ ಹೆಚ್ಚಿನ ಡೇಟಾ ಇಲ್ಲದಿರುವುದರಿಂದ ಅವು ನಮ್ಮ ವಿಶ್ಲೇಷಣೆಗೆ ಹೆಚ್ಚಿನ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸುವುದಿಲ್ಲ.\n",
"\n",
"ಮಿಸ್ ಆಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ಗುರುತಿಸುವುದನ್ನು ಮೀರಿ, pandas `Series` ಮತ್ತು `DataFrame`ಗಳಿಂದ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಅನುಕೂಲಕರ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದನ್ನು ಕಾರ್ಯದಲ್ಲಿ ನೋಡಲು, ನಾವು `example3` ಗೆ ಮರಳೋಣ. `DataFrame.dropna()` ಫಂಕ್ಷನ್ ನಲ್ ಮೌಲ್ಯಗಳಿರುವ ಸಾಲುಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.\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` ಗಳನ್ನು ಹೊಂದಿಸಲು ಫ್ಲೋಟ್‌ಗಳಿಗೆ ಅಪ್‌ಕಾಸ್ಟ್ ಮಾಡುತ್ತದೆ?)\n",
"\n",
"ನೀವು `DataFrame` ನಿಂದ ಒಂದೇ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ಸಂಪೂರ್ಣ ಸಾಲುಗಳು ಅಥವಾ ಕಾಲಮ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಬೇಕು. ನೀವು ಏನು ಮಾಡುತ್ತಿದ್ದೀರೋ ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ, ನೀವು ಒಂದನ್ನು ಅಥವಾ ಇನ್ನೊಂದನ್ನು ಮಾಡಬಹುದು, ಹಾಗಾಗಿ pandas ಎರಡಕ್ಕೂ ಆಯ್ಕೆಗಳು ನೀಡುತ್ತದೆ. ಡೇಟಾ ಸೈನ್ಸ್‌ನಲ್ಲಿ, ಕಾಲಮ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಚರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ ಮತ್ತು ಸಾಲುಗಳು ಅವಲೋಕನಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ ನೀವು ಡೇಟಾದ ಸಾಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚು; `dropna()` ನ ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್ ಯಾವುದೇ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುವದು:\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": [
"ಗಮನಿಸಿ, ಇದು ನೀವು ಉಳಿಸಿಕೊಳ್ಳಲು ಬಯಸುವ ಬಹಳಷ್ಟು ಡೇಟಾವನ್ನು ಬಿಟ್ಟಿಹೋಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಸಣ್ಣ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ. ನೀವು ಕೆಲವೊಂದು ಅಥವಾ ಎಲ್ಲಾ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಸಾಲುಗಳು ಅಥವಾ ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಬಿಟ್ಟಿಹೋಗಲು ಬಯಸಿದರೆ ಏನು ಮಾಡಬೇಕು? ನೀವು `dropna` ನಲ್ಲಿ `how` ಮತ್ತು `thresh` ಪರಿಮಾಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.\n",
"\n",
"ಡೀಫಾಲ್ಟ್ ಆಗಿ, `how='any'` (ನೀವು ಸ್ವತಃ ಪರಿಶೀಲಿಸಲು ಅಥವಾ ಈ ವಿಧಾನದಲ್ಲಿ ಇನ್ನೇನು ಪರಿಮಾಣಗಳಿವೆ ಎಂದು ನೋಡಲು ಬಯಸಿದರೆ, ಕೋಡ್ ಸೆಲ್‌ನಲ್ಲಿ `example4.dropna?` ಅನ್ನು ರನ್ ಮಾಡಿ). ಬದಲಾಗಿ, ನೀವು `how='all'` ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು, ಇದರಿಂದ ಎಲ್ಲಾ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಸಾಲುಗಳು ಅಥವಾ ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಬಿಟ್ಟಿಹೋಗುತ್ತದೆ. ಮುಂದಿನ ವ್ಯಾಯಾಮದಲ್ಲಿ ಇದನ್ನು ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ನೋಡಲು ನಮ್ಮ ಉದಾಹರಣೆಯ `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. ಡೇಟಾಸೆಟ್ ಸಾಕಷ್ಟು ದೊಡ್ಡದಾಗಿದ್ದರೆ ಮಾತ್ರ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕುವುದು ಒಳ್ಳೆಯ ವಿಚಾರ. \n",
"2. ಹೆಚ್ಚಿನ ಡೇಟಾ ಇಲ್ಲದಿದ್ದರೆ ಸಂಪೂರ್ಣ ಸಾಲುಗಳು ಅಥವಾ ಕಾಲಮ್‌ಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕಬಹುದು. \n",
"3. `DataFrame.dropna(axis=)` ವಿಧಾನವು ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. `axis` ಆರ್ಗ್ಯುಮೆಂಟ್ ಸಾಲುಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕಬೇಕೇ ಅಥವಾ ಕಾಲಮ್‌ಗಳನ್ನು ಬಿಟ್ಟಿಹಾಕಬೇಕೇ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ. \n",
"4. `how` ಆರ್ಗ್ಯುಮೆಂಟ್ ಕೂಡ ಬಳಸಬಹುದು. ಡೀಫಾಲ್ಟ್ ಆಗಿ ಇದು `any` ಗೆ ಸೆಟ್ ಆಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಯಾವುದೇ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಸಾಲುಗಳು/ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಬಿಟ್ಟಿಹಾಕುತ್ತದೆ. ಎಲ್ಲಾ ಮೌಲ್ಯಗಳು ನಲ್ ಆಗಿರುವ ಸಾಲುಗಳು/ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಬಿಟ್ಟಿಹಾಕಲು ಇದನ್ನು `all` ಗೆ ಸೆಟ್ ಮಾಡಬಹುದು.\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",
"ಮತ್ತೆ, ಇಲ್ಲಿ ನಾವು ಕ್ಷೇತ್ರ ಜ್ಞಾನವನ್ನು ಬಳಸಬಹುದು. ಮೋಡ್‌ನೊಂದಿಗೆ ಭರ್ತಿ ಮಾಡುವ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ.\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": [
"ನಾವು ನೋಡಬಹುದು, ನಲ್ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ. ಹೇಳಬೇಕಾಗಿಲ್ಲ, ನಾವು ಯಾವುದೇ ವಾಕ್ಯವನ್ನು `'True'` ಬದಲು ಬರೆಯಬಹುದು ಮತ್ತು ಅದು ಬದಲಾಯಿಸಲಾಗುತ್ತಿತ್ತು.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "heYe1I0dOmQ_"
},
"source": [
"### ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾ\n",
"ಈಗ, ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾಕ್ಕೆ ಬನ್ನೋಣ. ಇಲ್ಲಿ, ನಾವು ಕಾಣುವ ಎರಡು ಸಾಮಾನ್ಯ ವಿಧಾನಗಳು ಇಲ್ಲಿವೆ:\n",
"\n",
"1. ಸಾಲಿನ ಮಧ್ಯಮ ಮೌಲ್ಯದಿಂದ ಬದಲಾಯಿಸುವುದು\n",
"2. ಸಾಲಿನ ಸರಾಸರಿ ಮೌಲ್ಯದಿಂದ ಬದಲಾಯಿಸುವುದು\n",
"\n",
"ನಾವು ಮಧ್ಯಮ ಮೌಲ್ಯದಿಂದ ಬದಲಾಯಿಸುವುದು, ಹೊರಗಿನ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ತಿರುವುಳ್ಳ ಡೇಟಾದಲ್ಲಿ ಮಾಡುತ್ತೇವೆ. ಇದಕ್ಕೆ ಕಾರಣ ಮಧ್ಯಮವು ಹೊರಗಿನ ಮೌಲ್ಯಗಳಿಗೆ ಪ್ರತಿರೋಧಕವಾಗಿರುತ್ತದೆ.\n",
"\n",
"ಡೇಟಾ ಸಾಮಾನ್ಯೀಕೃತವಾಗಿದ್ದಾಗ, ನಾವು ಸರಾಸರಿಯನ್ನು ಬಳಸಬಹುದು, ಏಕೆಂದರೆ ಆ ಸಂದರ್ಭದಲ್ಲಿ ಸರಾಸರಿ ಮತ್ತು ಮಧ್ಯಮವು ಬಹಳ ಸಮೀಪವಾಗಿರುತ್ತವೆ.\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": [
"ಸರಾಸರಿ ಬಳಸಿ ತುಂಬುವುದು\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": [
"ನೀವು **ಮುಂದಿನ-ಪೂರಣೆ** ಶೂನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಮಾಡಬಹುದು, ಅಂದರೆ ಶೂನ್ಯವನ್ನು ತುಂಬಲು ಕೊನೆಯ ಮಾನ್ಯ ಮೌಲ್ಯವನ್ನು ಬಳಸುವುದು:\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",
"ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳು ಸಂಖ್ಯೆಗಳನ್ನೇ ಮಾತ್ರ ಹ್ಯಾಂಡಲ್ ಮಾಡುತ್ತವೆ ಮತ್ತು ಯಾವುದೇ ರೀತಿಯ ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾವನ್ನೇ ಮಾತ್ರ. ಅದು ಹೌದು ಮತ್ತು ಇಲ್ಲದ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೆ 0 ಮತ್ತು 1 ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಗುರುತಿಸಲು ಸಾಧ್ಯ. ಆದ್ದರಿಂದ, ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ತುಂಬಿದ ನಂತರ, ಮಾದರಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ವರ್ಗೀಕೃತ ಡೇಟಾವನ್ನು ಕೆಲವು ಸಂಖ್ಯಾತ್ಮಕ ರೂಪಕ್ಕೆ ಎನ್‌ಕೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.\n",
"\n",
"ಎನ್‌ಕೋಡಿಂಗ್ ಎರಡು ರೀತಿಗಳಲ್ಲಿ ಮಾಡಬಹುದು. ನಾವು ಅವುಗಳನ್ನು ಮುಂದಿನ ಭಾಗದಲ್ಲಿ ಚರ್ಚಿಸುವೆವು.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "uDq9SxB7mu5i"
},
"source": [
"**ಲೇಬಲ್ ಎನ್‌ಕೋಡಿಂಗ್**\n",
"\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_ಬಿಸಿನೆಸ್ ಕ್ಲಾಸ್', 'class_ಇಕಾನಮಿ ಕ್ಲಾಸ್', '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",
"> **ಕಲಿಕೆಯ ಗುರಿ:** ಈ ಉಪವಿಭಾಗದ ಕೊನೆಯಲ್ಲಿ, ನೀವು ಡೇಟಾಫ್ರೇಮ್ಗಳಿಂದ ನಕಲಿ ಮೌಲ್ಯಗಳನ್ನು ಗುರುತಿಸುವುದು ಮತ್ತು ತೆಗೆದುಹಾಕುವುದರಲ್ಲಿ ಆರಾಮವಾಗಿರಬೇಕು.\n",
"\n",
"ಕಳೆದುಹೋಗಿರುವ ಡೇಟಾದ ಜೊತೆಗೆ, ನೀವು ನಿಜಜೀವನದ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ನಕಲಿ ಡೇಟಾವನ್ನು ಸಹ συχνά ಎದುರಿಸುತ್ತೀರಿ. ಭಾಗ್ಯವಶಾತ್, pandas ನಕಲಿ ಎಂಟ್ರಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ತೆಗೆದುಹಾಕಲು ಸುಲಭವಾದ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qrEG-Wa0gRsJ"
},
"source": [
"### ನಕಲುಗಳನ್ನು ಗುರುತಿಸುವುದು: `duplicated`\n",
"\n",
"ನೀವು pandas ನಲ್ಲಿ `duplicated` ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಸುಲಭವಾಗಿ ನಕಲು ಮೌಲ್ಯಗಳನ್ನು ಗುರುತಿಸಬಹುದು, ಇದು ಒಂದು ಬೂಲಿಯನ್ ಮಾಸ್ಕ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅದು `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",
"ನಮ್ಮ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ \"ಜಾನ್ ಸ್ಮಿತ್\" ಎಂಬ ಹೆಸರಿನ ವಿವಿಧ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಹಲವಾರು ದಾಖಲೆಗಳಿವೆ ಎಂದು ಗಮನಿಸಿ. ಹೆಸರಿನ ಸಾದೃಶ್ಯದ ಆಧಾರದ ಮೇಲೆ ಸಾಧ್ಯವಿರುವ ನಕಲುಗಳನ್ನು ಗುರುತಿಸೋಣ.\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-ಸ್ಕೋರ್) ಬಳಸಿ.\n",
"\n",
"3. **ಸಮೀಪದ ನಕಲುಗಳು** ನಿಖರ ನಕಲುಗಳಿಗಿಂತ ಪತ್ತೆಹಚ್ಚಲು ಕಷ್ಟಕರವಾಗಿವೆ. ಅವುಗಳನ್ನು ಗುರುತಿಸಲು ಫಜ್ಜಿ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಡೇಟಾವನ್ನು ಸಾಮಾನ್ಯೀಕರಿಸುವುದು (ಕೆಳಗಿನ ಅಕ್ಷರಗೊಳಿಸುವುದು, ಖಾಲಿ ಸ್ಥಳಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು) ಪರಿಗಣಿಸಿ.\n",
"\n",
"4. **ಡೇಟಾ ಶುದ್ಧೀಕರಣವು ಪುನರಾವರ್ತನಾತ್ಮಕವಾಗಿದೆ**. ನೀವು ಅನೇಕ ತಂತ್ರಗಳನ್ನು ಅನ್ವಯಿಸಬೇಕಾಗಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಶುದ್ಧೀಕೃತ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಅಂತಿಮಗೊಳಿಸುವ ಮೊದಲು ಫಲಿತಾಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾಗಬಹುದು.\n",
"\n",
"5. **ನಿಮ್ಮ ನಿರ್ಧಾರಗಳನ್ನು ದಾಖಲೆ ಮಾಡಿಕೊಳ್ಳಿ**. ನೀವು ಯಾವ ಶುದ್ಧೀಕರಣ ಹಂತಗಳನ್ನು ಅನ್ವಯಿಸಿದ್ದೀರಿ ಮತ್ತು ಏಕೆ ಎಂದು ಗಮನದಲ್ಲಿಡಿ, ಏಕೆಂದರೆ ಇದು ಪುನರಾವರ್ತನೆ ಮತ್ತು ಪಾರದರ್ಶಕತೆಯಿಗಾಗಿ ಮುಖ್ಯವಾಗಿದೆ.\n",
"\n",
"> **ಉತ್ತಮ ಅಭ್ಯಾಸ:** ನಿಮ್ಮ ಮೂಲ \"ಕಳಪೆ\" ಡೇಟಾದ ಪ್ರತಿಯನ್ನು ಸದಾ ಇಟ್ಟುಕೊಳ್ಳಿ. ನಿಮ್ಮ ಮೂಲ ಡೇಟಾ ಫೈಲ್‌ಗಳನ್ನು ಮರುಬರೆಯಬೇಡಿ - `data_cleaned.csv` ಹೋಲುವ ಸ್ಪಷ್ಟ ಹೆಸರಿನ ನಿಯಮಗಳೊಂದಿಗೆ ಶುದ್ಧೀಕೃತ ಆವೃತ್ತಿಗಳನ್ನು ರಚಿಸಿ.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ಅಸ್ವೀಕರಣ**: \nಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\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-12-19T17:32:39+00:00",
"source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
"language_code": "kn"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
Reference in new issue View Git Blame Copy Permalink