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/ta/2-Working-With-Data/08-data-preparation/notebook.ipynb

4241 lines
170 KiB
Raw Permalink Blame History Escape

This file contains ambiguous Unicode characters!

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

{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "rQ8UhzFpgRra"
},
"source": [
"# தரவுத் தயாரிப்பு\n",
"\n",
"[மூல நோட்புக் ஆதாரம் *தரவியல்: தரவியல் Python மற்றும் Machine Learning Studio கற்கும் இயந்திர கற்றலுக்கான அறிமுகம் - லீ ஸ்டாட்*](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-ல் அவர் எழுதிய \"Taxonomic பிரச்சினைகளில் பல அளவீடுகளைப் பயன்படுத்துதல்\" என்ற கட்டுரையில் பயன்படுத்தப்பட்டது:\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_df` என்ற மாறியில் Iris Dataset-ஐ ஏற்றியுள்ளோம். தரவுகளை ஆராய்வதற்கு முன், எத்தனை தரவுப் புள்ளிகள் உள்ளன மற்றும் தரவுத்தொகுப்பின் மொத்த அளவு என்ன என்பதை அறிந்துகொள்வது பயனுள்ளதாக இருக்கும். நாம் கையாளும் தரவின் அளவைப் பார்ப்பது முக்கியம்.\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LOe5jQohhulf",
"outputId": "fb0577ac-3b4a-4623-cb41-20e1b264b3e9"
},
"outputs": [
{
"data": {
"text/plain": [
"(150, 4)"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.shape"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "smE7AGzOhxk2"
},
"source": [
"அப்படியானால், நாங்கள் 150 வரிசைகள் மற்றும் 4 நெடுவரிசைகளைக் கொண்ட தரவுகளை கையாளுகிறோம். ஒவ்வொரு வரிசையும் ஒரு தரவுப் புள்ளியை பிரதிநிதித்துவப்படுத்துகிறது, மேலும் ஒவ்வொரு நெடுவரிசையும் தரவுச் சட்டகத்துடன் தொடர்புடைய ஒரு தனித்தன்மையை பிரதிநிதித்துவப்படுத்துகிறது. அடிப்படையாக, 150 தரவுப் புள்ளிகள் உள்ளன, ஒவ்வொன்றும் 4 தனித்தன்மைகளை கொண்டுள்ளது.\n",
"\n",
"`shape` என்பது இங்கு dataframe இன் ஒரு பண்பாகும், ஒரு செயல்பாடு அல்ல, அதனால் இது ஒரு ஜோடி வட்டக் கோடுகளால் முடிவடைவதில்லை.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "d3AZKs0PinGP"
},
"source": [
"### `DataFrame.columns`\n",
"இப்போது நான்கு களங்களின் தரவுக்குள் செல்லலாம். ஒவ்வொன்றும் என்னைச் சரியாக பிரதிநிதித்துவப்படுத்துகிறது? `columns` பண்புக்கூறு dataframe இல் உள்ள களங்களின் பெயரை எங்களுக்கு வழங்கும்.\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) sütunlar உள்ளன. `columns` பண்புக்கூறு sütunların பெயர்களைச் சொல்கிறது மற்றும் அடிப்படையில் வேறொன்றும் இல்லை. இந்த பண்புக்கூறு ஒரு dataset உள்ள அம்சங்களை அடையாளம் காண விரும்பும்போது முக்கியத்துவம் பெறுகிறது.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2UTlvkjmgRrs"
},
"source": [
"### `DataFrame.info`\n",
"`shape` பண்புக்கூறு மூலம் தரப்பட்ட தரவின் அளவு மற்றும் `columns` பண்புக்கூறு மூலம் தரப்பட்ட அம்சங்கள் அல்லது நெடுக்களின் பெயர்கள் dataset பற்றி எதையாவது கூறுகின்றன. இப்போது, நாம் dataset-ஐ மேலும் ஆழமாக ஆராய விரும்புகிறோம். `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. Non-Null மதிப்புகளின் எண்ணிக்கை: Null மதிப்புகளை கையாளுவது தரவுத் தயாரிப்பில் ஒரு முக்கியமான படியாகும். இது பின்னர் நோட்புக்கில் கையாளப்படும். \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",
"மேலே உள்ள அனைத்து செயல்பாடுகள் மற்றும் பண்புகளுடன், தரவுத்தொகுப்பின் மேல் நிலைப் பார்வையை பெற்றுள்ளோம். எத்தனை தரவுப் புள்ளிகள் உள்ளன, எத்தனை அம்சங்கள் உள்ளன, ஒவ்வொரு அம்சத்தின் தரவுத் வகை மற்றும் ஒவ்வொரு அம்சத்திற்கும் non-null மதிப்புகளின் எண்ணிக்கை ஆகியவற்றை அறிந்துள்ளோம்.\n",
"\n",
"இப்போது தரவுகளை நேரடியாகப் பார்க்க நேரம் வந்துள்ளது. எங்கள் `DataFrame`-இன் முதல் சில வரிகள் (முதல் சில தரவுப் புள்ளிகள்) எப்படி இருக்கின்றன என்பதை பார்ப்போம்:\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "DZMJZh0OgRrw",
"outputId": "d9393ee5-c106-4797-f815-218f17160e00",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>5.1</td>\n",
" <td>3.5</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>4.9</td>\n",
" <td>3.0</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>4.7</td>\n",
" <td>3.2</td>\n",
" <td>1.3</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>4.6</td>\n",
" <td>3.1</td>\n",
" <td>1.5</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>5.0</td>\n",
" <td>3.6</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"0 5.1 3.5 1.4 0.2\n",
"1 4.9 3.0 1.4 0.2\n",
"2 4.7 3.2 1.3 0.2\n",
"3 4.6 3.1 1.5 0.2\n",
"4 5.0 3.6 1.4 0.2"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EBHEimZuEFQK"
},
"source": [
"இங்கே உள்ள வெளியீட்டைப் பார்க்கும்போது, தரவுத்தொகுப்பின் ஐந்து(5) பதிவுகளை காணலாம். இடதுபுறத்தில் உள்ள குறியீட்டைப் பார்க்கும்போது, இவை முதல் ஐந்து வரிசைகள் என்பதை கண்டறிகிறோம்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oj7GkrTdgRry"
},
"source": [
"### பயிற்சி:\n",
"\n",
"மேற்கண்ட எடுத்துக்காட்டில் இருந்து, இயல்பாக, `DataFrame.head` ஒரு `DataFrame`-இன் முதல் ஐந்து வரிசைகளை திருப்பி அளிக்கிறது என்பது தெளிவாகிறது. கீழே உள்ள குறியீட்டு செல்லில், ஐந்து வரிசைகளுக்கு மேல் காட்ட ஒரு வழியை கண்டுபிடிக்க முடியுமா?\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": true,
"id": "EKRmRFFegRrz",
"trusted": false
},
"outputs": [],
"source": [
"# Hint: Consult the documentation by using iris_df.head?"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BJ_cpZqNgRr1"
},
"source": [
"### `DataFrame.tail`\n",
"தரவைப் பார்க்கும் மற்றொரு வழி முடிவிலிருந்து (தொடக்கத்தின் பதிலாக) இருக்கலாம். `DataFrame.head`-இன் எதிர்மறை `DataFrame.tail` ஆகும், இது ஒரு `DataFrame`-இன் கடைசி ஐந்து வரிசைகளை திருப்பி அளிக்கிறது:\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "heanjfGWgRr2",
"outputId": "6ae09a21-fe09-4110-b0d7-1a1fbf34d7f3",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>145</th>\n",
" <td>6.7</td>\n",
" <td>3.0</td>\n",
" <td>5.2</td>\n",
" <td>2.3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>146</th>\n",
" <td>6.3</td>\n",
" <td>2.5</td>\n",
" <td>5.0</td>\n",
" <td>1.9</td>\n",
" </tr>\n",
" <tr>\n",
" <th>147</th>\n",
" <td>6.5</td>\n",
" <td>3.0</td>\n",
" <td>5.2</td>\n",
" <td>2.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>148</th>\n",
" <td>6.2</td>\n",
" <td>3.4</td>\n",
" <td>5.4</td>\n",
" <td>2.3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>149</th>\n",
" <td>5.9</td>\n",
" <td>3.0</td>\n",
" <td>5.1</td>\n",
" <td>1.8</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"145 6.7 3.0 5.2 2.3\n",
"146 6.3 2.5 5.0 1.9\n",
"147 6.5 3.0 5.2 2.0\n",
"148 6.2 3.4 5.4 2.3\n",
"149 5.9 3.0 5.1 1.8"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.tail()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "31kBWfyLgRr3"
},
"source": [
"நடப்பில், `DataFrame`-இன் முதல் சில வரிசைகள் அல்லது கடைசி சில வரிசைகளை எளிதாகப் பார்வையிட முடிவது மிகவும் பயனுள்ளதாக இருக்கும், குறிப்பாக ஒழுங்குபடுத்தப்பட்ட தரவுத்தொகுப்புகளில் வெளிப்படையான மதிப்புகளைத் தேடும்போது.\n",
"\n",
"மேலே கொடுக்கப்பட்ட கோடுகளின் உதவியுடன் காட்டப்பட்ட அனைத்து செயல்பாடுகள் மற்றும் பண்புகள், தரவின் தோற்றத்தையும் உணர்வையும் பெற உதவுகின்றன.\n",
"\n",
"> **முக்கியக் குறிப்புகள்:** ஒரு DataFrame-இல் உள்ள தகவலின் மெட்டாடேட்டா அல்லது அதில் உள்ள முதல் மற்றும் கடைசி சில மதிப்புகளைப் பார்ப்பதன் மூலம், நீங்கள் கையாளும் தரவின் அளவு, வடிவம் மற்றும் உள்ளடக்கத்தை உடனடியாகப் புரிந்துகொள்ள முடியும்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TvurZyLSDxq_"
},
"source": [
"### காணாமல் போன தரவுகள்\n",
"காணாமல் போன தரவுகளைப் பற்றி விரிவாகப் பார்ப்போம். சில காலங்களில், சில பத்திகளில் எந்த மதிப்பும் சேமிக்கப்படாதபோது காணாமல் போன தரவுகள் ஏற்படுகின்றன.\n",
"\n",
"ஒரு உதாரணத்தை எடுத்துக்கொள்வோம்: ஒருவருக்கு அவரது/அவளது எடை குறித்து கவலை இருந்தால், அவர் ஒரு கணக்கெடுப்பில் எடை புலத்தை நிரப்பாமல் விடுவார். அப்போது, அந்த நபரின் எடை மதிப்பு காணாமல் போயிருக்கும்.\n",
"\n",
"உலகளாவிய தரவுத்தொகுப்புகளில், பெரும்பாலான நேரங்களில், காணாமல் போன மதிப்புகள் ஏற்படுகின்றன.\n",
"\n",
"**Pandas காணாமல் போன தரவுகளை எவ்வாறு கையாளுகிறது**\n",
"\n",
"Pandas காணாமல் போன மதிப்புகளை இரண்டு வழிகளில் கையாளுகிறது. முதலில், நீங்கள் முந்தைய பிரிவுகளில் பார்த்த `NaN` (Not a Number) ஆகும். இது IEEE floating-point specification இன் ஒரு சிறப்பு மதிப்பாகும், மற்றும் இது காணாமல் போன floating-point மதிப்புகளை குறிக்க மட்டுமே பயன்படுத்தப்படுகிறது.\n",
"\n",
"Floating-point மதிப்புகளைத் தவிர, காணாமல் போன மதிப்புகளுக்கு pandas Python இன் `None` பொருளைப் பயன்படுத்துகிறது. இரண்டு விதமான மதிப்புகளை சந்திக்க நேரிடும் போது இது குழப்பமாக இருக்கலாம் என்று தோன்றினாலும், இந்த வடிவமைப்பு தேர்வுக்கு ஒழுங்கான நிரலாக்க காரணங்கள் உள்ளன, மேலும் நடைமுறையில், இந்த வழி pandas-க்கு பெரும்பாலான சந்தர்ப்பங்களில் நல்ல சமநிலையை வழங்க உதவுகிறது. இதைத் தவிர, `None` மற்றும் `NaN` இரண்டிலும் சில கட்டுப்பாடுகள் உள்ளன, அவற்றை எவ்வாறு பயன்படுத்த வேண்டும் என்பதில் நீங்கள் கவனமாக இருக்க வேண்டும்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lOHqUlZFgRr5"
},
"source": [
"### `None`: non-float மிஸ்ஸிங் டேட்டா\n",
"`None` என்பது Python-இல் இருந்து வந்ததால், இது NumPy மற்றும் pandas அடர்த்திகளில் `'object'` டேட்டா வகை அல்லாதவற்றில் பயன்படுத்த முடியாது. நினைவில் கொள்ளுங்கள், NumPy அடர்த்திகள் (மற்றும் pandas-இல் உள்ள டேட்டா அமைப்புகள்) ஒரே வகையான டேட்டாவை மட்டுமே கொண்டிருக்க முடியும். இதுவே பெரிய அளவிலான டேட்டா மற்றும் கணினி வேலைகளுக்கு அவற்றின் மிகப்பெரிய சக்தியை வழங்குகிறது, ஆனால் இது அவற்றின் நெகிழ்வுத்தன்மையை வரையறுக்கிறது. இவ்வகையான அடர்த்திகள் \"குறைந்த பொதுவான பரிமாணம்\" எனப்படும், அதாவது அடர்த்தியில் உள்ள அனைத்தையும் உள்ளடக்கக்கூடிய டேட்டா வகைக்கு மேம்படுத்தப்பட வேண்டும். `None` அடர்த்தியில் இருந்தால், நீங்கள் Python பொருட்களுடன் வேலை செய்கிறீர்கள் என்று பொருள்.\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 குறியீட்டின் மட்டத்தில் செயல்படுத்தப்படும். அடிப்படையாக, இதன் பொருள் `Series` அல்லது `DataFrames`-இல் `None` உள்ள செயல்பாடுகள் மெதுவாக இருக்கும். நீங்கள் இந்த செயல்திறன் குறைவைக் கவனிக்காமல் இருக்கலாம், ஆனால் பெரிய தரவுத்தொகுப்புகளுக்கு இது ஒரு பிரச்சனையாக மாறக்கூடும்.\n",
"\n",
"இரண்டாவது பக்க விளைவு முதல் விளைவிலிருந்து தோன்றுகிறது. ஏனெனில் `None` அடிப்படையாக `Series` அல்லது `DataFrame`s-ஐ சாதாரண Python உலகிற்கு திரும்பத் தள்ளுகிறது, `sum()` அல்லது `min()` போன்ற NumPy/pandas தொகுப்புகளை `None` மதிப்புகளை கொண்ட வரிசைகளில் பயன்படுத்துவது பொதுவாக ஒரு பிழையை உருவாக்கும்:\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 292
},
"id": "gWbx-KB9gRr8",
"outputId": "ecba710a-22ec-41d5-a39c-11f67e645b50",
"trusted": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "ignored",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-10-ce9901ad18bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 45\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m 46\u001b[0m initial=_NoValue, where=True):\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwhere\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n",
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'"
]
}
],
"source": [
"example1.sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LcEwO8UogRr9"
},
"source": [
"**முக்கியக் குறிப்புகள்**: முழு எண்கள் மற்றும் `None` மதிப்புகளுக்கு இடையிலான கூட்டல் (மற்றும் பிற செயல்பாடுகள்) வரையறுக்கப்படவில்லை, இது அவற்றைக் கொண்ட தரவுத்தொகுப்புகளுடன் நீங்கள் செய்யக்கூடியவற்றை வரையறுக்க முடியும்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pWvVHvETgRr9"
},
"source": [
"### `NaN`: மிஸ்ஸிங் ஃப்ளோட் மதிப்புகள்\n",
"\n",
"`None`-க்கு மாறாக, NumPy (அதனால் pandas) அதன் வேகமான, வெக்டரைச்ட் செயல்பாடுகள் மற்றும் ufuncs-க்கு `NaN`-ஐ ஆதரிக்கிறது. மோசமான செய்தி என்னவென்றால், `NaN`-இல் செய்யப்படும் எந்த கணித செயல்பாடும் எப்போதும் `NaN`-ஐ உருவாக்கும். உதாரணமாக:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "rcFYfMG9gRr9",
"outputId": "699e81b7-5c11-4b46-df1d-06071768690f",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan + 1"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "BW3zQD2-gRr-",
"outputId": "4525b6c4-495d-4f7b-a979-efce1dae9bd0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan * 0"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fU5IPRcCgRr-"
},
"source": [
"நல்ல செய்தி: `NaN` உள்ள வரிசைகளில் தொகுப்புகள் இயக்கப்படும் போது பிழைகள் தோன்றவில்லை. கெட்ட செய்தி: முடிவுகள் ஒரே மாதிரியான பயனுள்ளவை அல்ல:\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LCInVgSSgRr_",
"outputId": "fa06495a-0930-4867-87c5-6023031ea8b5",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"(nan, nan, nan)"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example2 = np.array([2, np.nan, 6, 8]) \n",
"example2.sum(), example2.min(), example2.max()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nhlnNJT7gRr_"
},
"source": [
"### பயிற்சி:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true,
"id": "yan3QRaOgRr_",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you add np.nan and None together?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_iDvIRC8gRsA"
},
"source": [
"நினைவில் கொள்ளவும்: `NaN` என்பது மிஸ்ஸிங் ப்ளோட்டிங்-பாயிண்ட் மதிப்புகளுக்காக மட்டுமே; முழு எண்கள், சரங்கள் அல்லது பூலியன்களுக்கு `NaN` சமமானது இல்லை.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kj6EKdsAgRsA"
},
"source": [
"### `NaN` மற்றும் `None`: pandas-இல் null மதிப்புகள்\n",
"\n",
"`NaN` மற்றும் `None` சில அளவுக்கு வேறுபடக்கூடியதாக செயல்படினாலும், pandas அவற்றை பரஸ்பரம் மாற்றி நடத்துவதற்காக உருவாக்கப்பட்டுள்ளது. இதை விளக்கமாகப் புரிந்துகொள்ள, முழு எண்களின் ஒரு `Series`-ஐ கவனிக்கவும்:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Nji-KGdNgRsA",
"outputId": "36aa14d2-8efa-4bfd-c0ed-682991288822",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 1\n",
"1 2\n",
"2 3\n",
"dtype: int64"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"int_series = pd.Series([1, 2, 3], dtype=int)\n",
"int_series"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WklCzqb8gRsB"
},
"source": [
"### பயிற்சி:\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": true,
"id": "Cy-gqX5-gRsB",
"trusted": false
},
"outputs": [],
"source": [
"# Now set an element of int_series equal to None.\n",
"# How does that element show up in the Series?\n",
"# What is the dtype of the Series?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WjMQwltNgRsB"
},
"source": [
"`Series` மற்றும் `DataFrame`களில் தரவின் ஒரே மாதிரியான தன்மையை உருவாக்கும் நோக்கில் தரவின் வகைகளை மேம்படுத்தும் செயல்முறையில், pandas `None` மற்றும் `NaN` ஆகியவற்றை காணாமல் போன மதிப்புகளுக்கு இடையே மாற்றுவதற்கு தயங்காது. இந்த வடிவமைப்பு அம்சத்தால், pandas-இல் `None` மற்றும் `NaN` ஆகியவற்றை \"null\" எனும் இரண்டு வெவ்வேறு வகைகளாக கருதுவது பயனுள்ளதாக இருக்கலாம். உண்மையில், pandas-இல் காணாமல் போன மதிப்புகளை நிர்வகிக்க நீங்கள் பயன்படுத்தும் முக்கியமான சில முறைமைகள் இந்த கருத்தை அவர்களின் பெயர்களில் பிரதிபலிக்கின்றன:\n",
"\n",
"- `isnull()`: காணாமல் போன மதிப்புகளை குறிக்கும் Boolean மாஸ்கை உருவாக்குகிறது\n",
"- `notnull()`: `isnull()`-க்கு எதிர்மாறானது\n",
"- `dropna()`: தரவின் வடிகட்டப்பட்ட பதிப்பை திருப்பி வழங்குகிறது\n",
"- `fillna()`: காணாமல் போன மதிப்புகளை நிரப்பிய அல்லது மதிப்பீடு செய்த தரவின் நகலை திருப்பி வழங்குகிறது\n",
"\n",
"இந்த முறைமைகள் மிகவும் முக்கியமானவை, மேலும் அவற்றை நன்கு புரிந்து கொண்டு பயன்படுத்துவதில் நிபுணத்துவம் பெறுவது அவசியம். எனவே, இவற்றை ஒவ்வொன்றாக விரிவாகப் பார்ப்போம்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Yh5ifd9FgRsB"
},
"source": [
"### வெற்றிட மதிப்புகளை கண்டறிதல்\n",
"\n",
"இப்போது வெற்றிட மதிப்புகளின் முக்கியத்துவத்தை நாங்கள் புரிந்துகொண்டுள்ளோம், அவற்றை சமாளிப்பதற்கு முன், அவற்றை எங்கள் தரவுத்தொகுப்பில் கண்டறிய வேண்டும். \n",
"`isnull()` மற்றும் `notnull()` ஆகியவை வெற்றிட தரவுகளை கண்டறிய உங்கள் முதன்மை முறைகள் ஆகும். இரண்டும் உங்கள் தரவின் மீது Boolean முகமூடிகளை திருப்பி அனுப்பும்.\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": true,
"id": "e-vFp5lvgRsC",
"trusted": false
},
"outputs": [],
"source": [
"example3 = pd.Series([0, np.nan, '', None])"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "1XdaJJ7PgRsC",
"outputId": "92fc363a-1874-471f-846d-f4f9ce1f51d0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 False\n",
"1 True\n",
"2 False\n",
"3 True\n",
"dtype: bool"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3.isnull()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PaSZ0SQygRsC"
},
"source": [
"வெளியீட்டை நன்றாக கவனமாக பாருங்கள். இதில் ஏதேனும் உங்களை ஆச்சரியப்படுத்துகிறதா? `0` என்பது கணித ரீதியில் null ஆக இருந்தாலும், இது ஒரு சரியான முழு எண் மற்றும் pandas இதை அப்படியே ஏற்றுக்கொள்கிறது. `''` என்பது கொஞ்சம் நுணுக்கமானது. இதை Section 1-ல் காலியான string மதிப்பை பிரதிநிதித்துவப்படுத்த பயன்படுத்தினாலும், pandas-க்கு இது null ஆக இல்லாமல் ஒரு string பொருளாகவே உள்ளது.\n",
"\n",
"இப்போது, இதை மாற்றி, நீங்கள் நடைமுறையில் பயன்படுத்தும் விதத்தில் இந்த முறைகளை பயன்படுத்துவோம். Boolean masks-ஐ நேரடியாக ``Series`` அல்லது ``DataFrame`` index ஆக பயன்படுத்தலாம், இது தனித்த missing (அல்லது உள்ள) மதிப்புகளுடன் வேலை செய்யும்போது பயனுள்ளதாக இருக்கும்.\n",
"\n",
"நாம் missing values-இன் மொத்த எண்ணிக்கையை அறிய விரும்பினால், `isnull()` முறை உருவாக்கும் mask-ஐப் பயன்படுத்தி ஒரு sum செய்யலாம்.\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "JCcQVoPkHDUv",
"outputId": "001daa72-54f8-4bd5-842a-4df627a79d4d"
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3.isnull().sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PlBqEo3mgRsC"
},
"source": [
"### பயிற்சி:\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": true,
"id": "ggDVf5uygRsD",
"trusted": false
},
"outputs": [],
"source": [
"# Try running example3[example3.notnull()].\n",
"# Before you do so, what do you expect to see?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D_jWN7mHgRsD"
},
"source": [
"**முக்கியக் குறிப்புகள்**: `isnull()` மற்றும் `notnull()` முறைகள் இரண்டும் DataFrames-ல் பயன்படுத்தும்போது ஒரே மாதிரியான முடிவுகளை உருவாக்குகின்றன: அவை முடிவுகளை மற்றும் அந்த முடிவுகளின் குறியீட்டை காட்டுகின்றன, இது உங்கள் தரவுடன் போராடும் போது உங்களுக்கு மிகுந்த உதவியாக இருக்கும்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BvnoojWsgRr4"
},
"source": [
"### காணாமல் போன தரவுகளை கையாளுதல்\n",
"\n",
"> **கற்றல் இலக்கு:** இந்த துணைப்பகுதியின் முடிவில், DataFrames-இல் null மதிப்புகளை எப்போது மற்றும் எப்படி மாற்றுவது அல்லது நீக்குவது என்பதை நீங்கள் அறிந்திருக்க வேண்டும்.\n",
"\n",
"Machine Learning மாதிரிகள் காணாமல் போன தரவுகளை நேரடியாக கையாள முடியாது. எனவே, தரவுகளை மாதிரியில் அனுப்புவதற்கு முன், இந்த காணாமல் போன மதிப்புகளை கையாள வேண்டும்.\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": [
"(பாண்டாஸ் இரண்டு களங்களை `NaN`களை ஏற்க floats ஆக மாற்றியது கவனித்தீர்களா?)\n",
"\n",
"நீங்கள் ஒரு `DataFrame`-இல் இருந்து ஒரு மதிப்பை மட்டும் நீக்க முடியாது, எனவே முழு வரிசைகள் அல்லது களங்களை நீக்க வேண்டும். நீங்கள் என்ன செய்கிறீர்கள் என்பதற்கேற்ப, ஒன்று அல்லது மற்றொன்றை செய்ய விரும்பலாம், எனவே பாண்டாஸ் இரண்டிற்கும் விருப்பங்களை வழங்குகிறது. காரணம், தரவியல் அறிவியலில், களங்கள் பொதுவாக மாறிகள் மற்றும் வரிசைகள் கண்காணிப்புகளை பிரதிநிதித்துவப்படுத்துகின்றன, நீங்கள் தரவின் வரிசைகளை நீக்க அதிகமாக வாய்ப்பு உள்ளது; `dropna()`-இன் இயல்பான அமைப்பு எந்த null மதிப்புகளையும் கொண்டுள்ள அனைத்து வரிசைகளையும் நீக்குவதற்காக அமைக்கப்பட்டுள்ளது:\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 80
},
"id": "jAVU24RXgRsE",
"outputId": "0b5e5aee-7187-4d3f-b583-a44136ae5f80",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"1 2.0 5.0 8"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TrQRBuTDgRsE"
},
"source": [
"தேவையானால், நீங்கள் நெடுவரிசைகளிலிருந்து NA மதிப்புகளை நீக்கலாம். இதற்கு `axis=1` ஐ பயன்படுத்தவும்:\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "GrBhxu9GgRsE",
"outputId": "ff4001f3-2e61-4509-d60e-0093d1068437",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>8</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 2\n",
"0 7\n",
"1 8\n",
"2 9"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna(axis='columns')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "KWXiKTfMgRsF"
},
"source": [
"குறிப்பாக, இது சிறிய தரவுத்தொகுப்புகளில் நீங்கள் வைத்திருக்க விரும்பும் பல தரவுகளை நீக்கக்கூடும். நீங்கள் பல அல்லது அனைத்து null மதிப்புகளை கொண்ட வரிசைகள் அல்லது நெடுவரிசைகளை மட்டும் நீக்க விரும்பினால் என்ன செய்ய வேண்டும்? `dropna`-இல் `how` மற்றும் `thresh` அளவுருக்களை குறிப்பிடலாம்.\n",
"\n",
"இயல்பாக, `how='any'` (நீங்கள் சுயமாக சரிபார்க்க விரும்பினால் அல்லது முறை எந்த அளவுருக்களை கொண்டுள்ளது என்பதைப் பார்க்க விரும்பினால், ஒரு குறியீட்டு செலில் `example4.dropna?` இயக்கவும்). மாற்றாக, `how='all'`-ஐ குறிப்பிடலாம், இதனால் அனைத்து null மதிப்புகளை கொண்ட வரிசைகள் அல்லது நெடுவரிசைகளை மட்டும் நீக்கலாம். இதை செயல்பாட்டில் காண, நமது `DataFrame` எடுத்துக்காட்டை விரிவாக்கி, அடுத்த பயிற்சியில் இதைப் பார்ப்போம்.\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "Bcf_JWTsgRsF",
"outputId": "72e0b1b8-52fa-4923-98ce-b6fbed6e44b1",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 NaN 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 NaN 6.0 9 NaN"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4[3] = np.nan\n",
"example4"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pNZer7q9JPNC"
},
"source": [
"> முக்கிய குறிப்புகள்: \n",
"1. தரவுத்தொகுப்பு பெரியதாக இருந்தால் மட்டுமே null மதிப்புகளை நீக்குவது நல்ல யோசனை. \n",
"2. முழு வரிசைகள் அல்லது நெடுவரிசைகள் பெரும்பாலான தரவுகள் இல்லை என்றால் அவற்றை நீக்கலாம். \n",
"3. `DataFrame.dropna(axis=)` முறை null மதிப்புகளை நீக்க உதவுகிறது. `axis` аргументம் வரிசைகளை நீக்க வேண்டுமா அல்லது நெடுவரிசைகளை நீக்க வேண்டுமா என்பதை குறிப்பிடுகிறது. \n",
"4. `how` аргументம் கூட பயன்படுத்தப்படலாம். இயல்பாக இது `any` ஆக அமைக்கப்பட்டுள்ளது. எனவே, எந்த null மதிப்புகளையும் கொண்டுள்ள வரிசைகள்/நெடுவரிசைகளை மட்டும் இது நீக்குகிறது. இதை `all` ஆக அமைக்கலாம், அதனால் அனைத்து மதிப்புகளும் null ஆக இருக்கும் வரிசைகள்/நெடுவரிசைகளை மட்டும் நாம் நீக்குவோம் என்று குறிப்பிடலாம். \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oXXSfQFHgRsF"
},
"source": [
"### பயிற்சி:\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": true,
"id": "ExUwQRxpgRsF",
"trusted": false
},
"outputs": [],
"source": [
"# How might you go about dropping just column 3?\n",
"# Hint: remember that you will need to supply both the axis parameter and the how parameter.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "38kwAihWgRsG"
},
"source": [
"`thresh` அளவுரு உங்களுக்கு நுண்ணிய கட்டுப்பாட்டை வழங்குகிறது: ஒரு வரி அல்லது நெடுவரிசை வைத்திருக்க தேவையான *non-null* மதிப்புகளின் எண்ணிக்கையை நீங்கள் அமைக்கலாம்:\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": [
"இங்கு, முதல் மற்றும் கடைசி வரிகள் நீக்கப்பட்டுள்ளன, ஏனெனில் அவற்றில் இரண்டு non-null மதிப்புகள் மட்டுமே உள்ளன.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mCcxLGyUgRsG"
},
"source": [
"### வெற்றிட மதிப்புகளை நிரப்புதல்\n",
"\n",
"சில நேரங்களில், வெற்றிட மதிப்புகளை சரியானதாக இருக்கக்கூடியவற்றால் நிரப்புவது பொருத்தமாக இருக்கலாம். வெற்றிட மதிப்புகளை நிரப்ப சில நுட்பங்கள் உள்ளன. முதலில், டொமைன் அறிவு (தொகுப்பின் அடிப்படையாக உள்ள பொருள் பற்றிய அறிவு) பயன்படுத்தி, எப்படியாவது வெற்றிட மதிப்புகளை அணுகுமுறை செய்யலாம்.\n",
"\n",
"நீங்கள் `isnull` ஐ பயன்படுத்தி இதை நேரடியாக செய்யலாம், ஆனால் இது கடினமாக இருக்கலாம், குறிப்பாக நீங்கள் நிரப்ப வேண்டிய மதிப்புகள் அதிகமாக இருந்தால். தரவியல் அறிவியலில் இது மிகவும் பொதுவான பணியாக இருப்பதால், pandas `fillna` ஐ வழங்குகிறது, இது உங்கள் தேர்வின் மூலம் வெற்றிட மதிப்புகளை மாற்றியமைக்கப்பட்ட `Series` அல்லது `DataFrame` இன் ஒரு நகலை திருப்புகிறது. இது நடைமுறையில் எப்படி செயல்படுகிறது என்பதை பார்க்க மற்றொரு உதாரண `Series` ஐ உருவாக்குவோம்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CE8S7louLezV"
},
"source": [
"### வகை தரவுகள் (எண் சார்ந்தவை அல்ல)\n",
"முதலில், எண் சார்ந்தவை அல்லாத தரவுகளைப் பார்ப்போம். தரவுத்தொகுப்புகளில், வகை தரவுகளைக் கொண்ட நெடுவரிசைகள் இருக்கும். உதாரணமாக, பாலினம், உண்மை அல்லது தவறு போன்றவை.\n",
"\n",
"இவற்றில் பெரும்பாலான சந்தர்ப்பங்களில், நாங்கள் குறைவான மதிப்புகளை அந்த நெடுவரிசையின் `mode` மூலம் மாற்றுகிறோம். உதாரணமாக, 100 தரவுப் புள்ளிகள் உள்ளன, அதில் 90 பேர் \"உண்மை\" என்று கூறியுள்ளனர், 8 பேர் \"தவறு\" என்று கூறியுள்ளனர், மேலும் 2 பேர் எந்தவிதமான தகவலையும் நிரப்பவில்லை. அப்போது, முழு நெடுவரிசையைப் பொருத்து, அந்த 2 இடங்களை \"உண்மை\" என நிரப்பலாம்.\n",
"\n",
"இங்கு மீண்டும், துறையியல் அறிவைப் பயன்படுத்தலாம். `mode` மூலம் நிரப்புவதற்கான ஒரு உதாரணத்தைப் பார்ப்போம்.\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "MY5faq4yLdpQ",
"outputId": "19ab472e-1eed-4de8-f8a7-db2a3af3cb1a"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>None</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 None\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode = pd.DataFrame([[1,2,\"True\"],\n",
" [3,4,None],\n",
" [5,6,\"False\"],\n",
" [7,8,\"True\"],\n",
" [9,10,\"True\"]])\n",
"\n",
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MLAoMQOfNPlA"
},
"source": [
"இப்போது, முதலில் `None` மதிப்பை mode மூலம் நிரப்புவதற்கு முன் mode ஐ கண்டுபிடிப்போம்.\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "WKy-9Y2tN5jv",
"outputId": "8da9fa16-e08c-447e-dea1-d4b1db2feebf"
},
"outputs": [
{
"data": {
"text/plain": [
"True 3\n",
"False 1\n",
"Name: 2, dtype: int64"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode[2].value_counts()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6iNz_zG_OKrx"
},
"source": [
"அதனால், None ஐ True ஆக மாற்றுவோம்\n"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"id": "TxPKteRvNPOs"
},
"outputs": [],
"source": [
"fill_with_mode[2].fillna('True',inplace=True)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "tvas7c9_OPWE",
"outputId": "ec3c8e44-d644-475e-9e22-c65101965850"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 True\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "SktitLxxOR16"
},
"source": [
"நாம் காணக்கூடியதுபோல், null மதிப்பு மாற்றப்பட்டுள்ளது. 'True' என்பதற்குப் பதிலாக எதையும் எழுதியிருக்கலாம், அது மாற்றப்பட்டிருக்கும்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "heYe1I0dOmQ_"
},
"source": [
"### எண் தரவுகள்\n",
"இப்போது, எண் தரவுகளுக்கு வருகிறோம். இங்கே, காணாமல் போன மதிப்புகளை மாற்றுவதற்கான இரண்டு பொதுவான முறைகள் உள்ளன:\n",
"\n",
"1. வரிசையின் நடுக்கோட்டுடன் மாற்றவும் \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. வகைப்பாட்டுத் தரவுகளுக்கு, பெரும்பாலும், பிழையான மதிப்புகள் அந்த நெடுவரிசையின் முறை (mode) மூலம் மாற்றப்படுகின்றன.\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": [
"நீங்கள் **முன்னே-fill** செய்யும் null மதிப்புகளை நிரப்பலாம், அதாவது கடைசி செல்லுபடியாகும் மதிப்பை null நிரப்ப பயன்படுத்தலாம்:\n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "vO3BuNrggRsI",
"outputId": "e2bc591b-0b48-4e88-ee65-754f2737c196",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 1.0\n",
"c 2.0\n",
"d 2.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(method='ffill')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nDXeYuHzgRsI"
},
"source": [
"நீங்கள் அடுத்த செல்லுபடியாகும் மதிப்பை பின்புறமாக பரப்ப **பின்நிரப்ப**வும் செய்து ஒரு வெற்றிடத்தை நிரப்பலாம்:\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "4M5onHcEgRsI",
"outputId": "8f32b185-40dd-4a9f-bd85-54d6b6a414fe",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 2.0\n",
"c 2.0\n",
"d 3.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(method='bfill')"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"id": "MbBzTom5gRsI"
},
"source": [
"நீங்கள் ஊகிக்கலாம் போல, இது DataFrames உடன் ஒரே மாதிரியான முறையில் செயல்படுகிறது, ஆனால் நீங்கள் null மதிப்புகளை நிரப்ப ஒரு `axis` ஐ குறிப்பிடவும் முடியும்:\n"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "aRpIvo4ZgRsI",
"outputId": "905a980a-a808-4eca-d0ba-224bd7d85955",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 NaN 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 NaN 6.0 9 NaN"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "VM1qtACAgRsI",
"outputId": "71f2ad28-9b4e-4ff4-f5c3-e731eb489ade",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>1.0</td>\n",
" <td>7.0</td>\n",
" <td>7.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8.0</td>\n",
" <td>8.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9.0</td>\n",
" <td>9.0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 1.0 7.0 7.0\n",
"1 2.0 5.0 8.0 8.0\n",
"2 NaN 6.0 9.0 9.0"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.fillna(method='ffill', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ZeMc-I1EgRsI"
},
"source": [
"முன்னைய மதிப்பு முன்னோக்கி நிரப்புவதற்கு கிடைக்காதபோது, வெற்றிட மதிப்பு மாறாமல் இருக்கும் என்பதை கவனிக்கவும்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eeAoOU0RgRsJ"
},
"source": [
"### பயிற்சி:\n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": true,
"id": "e8S-CjW8gRsJ",
"trusted": false
},
"outputs": [],
"source": [
"# What output does example4.fillna(method='bfill', axis=1) produce?\n",
"# What about example4.fillna(method='ffill') or example4.fillna(method='bfill')?\n",
"# Can you think of a longer code snippet to write that can fill all of the null values in example4?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "YHgy0lIrgRsJ"
},
"source": [
"நீங்கள் `fillna` பயன்படுத்துவதில் சிருஷ்டியாக இருக்கலாம். உதாரணமாக, `example4` ஐ மீண்டும் பார்ப்போம், ஆனால் இந்த முறை `DataFrame` இல் உள்ள அனைத்து மதிப்புகளின் சராசரியுடன் காணாமல் போன மதிப்புகளை நிரப்புவோம்:\n"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "OtYVErEygRsJ",
"outputId": "708b1e67-45ca-44bf-a5ee-8b2de09ece73",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>5.5</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>1.5</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 5.5 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 1.5 6.0 9 NaN"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.fillna(example4.mean())"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zpMvCkLSgRsJ"
},
"source": [
"குறிப்பாக, மூன்றாவது நெடுவரிசை இன்னும் மதிப்பில்லாமல் உள்ளது: இயல்பான திசை மதிப்புகளை வரிசை வாரியாக நிரப்புவது.\n",
"\n",
"> **முக்கியக் கருத்து:** உங்கள் தரவுத்தொகுப்புகளில் காணப்படும் பிழைமதிப்புகளை சமாளிக்க பல வழிகள் உள்ளன. நீங்கள் பயன்படுத்தும் குறிப்பிட்ட உத்தி (அவற்றை நீக்குவது, மாற்றுவது, அல்லது எப்படி மாற்றுவது) அந்த தரவின் தன்மைகளால் தீர்மானிக்கப்பட வேண்டும். நீங்கள் தரவுத்தொகுப்புகளை அதிகமாக கையாளும் போது, பிழைமதிப்புகளை எப்படி சமாளிக்க வேண்டும் என்பதில் சிறந்த புரிதலை உருவாக்குவீர்கள்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bauDnESIl9FH"
},
"source": [
"### வகைமுறை தரவுகளை குறியாக்கம் செய்வது\n",
"\n",
"இயந்திரக் கற்றல் மாதிரிகள் எண் மற்றும் எண் வடிவிலான தரவுகளுடன் மட்டுமே செயல்பட முடியும். அவை \"ஆம்\" மற்றும் \"இல்லை\" என்பவற்றின் வித்தியாசத்தை புரிந்துகொள்ள முடியாது, ஆனால் 0 மற்றும் 1 என்பவற்றை வேறுபடுத்த முடியும். எனவே, காணாமல் போன மதிப்புகளை நிரப்பிய பிறகு, மாதிரி புரிந்துகொள்ள வகைமுறை தரவுகளை எண் வடிவமாக குறியாக்கம் செய்ய வேண்டும்.\n",
"\n",
"குறியாக்கம் இரண்டு வழிகளில் செய்யலாம். அடுத்ததாக அவற்றைப் பற்றி விவாதிக்கப் போகிறோம்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "uDq9SxB7mu5i"
},
"source": [
"**லேபல் என்கோடிங்**\n",
"\n",
"லேபல் என்கோடிங் என்பது ஒவ்வொரு வகையையும் ஒரு எண்ணாக மாற்றுவது ஆகும். உதாரணமாக, நாம் விமான பயணிகளின் தரவுத்தொகுப்பை எடுத்துக்கொண்டால், அதில் ['பிஸினஸ் கிளாஸ்', 'எகானமி கிளாஸ்', 'ஃபர்ஸ்ட் கிளாஸ்'] ஆகியவற்றில் இருந்து பயண வகையை கொண்ட ஒரு பத்தி இருக்கும். இதற்கு லேபல் என்கோடிங் செய்யப்படும் போது, இது [0,1,2] ஆக மாற்றப்படும். இதை ஒரு உதாரணமாகக் கொண்டு கோடில் பார்க்கலாம். எதிர்கால நோட்புக்குகளில் `scikit-learn` பற்றி கற்றுக்கொள்ள இருப்பதால், இங்கு அதை பயன்படுத்தமாட்டோம்.\n"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "1vGz7uZyoWHL",
"outputId": "9e252855-d193-4103-a54d-028ea7787b34"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>first class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 business class\n",
"1 20 first class\n",
"2 30 economy class\n",
"3 40 economy class\n",
"4 50 economy class\n",
"5 60 business class"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"label = pd.DataFrame([\n",
" [10,'business class'],\n",
" [20,'first class'],\n",
" [30, 'economy class'],\n",
" [40, 'economy class'],\n",
" [50, 'economy class'],\n",
" [60, 'business class']\n",
"],columns=['ID','class'])\n",
"label"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IDHnkwTYov-h"
},
"source": [
"முதல் sütunில் லேபல் குறியாக்கத்தை செய்ய, ஒவ்வொரு வகுப்பிற்கும் ஒரு எண்ணை ஒதுக்குவதற்கான வரைபடத்தை முதலில் வரையறுக்க வேண்டும், பின்னர் மாற்ற வேண்டும்.\n"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "ZC5URJG3o1ES",
"outputId": "aab0f1e7-e0f3-4c14-8459-9f9168c85437"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 0\n",
"1 20 2\n",
"2 30 1\n",
"3 40 1\n",
"4 50 1\n",
"5 60 0"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"class_labels = {'business class':0,'economy class':1,'first class':2}\n",
"label['class'] = label['class'].replace(class_labels)\n",
"label"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ftnF-TyapOPt"
},
"source": [
"எப்படி நாம் எதிர்பார்த்தோமோ, அவ்வாறே வெளியீடு பொருந்துகிறது. எனவே, எப்போது லேபல் என்கோடிங்கைப் பயன்படுத்த வேண்டும்? லேபல் என்கோடிங்கை பின்வரும் நிலைகளில் பயன்படுத்தலாம்: \n",
"1. வகைகளின் எண்ணிக்கை அதிகமாக இருக்கும் போது \n",
"2. வகைகள் வரிசையில் இருக்கும் போது \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eQPAPVwsqWT7"
},
"source": [
"**ஒன் ஹாட் என்கோடிங்**\n",
"\n",
"ஒன் ஹாட் என்கோடிங் என்பது மற்றொரு வகையான என்கோடிங் முறையாகும். இந்த என்கோடிங் முறையில், ஒவ்வொரு பாகத்தின் வகையும் தனி பாகமாக சேர்க்கப்படும், மேலும் ஒவ்வொரு தரவுப் புள்ளியும் அந்த வகையை கொண்டிருக்கிறதா என்பதைப் பொறுத்து 0 அல்லது 1 பெறும். எனவே, n வெவ்வேறு வகைகள் இருந்தால், n பாகங்கள் டேட்டாபிரேமில் சேர்க்கப்படும்.\n",
"\n",
"உதாரணமாக, அதே விமான வகுப்பின் உதாரணத்தை எடுத்துக்கொள்வோம். வகைகள்: ['பிஸினஸ் கிளாஸ்', 'எகனாமி கிளாஸ்', 'பர்ஸ்ட் கிளாஸ்'] . எனவே, ஒன் ஹாட் என்கோடிங் செய்யும்போது, பின்வரும் மூன்று பாகங்கள் தரவுத்தொகுப்பில் சேர்க்கப்படும்: ['class_business class', 'class_economy class', 'class_first class'].\n"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "ZM0eVh0ArKUL",
"outputId": "83238a76-b3a5-418d-c0b6-605b02b6891b"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>first class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 business class\n",
"1 20 first class\n",
"2 30 economy class\n",
"3 40 economy class\n",
"4 50 economy class\n",
"5 60 business class"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_hot = pd.DataFrame([\n",
" [10,'business class'],\n",
" [20,'first class'],\n",
" [30, 'economy class'],\n",
" [40, 'economy class'],\n",
" [50, 'economy class'],\n",
" [60, 'business class']\n",
"],columns=['ID','class'])\n",
"one_hot"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "aVnZ7paDrWmb"
},
"source": [
"முதல் நெடுவரிசையில் ஒரே-தீவிர குறியாக்கத்தை செய்யலாம்.\n"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"id": "RUPxf7egrYKr"
},
"outputs": [],
"source": [
"one_hot_data = pd.get_dummies(one_hot,columns=['class'])"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "TM37pHsFr4ge",
"outputId": "7be15f53-79b2-447a-979c-822658339a9e"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class_business class</th>\n",
" <th>class_economy class</th>\n",
" <th>class_first class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class_business class class_economy class class_first class\n",
"0 10 1 0 0\n",
"1 20 0 0 1\n",
"2 30 0 1 0\n",
"3 40 0 1 0\n",
"4 50 0 1 0\n",
"5 60 1 0 0"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_hot_data"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_zXRLOjXujdA"
},
"source": [
"ஒவ்வொரு ஹாட் என்கோடு செய்யப்பட்ட நெடுவம் 0 அல்லது 1 ஐ கொண்டுள்ளது, இது அந்த தரவுப் புள்ளிக்கான அந்த வகை உள்ளது என்பதை குறிப்பிடுகிறது.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bDnC4NQOu0qr"
},
"source": [
"ஒரு ஹாட் என்கோடிங்கை எப்போது பயன்படுத்த வேண்டும்? ஒரு ஹாட் என்கோடிங்கை பின்வரும் நிலைகளில் ஒன்று அல்லது இரண்டிலும் பயன்படுத்தலாம்:\n",
"\n",
"1. வகைகளின் எண்ணிக்கையும் தரவுத்தொகுப்பின் அளவும் குறைவாக இருக்கும் போது. \n",
"2. வகைகள் எந்தவொரு குறிப்பிட்ட வரிசையையும் பின்பற்றாத போது. \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XnUmci_4uvyu"
},
"source": [
"> முக்கிய குறிப்புகள்:\n",
"1. எண்களல்லாத தரவுகளை எண் தரவாக மாற்றுவதற்காக குறியாக்கம் செய்யப்படுகிறது.\n",
"2. குறியாக்கம் இரண்டு வகைகளாக உள்ளது: லேபல் குறியாக்கம் மற்றும் ஒன் ஹாட் குறியாக்கம், இவை dataset-இன் தேவைகளின் அடிப்படையில் செய்யப்படலாம்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "K8UXOJYRgRsJ"
},
"source": [
"## மறுபடியும் வரும் தரவுகளை நீக்குதல்\n",
"\n",
"> **கற்கும் இலக்கு:** இந்த துணைபகுதியின் முடிவில், DataFrames-இல் மறுபடியும் வரும் மதிப்புகளை அடையாளம் காணவும், அவற்றை நீக்கவும் நீங்கள் வசதியாக இருக்க வேண்டும்.\n",
"\n",
"காணாமல் போன தரவுகளுக்கு கூடுதலாக, நீங்கள் உண்மையான உலக தரவுத்தொகுப்புகளில் அடிக்கடி மறுபடியும் வரும் தரவுகளை சந்திக்கலாம். அதிர்ஷ்டவசமாக, pandas மறுபடியும் வரும் பதிவுகளை கண்டறியவும், அவற்றை நீக்கவும் எளிய வழிமுறையை வழங்குகிறது.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qrEG-Wa0gRsJ"
},
"source": [
"### நகல் மதிப்புகளை கண்டறிதல்: `duplicated`\n",
"\n",
"நீங்கள் pandas இல் உள்ள `duplicated` முறைமையைப் பயன்படுத்தி நகல் மதிப்புகளை எளிதாக கண்டறியலாம், இது ஒரு Boolean mask ஐ திருப்புகிறது, அதில் ஒரு `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",
"இந்த மதிப்புகளை ஒரே மாதமாக்க ஒரு மாப்பிங் உருவாக்கலாம். ஒரு எளிய முறையாக, lowercase-க்கு மாற்றி, ஒரு மாப்பிங் dictionary உருவாக்கலாம்:\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-Score முறையைப் பயன்படுத்துதல்\n",
"\n",
"Z-Score முறை சராசரியிலிருந்து நிலையான சிதறல்களை அடிப்படையாகக் கொண்டு வெளிப்படையான மதிப்புகளை அடையாளம் காண்கிறது:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from scipy import stats\n",
"except ImportError:\n",
" print(\"scipy is required for Z-score calculation. Please install it with 'pip install scipy' and rerun this cell.\")\n",
"else:\n",
" # Calculate Z-scores for age, handling NaN values\n",
" age_nonan = dirty_data['age'].dropna()\n",
" zscores = np.abs(stats.zscore(age_nonan))\n",
" dirty_data['age_zscore'] = np.nan\n",
" dirty_data.loc[age_nonan.index, 'age_zscore'] = zscores\n",
"\n",
" # Typically, Z-score > 3 indicates an outlier\n",
" print(\"Rows with age Z-score > 3:\")\n",
" zscore_outliers = dirty_data[dirty_data['age_zscore'] > 3]\n",
" print(zscore_outliers[['customer_id', 'name', 'age', 'age_zscore']])\n",
"\n",
" # Clean up the temporary column\n",
" dirty_data = dirty_data.drop('age_zscore', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### அவதானமான மதிப்புகளை கையாளுதல்\n",
"\n",
"அவதானமான மதிப்புகள் கண்டறியப்பட்ட பிறகு, அவற்றை பல வழிகளில் கையாளலாம்:\n",
"1. **நீக்குதல்**: தவறானவை என்றால் அவதானமான மதிப்புகளைக் கொண்ட வரிசைகளை நீக்கவும்\n",
"2. **வரம்பு அமைத்தல்**: எல்லை மதிப்புகளால் மாற்றவும்\n",
"3. **NaN-ஆக மாற்றுதல்**: இவை காணாமல் போன தரவாக கருதி நிரப்பும் முறைகளைப் பயன்படுத்தவும்\n",
"4. **வைத்திருக்கவும்**: அவை உண்மையான மிகுந்த மதிப்புகள் என்றால்\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a cleaned version by replacing impossible ages with NaN\n",
"dirty_data['age_clean'] = dirty_data['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
")\n",
"\n",
"print(\"Age column before and after cleaning:\")\n",
"print(dirty_data[['customer_id', 'name', 'age', 'age_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3. அருகிலுள்ள நகல் வரிகளை கண்டறிதல்\n",
"\n",
"எங்கள் தரவுத்தொகுப்பில் \"John Smith\" என்பவருக்கான பல பதிவுகள் உள்ளன, அவற்றில் சிலவற்றின் மதிப்புகள் சிறிது மாறுபட்டுள்ளன. பெயர் ஒற்றுமையை அடிப்படையாகக் கொண்டு சாத்தியமான நகல்களை கண்டறிவோம்.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# First, let's look at exact name matches (ignoring extra whitespace)\n",
"dirty_data['name_normalized'] = dirty_data['name'].str.strip().str.lower()\n",
"\n",
"print(\"Checking for duplicate names:\")\n",
"duplicate_names = dirty_data[dirty_data.duplicated(['name_normalized'], keep=False)]\n",
"print(duplicate_names.sort_values('name_normalized')[['customer_id', 'name', 'age', 'country']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### பனுவல் பொருத்தத்துடன் அருகிலுள்ள நகல்களை கண்டறிதல்\n",
"\n",
"மேம்பட்ட நகல் கண்டறிதலுக்காக, நாம் பனுவல் பொருத்தத்தை பயன்படுத்தி ஒரே மாதிரியான பெயர்களை கண்டறியலாம்:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"\n",
" # Function to find potential duplicates\n",
" def find_near_duplicates(df, column, threshold=90):\n",
" \"\"\"\n",
" Find near-duplicate entries in a column using fuzzy matching.\n",
" \n",
" Parameters:\n",
" - df: DataFrame\n",
" - column: Column name to check for duplicates\n",
" - threshold: Similarity threshold (0-100)\n",
" \n",
" Returns: List of potential duplicate groups\n",
" \"\"\"\n",
" values = df[column].unique()\n",
" duplicate_groups = []\n",
" checked = set()\n",
" \n",
" for value in values:\n",
" if value in checked:\n",
" continue\n",
" \n",
" # Find similar values\n",
" matches = process.extract(value, values, scorer=fuzz.ratio, limit=len(values))\n",
" similar = [m[0] for m in matches if m[1] >= threshold]\n",
" \n",
" if len(similar) > 1:\n",
" duplicate_groups.append(similar)\n",
" checked.update(similar)\n",
" \n",
" return duplicate_groups\n",
"\n",
" # Find near-duplicate names\n",
" duplicate_groups = find_near_duplicates(dirty_data, 'name', threshold=90)\n",
"\n",
" print(\"Potential duplicate groups:\")\n",
" for i, group in enumerate(duplicate_groups, 1):\n",
" print(f\"\\nGroup {i}:\")\n",
" for name in group:\n",
" matching_rows = dirty_data[dirty_data['name'] == name]\n",
" print(f\" '{name}': {len(matching_rows)} occurrence(s)\")\n",
" for _, row in matching_rows.iterrows():\n",
" print(f\" - Customer {row['customer_id']}: age={row['age']}, country={row['country']}\")\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Skipping fuzzy matching for near-duplicates.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### நகல் தரவுகளை கையாளுதல்\n",
"\n",
"ஒருமுறை கண்டறிந்த பின், நகல் தரவுகளை எப்படி கையாள வேண்டும் என்பதை தீர்மானிக்க வேண்டும்:\n",
"1. **முதல் நிகழ்வை வைத்திருக்கவும்**: `drop_duplicates(keep='first')` பயன்படுத்தவும்\n",
"2. **கடைசி நிகழ்வை வைத்திருக்கவும்**: `drop_duplicates(keep='last')` பயன்படுத்தவும்\n",
"3. **தகவலை ஒருங்கிணைக்கவும்**: நகல் வரிகளிலிருந்து தகவலை இணைக்கவும்\n",
"4. **கையேடு மதிப்பீடு**: மனித மதிப்பீட்டிற்காக குறிக்கவும்\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Example: Remove duplicates based on normalized name, keeping first occurrence\n",
"cleaned_data = dirty_data.drop_duplicates(subset=['name_normalized'], keep='first')\n",
"\n",
"print(f\"Original dataset: {len(dirty_data)} rows\")\n",
"print(f\"After removing name duplicates: {len(cleaned_data)} rows\")\n",
"print(f\"Removed: {len(dirty_data) - len(cleaned_data)} duplicate rows\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(cleaned_data[['customer_id', 'name', 'age', 'country_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### சுருக்கம்: முழுமையான தரவுத் தூய்மைப்படுத்தும் குழாய்\n",
"\n",
"இதை முழுமையான தூய்மைப்படுத்தும் குழாயாக ஒன்றிணைக்கலாம்:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def clean_dataset(df):\n",
" \"\"\"\n",
" Comprehensive data cleaning function.\n",
" \"\"\"\n",
" # Create a copy to avoid modifying the original\n",
" cleaned = df.copy()\n",
" \n",
" # 1. Standardize categorical values (country)\n",
" country_mapping = {\n",
" 'usa': 'USA', 'u.s.a': 'USA', 'united states': 'USA',\n",
" 'uk': 'UK', 'united kingdom': 'UK',\n",
" 'canada': 'Canada', 'mexico': 'Mexico'\n",
" }\n",
" cleaned['country'] = cleaned['country'].str.lower().map(country_mapping)\n",
" \n",
" # 2. Clean abnormal age values\n",
" cleaned['age'] = cleaned['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
" )\n",
" \n",
" # 3. Remove near-duplicate names (normalize whitespace)\n",
" cleaned['name'] = cleaned['name'].str.strip()\n",
" cleaned = cleaned.drop_duplicates(subset=['name'], keep='first')\n",
" \n",
" return cleaned\n",
"\n",
"# Apply the cleaning pipeline\n",
"final_cleaned_data = clean_dataset(dirty_data)\n",
"\n",
"print(\"Before cleaning:\")\n",
"print(f\" Rows: {len(dirty_data)}\")\n",
"print(f\" Unique countries: {dirty_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((dirty_data['age'] < 0) | (dirty_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nAfter cleaning:\")\n",
"print(f\" Rows: {len(final_cleaned_data)}\")\n",
"print(f\" Unique countries: {final_cleaned_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((final_cleaned_data['age'] < 0) | (final_cleaned_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(final_cleaned_data[['customer_id', 'name', 'age', 'country', 'purchase_amount']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 🎯 சவால் பயிற்சி\n",
"\n",
"இப்போது உங்கள் முறை! கீழே தரவின் புதிய வரி கொடுக்கப்பட்டுள்ளது, இதில் பல தரம் குறைவான பிரச்சினைகள் உள்ளன. நீங்கள் செய்ய வேண்டியது:\n",
"\n",
"1. இந்த வரியில் உள்ள அனைத்து பிரச்சினைகளையும் கண்டறியவும் \n",
"2. ஒவ்வொரு பிரச்சினையையும் சுத்தமாக்குவதற்கான குறியீட்டை எழுதவும் \n",
"3. சுத்தமாக்கப்பட்ட வரியை தரவுத்தொகுப்பில் சேர்க்கவும் \n",
"\n",
"இங்கே பிரச்சினையுள்ள தரவுகள்:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# New problematic row\n",
"new_row = pd.DataFrame({\n",
" 'customer_id': [13],\n",
" 'name': [' Diana Prince '], # Extra whitespace\n",
" 'age': [250], # Impossible age\n",
" 'country': ['U.S.A.'], # Inconsistent format\n",
" 'purchase_amount': [150.00]\n",
"})\n",
"\n",
"print(\"New row to clean:\")\n",
"print(new_row)\n",
"\n",
"# TODO: Your code here to clean this row\n",
"# Hints:\n",
"# 1. Strip whitespace from the name\n",
"# 2. Check if the name is a duplicate (Diana Prince already exists)\n",
"# 3. Handle the impossible age value\n",
"# 4. Standardize the country name\n",
"\n",
"# Example solution (uncomment and modify as needed):\n",
"# new_row_cleaned = new_row.copy()\n",
"# new_row_cleaned['name'] = new_row_cleaned['name'].str.strip()\n",
"# new_row_cleaned['age'] = np.nan # Invalid age\n",
"# new_row_cleaned['country'] = 'USA' # Standardized\n",
"# print(\"\\nCleaned row:\")\n",
"# print(new_row_cleaned)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### முக்கிய குறிப்புகள்\n",
"\n",
"1. **மாறுபட்ட வகைகள்** உண்மையான தரவுகளில் பொதுவாக காணப்படும். தனித்துவமான மதிப்புகளை சரிபார்த்து, மாப்பிங் அல்லது மங்கலான பொருத்தம் மூலம் அவற்றை ஒரே மாதமாக்கவும்.\n",
"\n",
"2. **விலகிய மதிப்புகள்** உங்கள் பகுப்பாய்வில் பெரிதும் பாதிப்பை ஏற்படுத்தலாம். துறையின் அறிவு மற்றும் புள்ளியியல் முறைகளை (IQR, Z-score) இணைத்து அவற்றை கண்டறியவும்.\n",
"\n",
"3. **சமீபத்திய நகல்கள்** சரியான நகல்களை விட கண்டறிய கடினமாக இருக்கும். மங்கலான பொருத்தம் மற்றும் தரவுகளை சாதாரணமாக்கல் (எழுத்துகளை சிறிய எழுத்தாக மாற்றுதல், வெற்றிடங்களை நீக்குதல்) மூலம் அவற்றை அடையாளம் காண முயற்சிக்கவும்.\n",
"\n",
"4. **தரவு சுத்திகரிப்பு மீண்டும் மீண்டும் செய்யப்படும் செயலாகும்**. பல முறைகளை பயன்படுத்தி, முடிவுகளை மதிப்பீடு செய்து, சுத்திகரிக்கப்பட்ட தரவுத்தொகுப்பை இறுதியாக முடிக்க வேண்டும்.\n",
"\n",
"5. **உங்கள் முடிவுகளை பதிவு செய்யவும்**. நீங்கள் எந்த சுத்திகரிப்பு நடவடிக்கைகளை எடுத்தீர்கள் மற்றும் ஏன் எடுத்தீர்கள் என்பதை பதிவு செய்யுங்கள், இது மீண்டும் செய்யக்கூடியதற்கும் வெளிப்படைத்தன்மைக்கும் முக்கியமானது.\n",
"\n",
"> **சிறந்த நடைமுறை:** உங்கள் அசல் \"அழுக்கான\" தரவின் ஒரு பிரதியை எப்போதும் வைத்திருங்கள். உங்கள் மூல தரவுக் கோப்புகளை ஒருபோதும் மீட்டெடுக்க வேண்டாம் - `data_cleaned.csv` போன்ற தெளிவான பெயரிடல் முறைகளுடன் சுத்திகரிக்கப்பட்ட பதிப்புகளை உருவாக்கவும்.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**குறிப்பு**: \nஇந்த ஆவணம் [Co-op Translator](https://github.com/Azure/co-op-translator) என்ற AI மொழிபெயர்ப்பு சேவையைப் பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. நாங்கள் துல்லியத்திற்காக முயற்சிக்கின்றோம், ஆனால் தானியக்க மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறான தகவல்கள் இருக்கக்கூடும் என்பதை தயவுசெய்து கவனத்தில் கொள்ளவும். அதன் தாய்மொழியில் உள்ள மூல ஆவணம் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்த தவறான புரிதல்கள் அல்லது தவறான விளக்கங்களுக்கு நாங்கள் பொறுப்பல்ல.\n"
]
}
],
"metadata": {
"anaconda-cloud": {},
"colab": {
"name": "notebook.ipynb",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.4"
},
"coopTranslator": {
"original_hash": "6301339d1c9a301b00639c635dc9b731",
"translation_date": "2025-10-11T16:14:32+00:00",
"source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
"language_code": "ta"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
Reference in new issue View Git Blame Copy Permalink