Sign in Subscribe
By Thisara Priyamal —

Pandas Data Cleaning & Preprocessing | Python Sinhala Guide

Pandas Data Cleaning & Preprocessing | Python Sinhala Guide

කොහොමද යාලුවනේ! Data Science වලට Pandas එක්ක Data Cleaning & Preprocessing කරමු!

Data Science කියන්නේ මේ දවස්වල ලෝකයේ ගොඩක් කතාබහට ලක්වෙන ක්ෂේත්‍රයක්. ඒත්, Data Science වල සාර්ථකත්වය රඳා පවතින්නේ හුදෙක් Machine Learning algorithms දන්න එක මතම නෙවෙයි, Data Cleaning සහ Preprocessing කියන දේවල් කොච්චර හොඳට කරනවාද කියන එක මතත් ගොඩක් වෙලාවට රඳා පවතිනවා. අද අපි කතා කරන්න යන්නේ Python programming language එකේ Data Science වලට අත්‍යවශ්‍යම library එකක් වන Pandas භාවිතයෙන් Data Cleaning සහ Preprocessing කරන ආකාරය ගැන.

අපි මේ tutorial එකෙන්, Data cleaning වලදී නිතරම හම්බවෙන ප්‍රශ්න තුනක්, ඒ කියන්නේ Missing Values (NaN), Duplicate Values, සහ Data Type Conversion කියන දේවල් Pandas භාවිතයෙන් පහසුවෙන් කළමනාකරණය කරගන්නා ආකාරය පියවරෙන් පියවර ඉගෙන ගන්නවා. මේක Data Science ගමනේ ඔයාගේ පළමු පියවර වුණත්, නැත්තම් දැනටමත් මේ ක්ෂේත්‍රයේ ඉන්න කෙනෙක් වුණත්, මේ tutorial එක ඔයාට ගොඩක් වටිනවා.

එහෙනම්, අපි පටන් ගමු නේද?

1. Data Cleaning - ඇයි මේක මෙච්චර වැදගත්?

හිතන්න, ඔයා හොඳට රසට කෑමක් හදන්න යනවා කියලා. ඒකට ඔයා එළවළු ටිකක් ගේනවා. ඔයා ඒවා සෝදන්නේ නැතුව, පොතු අරින්නේ නැතුව, නරක් වෙච්ච ටික අයින් කරන්නේ නැතුව, එහෙම්මම උයනවද? නැහැනේ! එහෙම කළොත් ඔයා හදන කෑමේ රසයක් නැති වෙන්න පුළුවන්, නැත්තම් ලෙඩ වෙන්නත් පුළුවන්.

Data Cleaning කියන්නේත් හරියට ඒ වගේ දෙයක් තමයි. අපි Data Science project එකකට Data set එකක් ගත්තාම, ඒක බොහෝ වෙලාවට අපිට කෙලින්ම use කරන්න බැරි තත්වයක තමයි තියෙන්නේ. ඒකේ වැරදි තොරතුරු, නැති තොරතුරු, නැවත නැවත තියෙන තොරතුරු (duplicates) වගේ ගොඩක් ප්‍රශ්න තියෙන්න පුළුවන්. මේ වගේ "අපිරිසිදු" (dirty) data එකක් එක්ක වැඩ කළොත්, අපේ analysis වල ප්‍රතිඵල වැරදි වෙන්න පුළුවන්, Machine Learning model එකේ accuracy එක අඩු වෙන්න පුළුවන්, ඒ වගේම අපිට ගන්න සිද්ධාන්ත (conclusions) සම්පූර්ණයෙන්ම වැරදි වෙන්නත් පුළුවන්.

ඒ නිසා, Data Cleaning කියන්නේ Data Science වලදී, Data analysis වලදී වගේම Machine Learning වලදීත් අනිවාර්යයෙන්ම කරන්න ඕන දෙයක්. මේකට තමයි අපි Pandas library එක භාවිතා කරන්නේ.

Data Cleaning වලදී සාමාන්‍යයෙන් හම්බවෙන ප්‍රධාන ගැටළු:

  • Missing Values (NaN): සමහර data points වලට අගයන් නැතිවීම. (Not a Number)
  • Duplicate Data: එකම data record එක නැවත නැවතත් තිබීම.
  • Incorrect Data Types: Data එක වැරදි data type එකකින් තිබීම. (උදාහරණයක් ලෙස: අංකයක් String එකක් ලෙස තිබීම.)
  • Inconsistent Data: එකම තොරතුර විවිධ විදියට ඇතුලත් කර තිබීම. (උදා: "Sri Lanka", "SL", "S.Lanka")
  • Outliers: සාමාන්‍ය data රටාවෙන් ගොඩක් දුරස් වන අගයන්.

අද අපි මේවායින් පළමු කරුණු තුන ගැන විස්තරාත්මකව කතා කරමු.

2. Missing Values (NaN) - අතුරුදහන් වුණු දත්ත එක්ක වැඩ කරමු!

ඔයා Data set එකක් එක්ක වැඩ කරනකොට, සමහර columns වලට අදාළ cells හිස්ව (empty) තියෙනවා දකින්න පුළුවන්. මේවා තමයි Missing Values කියලා කියන්නේ. Pandas වලදී මේවා බොහෝවිට NaN (Not a Number) කියලා තමයි පෙන්නුම් කරන්නේ. මේ missing values අපේ analysis වලට බාධා ඇති කරන්න පුළුවන්, සමහර algorithms වලට ඒවා process කරන්න බැරි වෙන්නත් පුළුවන්.

Missing Values හඳුනාගැනීම:

මුලින්ම, අපේ Data set එකේ කොච්චර Missing Values තියෙනවද කියලා බලමු. මේකට Pandas වල තියෙන .isnull() (නැත්තම් .isna()) සහ .sum() functions යොදාගන්න පුළුවන්.

import pandas as pd
import numpy as np

# Sample DataFrame එකක් හදාගමු
data = {
    'Product': ['Laptop', 'Mouse', 'Keyboard', 'Monitor', 'Speaker', 'Webcam', 'Microphone', 'Headphones', 'Tablet', 'Printer'],
    'Price': [1200, 25, 75, np.nan, 50, 30, np.nan, 90, 300, 150],
    'Quantity': [10, 50, np.nan, 5, 20, 15, 8, 12, np.nan, 7],
    'Rating': [4.5, 4.0, 4.2, 3.8, np.nan, 4.1, 3.9, 4.3, 4.0, 4.6]
}
df = pd.DataFrame(data)

print("Original DataFrame:\n", df)
print("\nMissing values in each column:\n")
print(df.isnull().sum())

ප්‍රතිඵලය:

Original DataFrame:
      Product  Price  Quantity  Rating
0     Laptop  1200.0      10.0     4.5
1      Mouse    25.0      50.0     4.0
2   Keyboard    75.0       NaN     4.2
3    Monitor     NaN       5.0     3.8
4    Speaker    50.0      20.0     NaN
5     Webcam    30.0      15.0     4.1
6 Microphone     NaN       8.0     3.9
7 Headphones    90.0      12.0     4.3
8     Tablet   300.0       NaN     4.0
9    Printer   150.0       7.0     4.6

Missing values in each column:

Product     0
Price       2
Quantity    2
Rating      1
dtype: int64

මේ output එකෙන් අපිට පේනවා Price, Quantity, සහ Rating කියන columns වල Missing values තියෙනවා කියලා.

Missing Values කළමනාකරණය කිරීමේ ක්‍රම:

a) Missing Values අඩංගු පේළි (Rows) හෝ තීරු (Columns) ඉවත් කිරීම (Dropping):

Missing Values ගොඩක් අඩු ප්‍රමාණයක් තියෙනවා නම්, නැත්තම් ඒ data එක අපේ analysis එකට එතරම් වැදගත් නැත්නම්, අපිට ඒ Missing Values තියෙන පේළි හෝ columns අයින් කරලා දාන්න පුළුවන්. මේකට .dropna() function එක භාවිතා කරනවා.

  • df.dropna(): Missing value එකක් හෝ කීපයක් තියෙන හැම row එකක්ම delete කරනවා.
  • df.dropna(axis=1): Missing value එකක් හෝ කීපයක් තියෙන හැම column එකක්ම delete කරනවා.
  • df.dropna(how='all'): හැම column එකකම Missing Values තියෙන row විතරක් delete කරනවා.
# Missing values තියෙන හැම row එකක්ම delete කරමු
df_dropped_rows = df.dropna()
print("\nDataFrame after dropping rows with any NaN:\n", df_dropped_rows)

# (ඔයාට මේක අලුත් DataFrame එකකට assign කරගන්නත් පුළුවන්, නැත්තම් inplace=True පාවිච්චි කරන්නත් පුළුවන්)
# df.dropna(inplace=True)

ප්‍රතිඵලය:

DataFrame after dropping rows with any NaN:
     Product  Price  Quantity  Rating
0    Laptop  1200.0      10.0     4.5
1     Mouse    25.0      50.0     4.0
5    Webcam    30.0      15.0     4.1
7 Headphones    90.0      12.0     4.3
9   Printer   150.0       7.0     4.6

මේ විදියට Dropping කරනකොට මතක තියාගන්න ඕනේ, අපිට ගොඩක් වැදගත් data ටිකක් නැති වෙන්න පුළුවන් කියන එක. ඒ නිසා, මේ ක්‍රමය භාවිතා කරන්න ඕනේ හුඟක් පරිස්සමින්.

b) Missing Values පිරවීම (Imputation):

Missing Values අයින් කරනවා වෙනුවට, අපිට ඒවාට වෙනත් අගයන් ආදේශ කරන්න පුළුවන්. මේ ක්‍රියාවලියට Imputation කියලා කියනවා. මේකට .fillna() function එක භාවිතා කරනවා. Imputation වලදී අපි බහුලවම භාවිතා කරන ක්‍රම කීපයක් තියෙනවා:

  • Mean (සාමාන්‍යය) මගින් පිරවීම: Numerical data වලට සාමාන්‍යයෙන් භාවිතා කරනවා. Data එක සාමාන්‍ය විදියට (normally distributed) තියෙනවා නම් මේක හොඳයි.
  • Median (මධ්‍යස්ථය) මගින් පිරවීම: Numerical data වලදී, Data එක skewed (එක පැත්තකට බර) වෙලා තියෙනවා නම් මේක mean එකට වඩා හොඳයි. Outliers වල බලපෑම අඩුයි.
  • Mode (බහුලවම පවතින අගය) මගින් පිරවීම: Categorical data (text data) වලට වගේම numerical data වලටත් භාවිතා කරන්න පුළුවන්.
  • Fixed Value එකකින් පිරවීම: Missing value එකට 0, -1 වගේ specific අගයක් දාන්න පුළුවන්.
  • Forward Fill (ffill) / Backward Fill (bfill): ඊට කලින් තියෙන (previous) අගයෙන් නැත්තම් ඊට පස්සේ තියෙන (next) අගයෙන් පිරවීම. Time series data වලට මේක වැදගත්.
# DataFrame එකේ මුල් පිටපතක් තියාගමු
df_filled = df.copy()

# 'Price' column එකේ Missing values වලට Mean එක දාමු
mean_price = df_filled['Price'].mean()
df_filled['Price'].fillna(mean_price, inplace=True)

# 'Quantity' column එකේ Missing values වලට Median එක දාමු
median_quantity = df_filled['Quantity'].median()
df_filled['Quantity'].fillna(median_quantity, inplace=True)

# 'Rating' column එකේ Missing values වලට Mode එක දාමු (Ratings categorical වගේ තියෙන නිසා)
mode_rating = df_filled['Rating'].mode()[0] # mode() එක Series එකක් return කරන නිසා [0] ගන්නවා
df_filled['Rating'].fillna(mode_rating, inplace=True)

print("\nDataFrame after Imputation:\n", df_filled)
print("\nMissing values after Imputation:\n")
print(df_filled.isnull().sum())

ප්‍රතිඵලය:

DataFrame after Imputation:
      Product     Price  Quantity  Rating
0     Laptop  1200.000      10.0     4.5
1      Mouse    25.000      50.0     4.0
2   Keyboard    75.000      10.0     4.2
3    Monitor   194.375       5.0     3.8
4    Speaker    50.000      20.0     4.0
5     Webcam    30.000      15.0     4.1
6 Microphone   194.375       8.0     3.9
7 Headphones    90.000      12.0     4.3
8     Tablet   300.000      10.0     4.0
9    Printer   150.000       7.0     4.6

Missing values after Imputation:

Product     0
Price       0
Quantity    0
Rating      0
dtype: int64

දැන් අපේ DataFrame එකේ Missing Values නැහැ!

3. Duplicate Values - අනවශ්‍ය දත්ත අයින් කරමු!

Data set එකක එකම record එක නැවත නැවතත් තිබුණොත්, ඒකෙන් අපේ analysis එකට වැරදි බලපෑමක් ඇති වෙන්න පුළුවන්. උදාහරණයක් ලෙස, ගණන් කිරීමේදී (counting) එකම record එක දෙවරක් ගණනය වෙන්න පුළුවන්. මේවා තමයි Duplicate Values කියලා කියන්නේ. Pandas වල .duplicated() සහ .drop_duplicates() functions මගින් මේවා හඳුනාගෙන ඉවත් කරන්න පුළුවන්.

Duplicate Values හඳුනාගැනීම:

.duplicated() function එකෙන් duplicate rows හඳුනාගන්න පුළුවන්. මේක boolean Series එකක් return කරනවා, duplicate row එකක් නම් True, නැත්තම් False.

# Sample DataFrame එකක් හදාගමු (duplicates එක්ක)
data_dup = {
    'Name': ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob', 'David'],
    'Age': [25, 30, 25, 35, 30, 40],
    'City': ['New York', 'London', 'New York', 'Paris', 'London', 'Tokyo']
}
df_dup = pd.DataFrame(data_dup)

print("Original DataFrame with duplicates:\n", df_dup)
print("\nDuplicate rows (True means it's a duplicate):\n")
print(df_dup.duplicated())

print("\nNumber of duplicate rows:\n")
print(df_dup.duplicated().sum())

ප්‍රතිඵලය:

Original DataFrame with duplicates:
      Name  Age      City
0    Alice   25  New York
1      Bob   30    London
2    Alice   25  New York
3  Charlie   35     Paris
4      Bob   30    London
5    David   40     Tokyo

Duplicate rows (True means it's a duplicate):
0    False
1    False
2     True
3    False
4     True
5    False
dtype: bool

Number of duplicate rows:

2

මේ output එකෙන් පේනවා Alice, 25, New York සහ Bob, 30, London කියන records නැවතත් තියෙනවා කියලා.

Duplicate Values ඉවත් කිරීම:

.drop_duplicates() function එකෙන් duplicate rows ඉවත් කරන්න පුළුවන්.

  • df.drop_duplicates(): හැම column එකක්ම බලාගෙන duplicate rows අයින් කරනවා. මුලින්ම හම්බවෙන duplicate record එක තියාගෙන අනිත් ඒවා අයින් කරනවා.
  • df.drop_duplicates(subset=['ColumnName']): ඔයාට ඕන specific columns කීපයක් විතරක් බලාගෙන duplicate rows අයින් කරන්නත් පුළුවන්.
  • df.drop_duplicates(keep='last'): අන්තිමට හම්බවෙන duplicate record එක තියාගෙන අනිත් ඒවා අයින් කරනවා. (Default එක keep='first')
# Duplicates ඉවත් කරමු
df_no_duplicates = df_dup.drop_duplicates()

print("\nDataFrame after dropping duplicates:\n", df_no_duplicates)
print("\nNumber of duplicate rows after dropping:\n")
print(df_no_duplicates.duplicated().sum())

ප්‍රතිඵලය:

DataFrame after dropping duplicates:
      Name  Age      City
0    Alice   25  New York
1      Bob   30    London
3  Charlie   35     Paris
5    David   40     Tokyo

Number of duplicate rows after dropping:

0

දැන් අපේ DataFrame එකේ Duplicate Values නැහැ!

4. Data Type Conversion - දත්ත වර්ග හරියට සකස් කරමු!

Data set එකක් load කරාම, Pandas විසින් columns වලට data types automatically assign කරනවා. ඒත් සමහර වෙලාවට, මේ types අපිට ඕන විදියට නැති වෙන්න පුළුවන්. උදාහරණයක් ලෙස, අංක තියෙන column එකක් object (string) එකක් විදියට recognize වෙන්න පුළුවන්, නැත්තම් දිනයන් (dates) object එකක් විදියට recognize වෙන්න පුළුවන්. වැරදි data types නිසා data analysis වලට, calculations වලට, වගේම Machine Learning model වලටත් බලපෑම් ඇති වෙන්න පුළුවන්.

Pandas වල .astype(), pd.to_numeric(), pd.to_datetime() වගේ functions මගින් data types convert කරන්න පුළුවන්.

Data Types හඳුනාගැනීම:

මුලින්ම, අපේ DataFrame එකේ columns වල data types මොනවාද කියලා බලමු. මේකට .info() හෝ .dtypes භාවිතා කරන්න පුළුවන්.

# Sample DataFrame එකක් හදාගමු (වැරදි data types එක්ක)
data_types = {
    'OrderID': ['A101', 'A102', 'A103', 'A104'],
    'Amount': ['150.50', '200', '75.25', '120.00'], # These are strings, but should be numbers
    'OrderDate': ['2023-01-15', '2023-01-16', '2023-01-17', '2023-01-18'], # These are strings, but should be dates
    'IsShipped': [True, False, True, 'Yes'] # 'Yes' is a string, not boolean
}
df_types = pd.DataFrame(data_types)

print("Original DataFrame info (before conversion):\n")
df_types.info()

ප්‍රතිඵලය:

Original DataFrame info (before conversion):

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 4 columns):
 #   Column     Non-Null Count  Dtype 
---  ------     --------------  -----
 0   OrderID    4 non-null      object
 1   Amount     4 non-null      object
 2   OrderDate  4 non-null      object
 3   IsShipped  4 non-null      object
dtypes: object(4)
memory usage: 256.0+ bytes

මේ output එකෙන් පේනවා හැම column එකක්ම object (string) විදියට recognize වෙලා තියෙනවා කියලා. අපිට ඕන Amount එක numbers විදියටත්, OrderDate එක dates විදියටත්, IsShipped එක boolean විදියටත් තියෙන්න.

Data Types Convert කිරීම:

# 'Amount' column එක numeric (float) එකකට convert කරමු
df_types['Amount'] = pd.to_numeric(df_types['Amount'])

# 'OrderDate' column එක datetime එකකට convert කරමු
df_types['OrderDate'] = pd.to_datetime(df_types['OrderDate'])

# 'IsShipped' column එක boolean එකකට convert කරමු
# 'Yes' කියන string එක True වලට convert කරගන්න පුළුවන්.
# ඒ වගේම Pandas bool type එක True/False විතරයි accept කරන්නේ. 'Yes' string එක True කරන්න map() භාවිතා කරමු.
df_types['IsShipped'] = df_types['IsShipped'].map({'True': True, 'False': False, True: True, False: False, 'Yes': True, 'No': False}).astype(bool)

# දැන් DataFrame එකේ info එක ආයෙත් බලමු
print("\nDataFrame info (after conversion):\n")
df_types.info()

print("\nDataFrame after type conversion:\n", df_types)

ප්‍රතිඵලය:

DataFrame info (after conversion):

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 4 columns):
 #   Column     Non-Null Count  Dtype         
---  ------     --------------  -----         
 0   OrderID    4 non-null      object        
 1   Amount     4 non-null      float64       
 2   OrderDate  4 non-null      datetime64[ns]
 3   IsShipped  4 non-null      bool          
dtypes: bool(1), datetime64[ns](1), float64(1), object(1)
memory usage: 292.0+ bytes

DataFrame after type conversion:
  OrderID  Amount  OrderDate  IsShipped
0    A101  150.50 2023-01-15       True
1    A102  200.00 2023-01-16      False
2    A103   75.25 2023-01-17       True
3    A104  120.00 2023-01-18       True

දැන් අපේ DataFrame එකේ columns වලට හරියට data types assign වෙලා තියෙනවා! Amount එක float64 වෙලා, OrderDate එක datetime64[ns] වෙලා, IsShipped එක bool වෙලා.

වැදගත් උපදෙස් (Best Practices):

  • Data Cleaning Steps Documentation: ඔයා කරන හැම Data Cleaning step එකක්ම comment කරලා, නැත්තම් වෙනම document කරලා තියාගන්න. ඒක අනාගතයේදී ඔයාට නැවත මේ project එක බලනකොට වගේම අනිත් අයත් එක්ක වැඩ කරනකොටත් ගොඩක් වැදගත්.
  • Original Data Copy: Data Cleaning කරනකොට හැමවිටම original DataFrame එකේ copy එකක් අරගෙන වැඩ කරන්න. මොකද, මොනවා හරි වැරදීමක් වුණොත්, original data එක නැවත ලබාගන්න පුළුවන්. (df.copy())
  • Context Matters: Missing values fill කරනකොට, duplicates අයින් කරනකොට, ඒ data එක මොකක්ද, ඒකේ context එක මොකක්ද කියලා හොඳට හිතලා බලන්න. හැම වෙලාවෙම mean එකෙන් fill කරන එක, නැත්තම් හැම වෙලාවෙම duplicates අයින් කරන එක හොඳම විසඳුම වෙන්නේ නැති වෙන්න පුළුවන්.

අවසන් වශයෙන්...

හොඳයි යාලුවනේ, ඔන්න අපි අද Python Pandas භාවිතයෙන් Data Cleaning සහ Preprocessing වල ප්‍රධාන අංග කීපයක් ගැන ඉගෙන ගත්තා. Missing Values කළමනාකරණය කරන හැටි, Duplicate Values ඉවත් කරන හැටි, සහ Data Types හරියට සකස් කරගන්නා ආකාරය අපි code උදාහරණ එක්කම බැලුවා.

Data Science වලදී, "Garbage In, Garbage Out" කියන ප්‍රසිද්ධ කියමනක් තියෙනවා. ඒ කියන්නේ, ඔයා අපිරිසිදු (dirty) data එකක් එක්ක වැඩ කළොත්, ඔයාට ලැබෙන ප්‍රතිඵලත් අපිරිසිදු, ඒ කියන්නේ වැරදි ප්‍රතිඵල වෙන්න පුළුවන් කියන එකයි. ඒ නිසා, මේ Data Cleaning සහ Preprocessing කියන පියවර ගොඩක්ම වැදගත්.

මතක තියාගන්න, Data cleaning කියන්නේ එක පාරින් ඉවර කරන්න පුළුවන් දෙයක් නෙවෙයි, ඒක නිරන්තරයෙන්ම (iterative) කරන්න ඕන ක්‍රියාවලියක්. Data set එක එක්ක වැඩිපුර වැඩ කරනකොට, තවත් අලුත් ගැටළු මතු වෙන්න පුළුවන්. ඒ නිසා, හැමවිටම විවෘත මනසකින් මේ දේවල් වලට මුහුණ දෙන්න සූදානම් වෙලා ඉන්න.

දැන් ඔයාට පුළුවන් මේ ඉගෙන ගත්ත දේවල් ඔයාගේම DataSets අරගෙන practice කරන්න. Kaggle වගේ platforms වල නොමිලේ download කරගන්න පුළුවන් DataSets ගොඩක් තියෙනවා. ඒවා අරගෙන මේ techniques ටික apply කරලා බලන්න. ඔබට අමතරව තවත් මොනවා හරි දැනගන්න ඕන නම්, නැත්තම් මේ tutorial එක ගැන අදහස් තියෙනවා නම්, පහළින් comment එකක් දාන්න! ඔබේ අත්දැකීම් අපිත් එක්ක බෙදාගන්න.

එහෙනම්, තවත් අලුත් ලිපියකින් හමුවෙමු! සුභ දවසක්!

Previous

Pandas Data Selection & Filtering Sinhala Guide | loc, iloc, Boolean Indexing

 Next

Next.js Static Export Sinhala | HTML Sites | Performance | SEO Friendly