Pandas Groupby & Aggregation | Python Data Science Sinhala Tutorial
ආයුබෝවන් යාළුවනේ! අද අපි Pandas වල ඉතාම වැදගත්, ඒ වගේම Data Science කරන ඕනෑම කෙනෙකුට නැතිවම බැරි Grouping සහ Aggregation ගැන සිංහලෙන් සරලව කතා කරන්නයි ලෑස්ති වෙන්නේ. Data Analysis වලදී, අපිට ගොඩක් වෙලාවට සිද්ධ වෙනවා විශාල Dataset එකක් අරගෙන, ඒකේ තියෙන විවිධ කොටස් වලට වෙන් කරලා, ඒ වෙන් කරපු කොටස් වල තොරතුරු එකතු කරලා (summarize) බලන්න. මේ වැඩේට තමයි Pandas groupby() කියන powerful function එකයි, ඒත් එක්ක එන aggregation functions ටිකයි යොදා ගන්නේ. මේක හරියට පොත් ගොඩක් තියෙන පුස්තකාලයක, එකම වර්ගයේ පොත් එක තැනකට එකතු කරලා, ඒ පොත් අතරින් වැඩිපුරම ජනප්‍රිය එක හෝ වැඩිපුරම කියවපු එක මොකක්ද කියලා හොයනවා වගේ වැඩක්!
මේ tutorial එක අවසානයේදී, ඔයාලට Pandas groupby() කියන්නේ මොකක්ද, ඒක කොහොමද පාවිච්චි කරන්නේ, විවිධ aggregation functions යොදා ගන්නේ කොහොමද, ඒ වගේම ප්‍රායෝගික data analysis අවස්ථාවලදී මේවා පාවිච්චි කරලා කොහොමද වටිනා insights ලබා ගන්නේ කියන එක පැහැදිලිව අවබෝධ වෙයි.
එහෙනම් අපි පටන් ගමුද?
1. Pandas groupby() කියන්නේ මොකක්ද? (Understanding groupby())
Pandas groupby() කියන ක්‍රියාවලිය මූලිකවම "Split-Apply-Combine" කියන concept එක මත තමයි ක්‍රියාත්මක වෙන්නේ. මේකේ තේරුම මෙහෙමයි:
- Split (වෙන් කිරීම): මුළු DataFrame එකම අපි තෝරන එකක් හෝ කිහිපයක් (key) අනුව කුඩා කණ්ඩායම් වලට (groups) වෙන් කරනවා. උදාහරණයක් විදිහට, Product Category එක අනුව sales data එක Electronics, Clothing, Books වගේ කණ්ඩායම් වලට වෙන් කරන්න පුළුවන්.
- Apply (යෙදීම): වෙන් කරපු හැම කණ්ඩායමකටම (group) අපි කැමති function එකක් (එකතු කිරීම - aggregation, පරිවර්තනය - transformation, හෝ filtering) යොදනවා. අපේ මේ tutorial එකේදී අපි අවධානය යොමු කරන්නේ aggregation වලට.
- Combine (එකතු කිරීම): හැම කණ්ඩායමකටම යෙදූ function එකේ ප්‍රතිඵල අලුත් DataFrame එකක් විදිහට නැවත එකතු කරනවා.
මේ groupby() ක්‍රියාවලිය හරියට හතු අහුලන්න යනවා වගේ. අපි වෙන් කරන්නේ (split) හතු වල වර්ගය අනුව, පස්සේ හැම වර්ගයකින්ම අපි හොයන දේ (apply) කරනවා, අන්තිමට ඒ හැම ප්‍රතිඵලයක්ම එකතු කරනවා (combine).
සරල උදාහරණයක්:
අපි හිතමු අපිට Company එකක employeesලගේ department එකයි, salary එකයි තියෙන data set එකක් තියෙනවා කියලා.
import pandas as pd
# Sample DataFrame එකක් හදමු
data = {
'Department': ['HR', 'IT', 'Finance', 'HR', 'IT', 'Finance', 'IT', 'HR'],
'Employee': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace', 'Heidi'],
'Salary': [60000, 80000, 75000, 62000, 90000, 78000, 85000, 65000]
}
df = pd.DataFrame(data)
print("මුල් DataFrame එක:")
print(df)
# Department එක අනුව Group කරමු
grouped_by_department = df.groupby('Department')
print("\nGrouped object එක: ", grouped_by_department)
print("\nGrouped object එකේ HR group එකේ data:")
print(grouped_by_department.get_group('HR'))
Output:
මුල් DataFrame එක:
Department Employee Salary
0 HR Alice 60000
1 IT Bob 80000
2 Finance Charlie 75000
3 HR David 62000
4 IT Eve 90000
5 Finance Frank 78000
6 IT Grace 85000
7 HR Heidi 65000
Grouped object එක: <pandas.core.groupby.generic.DataFrameGroupBy object at 0x...
Grouped object එකේ HR group එකේ data:
Department Employee Salary
0 HR Alice 60000
3 HR David 62000
7 HR Heidi 65000
මෙතනදී අපි df.groupby('Department') කියලා කිව්වහම, Pandas වලින් DataFrame එකේ තියෙන Department column එකේ unique values (HR, IT, Finance) අනුව data එක වෙන වෙනම groups වලට වෙන් කරනවා. හැබැයි මේකෙන් අපිට කෙලින්ම result DataFrame එකක් ලැබෙන්නේ නැහැ. ලැබෙන්නේ DataFrameGroupBy කියන object එකක්. මේ object එකේ තියෙන groups වලට aggregation function එකක් යෙදුවහම තමයි අපිට summarized data එක ලැබෙන්නේ.
2. Aggregation Functions (එකතු කිරීමේ ක්‍රම)
වෙන් කරපු groups වලට අපි යොදන functions තමයි aggregation functions කියලා කියන්නේ. මේවායින් group එකේ තියෙන data එක එක value එකකට reduce කරනවා.
බහුලවම පාවිච්චි වෙන aggregation functions ටිකක් පහතින් බලමු:
sum(): Group එකේ තියෙන values වල එකතුව.mean(): Group එකේ තියෙන values වල සාමාන්‍යය (average).count(): Group එකේ තියෙන non-null values ගණන.min(): Group එකේ තියෙන අවම value එක.max(): Group එකේ තියෙන උපරිම value එක.median(): Group එකේ තියෙන මධ්‍යස්ථ value එක (middle value).std(): Group එකේ standard deviation එක.size(): Group එකේ තියෙන rows ගණන (null values එක්ක).
Aggregation Functions භාවිතය:
අපි කලින් හදපු df DataFrame එකම පාවිච්චි කරමු. අපි දැන් බලමු හැම Department එකකම average salary එක කීයද කියලා.
# හැම Department එකකම සාමාන්‍ය salary එක හොයමු
average_salary_per_department = df.groupby('Department')['Salary'].mean()
print("\nDepartment එක අනුව සාමාන්‍ය Salary:")
print(average_salary_per_department)
# හැම Department එකකම මුළු salary එක හොයමු
total_salary_per_department = df.groupby('Department')['Salary'].sum()
print("\nDepartment එක අනුව මුළු Salary:")
print(total_salary_per_department)
# හැම Department එකකම employeesලා කී දෙනෙක් ඉන්නවද කියලා බලමු
employee_count_per_department = df.groupby('Department')['Employee'].count()
print("\nDepartment එක අනුව Employee ගණන:")
print(employee_count_per_department)
Output:
Department එක අනුව සාමාන්‍ය Salary:
Department
Finance 76500.0
HR 62333.3
IT 85000.0
Name: Salary, dtype: float64
Department එක අනුව මුළු Salary:
Department
Finance 153000
HR 182000
IT 255000
Name: Salary, dtype: int64
Department එක අනුව Employee ගණන:
Department
Finance 2
HR 3
IT 3
Name: Employee, dtype: int64
මේ outputs වලින් පේනවා, කොහොමද අපි Department එක අනුව data එක වෙන් කරලා, ඒ වෙන් කරපු groups වලට mean(), sum(), count() වගේ functions යෙදුවම අපිට අවශ්‍ය summarized data එක ලැබෙන්නේ කියලා.
3. ප්‍රායෝගික උදාහරණයක්: නිෂ්පාදන විකුණුම් විශ්ලේෂණය (Practical Example: Product Sales Analysis)
දැන් අපි තව ටිකක් සංකීර්ණ scenario එකක් අරගෙන වැඩ කරමු. අපි හිතමු අපිට මාසෙකට කරපු sales data එකක් තියෙනවා කියලා. මේකෙන් Product Category එක අනුව මුළු විකුණුම් ප්‍රමාණය (Total Quantity) සහ මුළු ආදායම (Total Revenue) හොයන හැටි බලමු.
# තව ටිකක් ලොකු DataFrame එකක් හදමු
sales_data = {
'Product': ['Laptop', 'Mouse', 'Keyboard', 'Monitor', 'Speaker', 'Headphones', 'Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'Category': ['Electronics', 'Electronics', 'Electronics', 'Electronics', 'Audio', 'Audio', 'Electronics', 'Electronics', 'Electronics', 'Electronics'],
'Region': ['North', 'South', 'North', 'East', 'South', 'North', 'East', 'North', 'South', 'East'],
'Quantity': [2, 5, 3, 1, 4, 2, 3, 6, 2, 1],
'UnitPrice': [1200, 25, 75, 300, 50, 80, 1250, 22, 70, 310]
}
sales_df = pd.DataFrame(sales_data)
# Revenue (ආදායම) column එකක් හදමු
sales_df['Revenue'] = sales_df['Quantity'] * sales_df['UnitPrice']
print("\nSales DataFrame එක:")
print(sales_df)
# 1. Product Category එක අනුව මුළු විකුණුම් ප්‍රමාණය (Total Quantity) සහ මුළු ආදායම (Total Revenue) හොයමු
category_summary = sales_df.groupby('Category').agg(
TotalQuantity=('Quantity', 'sum'),
TotalRevenue=('Revenue', 'sum')
)
print("\nCategory එක අනුව විකුණුම් සාරාංශය:")
print(category_summary)
# 2. Region එක අනුව මුළු ආදායම හොයමු
region_revenue = sales_df.groupby('Region')['Revenue'].sum()
print("\nRegion එක අනුව මුළු ආදායම:")
print(region_revenue)
# 3. Category සහ Region දෙකම අනුව මුළු Quantity සහ මුළු Revenue හොයමු
# Multi-level Grouping
category_region_summary = sales_df.groupby(['Category', 'Region']).agg(
TotalQuantity=('Quantity', 'sum'),
TotalRevenue=('Revenue', 'sum')
)
print("\nCategory සහ Region අනුව විකුණුම් සාරාංශය:")
print(category_region_summary)
Output:
Sales DataFrame එක:
Product Category Region Quantity UnitPrice Revenue
0 Laptop Electronics North 2 1200 2400
1 Mouse Electronics South 5 25 125
2 Keyboard Electronics North 3 75 225
3 Monitor Electronics East 1 300 300
4 Speaker Audio South 4 50 200
5 Headphones Audio North 2 80 160
6 Laptop Electronics East 3 1250 3750
7 Mouse Electronics North 6 22 132
8 Keyboard Electronics South 2 70 140
9 Monitor Electronics East 1 310 310
Category එක අනුව විකුණුම් සාරාංශය:
TotalQuantity TotalRevenue
Category
Audio 6 360
Electronics 23 7382
Region එක අනුව මුළු ආදායම:
Region
East 4360
North 2917
South 465
Name: Revenue, dtype: int64
Category සහ Region අනුව විකුණුම් සාරාංශය:
TotalQuantity TotalRevenue
Category Region
Audio North 2 160
South 4 200
Electronics East 5 4360
North 11 2757
South 7 265
මේ example එකෙන් ඔයාලට පේනවා ඇති, කොහොමද Category එක අනුව total quantity සහ total revenue එක හොයාගන්නේ කියලා. ඒ වගේම Category එකයි, Region එකයි දෙකම පාවිච්චි කරලා multi-level grouping එකක් කරලා data එක summarize කරගන්නේ කොහොමද කියන එකත් මේකෙන් පැහැදිලියි.
4. Advanced Aggregation with agg() (agg() භාවිතයෙන් සංකීර්ණ එකතු කිරීම්)
අපි මේ වෙනකම් බැලුවේ එක column එකකට එක aggregation function එකක් යොදන හැටි. හැබැයි සමහර වෙලාවට අපිට ඕන වෙන්න පුළුවන් එක group එකකට එක column එකකට functions කිහිපයක් යොදන්න, නැත්නම් වෙනස් columns වලට වෙනස් functions යොදන්න. මේකට තමයි agg() කියන method එක අපිට උදව් කරන්නේ.
agg() method එකට dictionary එකක් ({'column_name': 'function'}) හෝ list of functions {'column_name': ['func1', 'func2']} දෙන්න පුළුවන්. ඒ වගේම named aggregation කරන්නත් පුළුවන්.
agg() භාවිතය:
අපි කලින් sales_df එකම පාවිච්චි කරලා, Product Category එක අනුව Total Quantity, Average UnitPrice, සහ Max Revenue හොයමු.
# Category එක අනුව විවිධ aggregations එකවර සිදු කිරීම
advanced_summary = sales_df.groupby('Category').agg(
TotalQuantity=('Quantity', 'sum'),
AverageUnitPrice=('UnitPrice', 'mean'),
MaxRevenue=('Revenue', 'max'),
MinRevenue=('Revenue', 'min'), # තවත් එකක් එකතු කරමු
NumberOfProducts=('Product', 'count') # Group එකේ තියෙන products ගාන
)
print("\nCategory එක අනුව සංකීර්ණ සාරාංශය:")
print(advanced_summary)
Output:
Category එක අනුව සංකීර්ණ සාරාංශය:
TotalQuantity AverageUnitPrice MaxRevenue MinRevenue NumberOfProducts
Category
Audio 6 65.000000 200 160 2
Electronics 23 298.000000 3750 125 8
මේකෙන් පේනවා, agg() method එක පාවිච්චි කරලා කොච්චර ලේසියෙන් එක groupby operation එකකින් අපිට අවශ්‍ය හැම summary එකක්ම ගන්න පුළුවන්ද කියලා. named aggregation කියන ක්‍රමයේදී NewColumnName=('OriginalColumn', 'aggregation_function') විදිහට අපි dictionary values දුන්නහම, output DataFrame එකට ලස්සන column names ලැබෙනවා.
5. Grouped Object සහ Multi-level Indexing (Review & Best Practices)
Grouped Object (DataFrameGroupBy)
කලින් කිව්වා වගේ, df.groupby('column_name') කියලා දුන්නහම ලැබෙන්නේ DataFrameGroupBy object එකක්. මේක අපිට කෙලින්ම data පෙන්නන්නේ නැහැ. ඒක memory එකේ තියාගෙන ඉන්නේ, අපි aggregation function එකක් දුන්නහම calculation කරන්න ලෑස්ති කරගෙන වගේ. මේ object එකට තව operations ගොඩක් කරන්න පුළුවන්, .first(), .last(), .nth() වගේ.
Multi-level Indexing
අපි columns කිහිපයක් groupby කළාම (උදාහරණයක් විදිහට sales_df.groupby(['Category', 'Region'])), ලැබෙන result DataFrame එකේ index එකේ multi-level index එකක් (MultiIndex) හැදෙනවා. මේක ඉතාම ප්‍රයෝජනවත් වුණත්, සමහර වෙලාවට මේකත් එක්ක වැඩ කරන්න ටිකක් අමාරු වෙන්න පුළුවන්, විශේෂයෙන්ම data visualization වලදී.
මේ multi-level index එක සාමාන්‍ය columns වලට පරිවර්තනය කරන්න .reset_index() කියන method එක පාවිච්චි කරන්න පුළුවන්.
# Multi-level Indexing ප්‍රතිඵලය
print("\nMulti-level Indexing සහිත ප්‍රතිඵලය:")
print(category_region_summary)
# reset_index() භාවිතය
reset_indexed_summary = category_region_summary.reset_index()
print("\nreset_index() පසුව:")
print(reset_indexed_summary)
Output:
Multi-level Indexing සහිත ප්‍රතිඵලය:
TotalQuantity TotalRevenue
Category Region
Audio North 2 160
South 4 200
Electronics East 5 4360
North 11 2757
South 7 265
reset_index() පසුව:
Category Region TotalQuantity TotalRevenue
0 Audio North 2 160
1 Audio South 4 200
2 Electronics East 5 4360
3 Electronics North 11 2757
4 Electronics South 7 265
දැන් Category සහ Region කියන columns දෙක index එකෙන් ගිලිහිලා සාමාන්‍ය columns විදිහට DataFrame එකට ඇවිත් තියෙනවා. මේකෙන් data එක further analysis කරන්න හරි, වෙන tools වලට export කරන්න හරි ලේසියි.
නිගමනය (Conclusion)
අද අපි Pandas වල ඉතාම ප්‍රබල groupby() method එක ගැනත්, ඒත් එක්ක එන විවිධ aggregation functions ගැනත්, agg() method එක භාවිතයෙන් සංකීර්ණ aggregations සිදු කරන්නේ කොහොමද කියන එක ගැනත් විස්තරාත්මකව කතා කළා. Data Science සහ Data Analysis වලදී මේ concepts ඉතාම වැදගත්. මේවා පාවිච්චි කරලා විශාල datasets වල තියෙන patterns, trends, සහ insights ඉතාම පහසුවෙන් හොයාගන්න පුළුවන්.
හිතනවා මේ tutorial එක ඔයාලට ගොඩක් ප්‍රයෝජනවත් වෙන්න ඇති කියලා. දැන් ඔයාලට පුළුවන් තමන්ගේම datasets අරගෙන, මේ ඉගෙන ගත්ත දේවල් practice කරන්න. මතක තියාගන්න, coding වලදී පුහුණුව තමයි වැදගත්ම දේ. ඒ නිසා පුළුවන් තරම් practice කරන්න!
ඔයාලගේ අදහස්, ප්‍රශ්න, නැත්නම් මේ වගේ analysis කරද්දී මුහුණ දුන්නු අත්දැකීම් comment section එකේ ලියන්න අමතක කරන්න එපා. අපි ඊළඟ tutorial එකෙන් හමුවෙමු! ගිහින් එන්නම්.
