Python Pandas Series & DataFrames - Data Science Sinhala Tutorial
අද කාලේ Data Science ගැන කතා නොකරන කෙනෙක් නැති තරම්. හැම තැනම දත්ත (Data) තියෙනවා, ඒ දත්ත තේරුම් අරගෙන, ඒවායින් වටිනා තොරතුරු හොයාගන්න එක තමයි Data Science වල ප්‍රධානම අරමුණ. මේ වැඩේට අපිට Python කියන භාෂාවයි, ඒකේ තියෙන Pandas කියන library එකයි නැතුවම බෑ. Pandas කියන්නේ දත්ත එක්ක වැඩ කරන්න තියෙන සුපිරිම මෙවලමක්. හරියට අපේ පැරණි සිංහල කෑම වට්ටෝරු පොතක් වගේ, හැමදේම පිළිවෙලට තියෙන්නේ.
අද මේ ලිපියෙන් අපි බලමු Pandas වල තියෙන ප්‍රධානම data structures දෙකක් වෙන Series සහ DataFrame ගැන. මේවා මොනවද, කොහොමද මේවා හදාගන්නේ, আর කොහොමද මේවා පාවිච්චි කරලා දත්ත ටිකක් නිරීක්ෂණය කරන්නේ කියලා අපි සරලව කතා කරමු. මේක හරියට, ලොකු ගොඩනැගිල්ලක් හදන්න කලින් අත්තිවාරම දානවා වගේ දෙයක්. Data Science වලට අඩිතාලම දාන්න මේ දැනුම ඔයාට ගොඩක් වැදගත් වේවි.
Pandas කියන්නේ මොකක්ද?
Pandas කියන්නේ Python වල තියෙන open-source library එකක්. මේක විශේෂයෙන්ම හදලා තියෙන්නේ data manipulation සහ analysis පහසු කරන්න. අපිට ලොකු දත්ත ගොඩවල් එක්ක වැඩ කරන්න වෙන වෙලාවට, Pandas අපිට ගොඩක් උදව් වෙනවා. ඒක හරියට දත්ත ටිකක් Excel spreadsheet එකක වගේ, නමුත් Python වලදී, ඊටත් වඩා පහසුවෙන් සහ බලගතු විදියට වැඩ කරන්න පුළුවන්. දත්ත clean කරනවා, transform කරනවා, analyze කරනවා වගේ වැඩ වලට Pandas නැතුවම බෑ.
පටන් ගන්න කලින්, ඔයාගේ Python environment එකේ Pandas install කරලා නැත්නම්, පහත command එකෙන් install කරගන්න පුළුවන්:
pip install pandasඊට පස්සේ, ඔයාගේ Python script එකේ Pandas පාවිච්චි කරන්න, හැමවෙලේම මුලින්ම මේ line එක ලියන්න ඕනේ:
import pandas as pdමේකෙන් වෙන්නේ Pandas library එක pd කියන කෙටි නමින් අපේ script එකට import කරන එක. හැමෝම වගේ pd කියලා තමයි පාවිච්චි කරන්නේ. ඒක හොඳ පුරුද්දක් (Best Practice).
Pandas Series: දත්ත තනි තීරුවක් (A Single Column of Data)
Pandas Series කියන්නේ Pandas වල තියෙන one-dimensional (1D) labeled array එකක්. ඒ කියන්නේ, ඒක එක data type එකක දත්ත එක තීරුවක තියෙනවා වගේ. හරියට Excel spreadsheet එකක තනි column එකක් වගේ. හැබැයි මේ column එකේ index එකක් තියෙනවා. මේ index එකෙන් අපිට ඒ Series එකේ තියෙන දත්ත identify කරන්න පුළුවන්. Series එකක අංක, strings, floating point numbers වගේ ඕනම data type එකක දත්ත තියෙන්න පුළුවන්.
Series එකක් හදාගන්නේ කොහොමද?
අපිට Series එකක් හදාගන්න පුළුවන් Python list එකකින්, dictionary එකකින්, නැත්නම් තනි scalar value එකකින්. අපි උදාහරණයක් බලමු:
1. Python List එකකින් Series එකක් හදන හැටි:
import pandas as pd
# Python list එකක්
data_list = ["අම්පාර", "ගාල්ල", "නුවර", "යාපනය", "කොළඹ"]
# Series එකක් හදනවා
districts = pd.Series(data_list)
print(districts)
මේ code එක run කරාම ඔයාට මෙහෙම output එකක් ලැබෙයි:
0 අම්පාර
1 ගාල්ල
2 නුවර
3 යාපනය
4 කොළඹ
dtype: object
මේකේ වම් පැත්තේ තියෙන 0, 1, 2, 3, 4 කියන්නේ default index එක. ඒ කියන්නේ Pandas විසින් ස්වයංක්‍රීයව දාපු අංක. දකුණු පැත්තේ තියෙන්නේ අපේ දත්ත. dtype: object කියන්නේ මේ දත්ත strings විදියට හඳුනාගෙන තියෙනවා කියන එක.
2. Dictionary එකකින් Series එකක් හදන හැටි:
Dictionary එකකින් Series එකක් හදනකොට, dictionary එකේ keys ටික Series index එක විදියටත්, values ටික Series data විදියටත් පාවිච්චි කරනවා.
import pandas as pd
# Python dictionary එකක්
data_dict = {
'අඹ': 100,
'කෙසෙල්': 150,
'පේර': 75,
'දොඩම්': 120
}
# Series එකක් හදනවා
fruit_prices = pd.Series(data_dict)
print(fruit_prices)
Output:
අඹ 100
කෙසෙල් 150
පේර 75
දොඩම් 120
dtype: int64
දැන් ඔයාට පේනවා fruit_prices Series එකේ index එක විදියට පාවිච්චි වෙන්නේ පළතුරු වල නම් (dictionary keys). dtype: int64 කියන්නේ මේ දත්ත integers විදියට හඳුනාගෙන තියෙනවා කියන එක.
Series එකකින් දත්ත ගන්න හැටි (Accessing Elements)
අපිට index එක පාවිච්චි කරලා Series එකක තියෙන ඕනෑම දත්තයක් ගන්න පුළුවන්.
import pandas as pd
fruit_prices = pd.Series({
'අඹ': 100,
'කෙසෙල්': 150,
'පේර': 75,
'දොඩම්': 120
})
# 'පේර' වල මිල ගන්නවා
pera_price = fruit_prices['පේර']
print(f"පේර මිල: {pera_price}")
# Default numerical index එක පාවිච්චි කරලා ගන්නවා (dictionary වලින් හැදුවත් numerical index එකකුත් තියෙනවා)
# නමුත් dictionary key එකම පාවිච්චි කරන එක තමයි සුදුසු.
# fruit_prices.iloc[2] කියලා දුන්නත් 'පේර' වල මිල ලැබෙනවා
Output:
පේර මිල: 75
Pandas DataFrame: දත්ත වගුවක් (A Table of Data)
Pandas DataFrame කියන්නේ Pandas වල තියෙන ප්‍රධානම data structure එක. ඒක two-dimensional (2D) labeled data structure එකක්. හරියට Excel spreadsheet එකක් වගේ, නැත්නම් SQL table එකක් වගේ. DataFrame එකක තියෙනවා columns සහ rows. සෑම column එකක්ම Series එකක් වගේ ක්‍රියා කරනවා. DataFrame එකක තියෙන සෑම column එකකටම වෙනස් data types තියෙන්න පුළුවන්.
DataFrame එකක් හදාගන්නේ කොහොමද?
DataFrame එකක් හදාගන්න ගොඩක් ක්‍රම තියෙනවා. අපි ප්‍රධාන ක්‍රම දෙකක් බලමු.
1. Dictionary of Lists/Series එකකින් DataFrame එකක් හදන හැටි:
මේක DataFrame එකක් හදාගන්න තියෙන ජනප්‍රියම ක්‍රමයක්. dictionary එකේ keys ටික column names විදියටත්, values ටික (ඒවා list, Numpy array, හෝ Series වෙන්න පුළුවන්) ඒ column එකේ දත්ත විදියටත් පාවිච්චි කරනවා.
import pandas as pd
# Dictionary of lists එකක්
data = {
'නම': ['අමිල', 'සුනිල්', 'කමලී', 'නිරෝෂා'],
'වයස': [28, 35, 24, 30],
'නගරය': ['කොළඹ', 'ගාල්ල', 'නුවර', 'කුරුණෑගල'],
'වැටුප': [75000, 80000, 60000, 70000]
}
# DataFrame එකක් හදනවා
df = pd.DataFrame(data)
print(df)
Output:
නම වයස නගරය වැටුප
0 අමිල 28 කොළඹ 75000
1 සුනිල් 35 ගාල්ල 80000
2 කමලී 24 නුවර 60000
3 නිරෝෂා 30 කුරුණෑගල 70000
දැන් ඔයාට පේනවා, මේක හරියට පොඩි spreadsheet එකක් වගේ. නම, වයස, නගරය, වැටුප කියන්නේ column names. වම් පැත්තේ 0, 1, 2, 3 කියන්නේ row index එක.
2. List of Dictionaries එකකින් DataFrame එකක් හදන හැටි:
සමහර වෙලාවට අපිට දත්ත ලැබෙන්නේ මේ වගේ list of dictionaries එකක් විදියට. එතකොටත් අපිට DataFrame එකක් හදාගන්න පුළුවන්.
import pandas as pd
# List of Dictionaries එකක්
data_records = [
{'නම': 'ආශා', 'වයස': 25, 'නගරය': 'මහනුවර'},
{'නම': 'දිල්හානි', 'වයස': 32, 'නගරය': 'ගම්පහ'},
{'නම': 'සමන්', 'වයස': 40, 'නගරය': 'කොළඹ'}
]
df_records = pd.DataFrame(data_records)
print(df_records)
Output:
නම වයස නගරය
0 ආශා 25 මහනුවර
1 දිල්හානි 32 ගම්පහ
2 සමන් 40 කොළඹ
DataFrame එකක් නිරීක්ෂණය කරන හැටි (Basic Data Inspection)
අපිට DataFrame එකක් ලැබුනම, ඒකේ දත්ත ටිකක් නිරීක්ෂණය කරන එක ගොඩක් වැදගත්. මේකට ගොඩක් ප්‍රයෝජනවත් methods කිහිපයක් තියෙනවා:
.head(): DataFrame එකේ මුල් rows 5 පෙන්වනවා..head(10)කියලා දුන්නොත් මුල් rows 10 පෙන්වයි..tail(): DataFrame එකේ අන්තිම rows 5 පෙන්වනවා..info(): DataFrame එකේ සමස්ත තොරතුරු (number of entries, column names, non-null values ගණන, data types, memory usage) පෙන්වනවා. මේක දත්ත පිරිසිදු කරන්න (data cleaning) කලින් ගොඩක් වැදගත්..describe(): Numerical columns වල සංඛ්‍යානමය සාරාංශයක් (count, mean, std, min, max, quartiles) පෙන්වනවා..shape: DataFrame එකේ rows සහ columns ගණන පෙන්වනවා (උදා: (4, 4))..columns: DataFrame එකේ තියෙන column names ලැයිස්තුවක් පෙන්වනවා.
import pandas as pd
data = {
'නම': ['අමිල', 'සුනිල්', 'කමලී', 'නිරෝෂා', 'දිනේෂ්', 'මාලතී'],
'වයස': [28, 35, 24, 30, 45, 29],
'නගරය': ['කොළඹ', 'ගාල්ල', 'නුවර', 'කුරුණෑගල', 'මාතර', 'කළුතර'],
'වැටුප': [75000, 80000, 60000, 70000, 95000, 68000]
}
df = pd.DataFrame(data)
print("\n--- DataFrame එකේ මුල් rows 3 ---")
print(df.head(3))
print("\n--- DataFrame එකේ අවසාන rows 2 ---")
print(df.tail(2))
print("\n--- DataFrame එකේ තොරතුරු ---")
df.info()
print("\n--- Numerical columns වල සාරාංශය ---")
print(df.describe())
print("\n--- DataFrame එකේ shape (rows, columns) ---")
print(df.shape)
print("\n--- Column names ---")
print(df.columns)
DataFrame එකකින් දත්ත ගන්න හැටි (Accessing Data)
1. Columns තෝරාගැනීම:
අපිට DataFrame එකකින් එක column එකක් හෝ columns කිහිපයක් තෝරාගන්න පුළුවන්.
# 'නම' column එක තෝරාගන්නවා (එක Series එකක් විදියට ලැබෙනවා)
names = df['නම']
print("\n--- 'නම' column එක ---")
print(names)
# Columns කිහිපයක් තෝරාගන්නවා (අලුත් DataFrame එකක් විදියට ලැබෙනවා)
selected_cols = df[['නම', 'නගරය']]
print("\n--- 'නම' සහ 'නගරය' columns ---")
print(selected_cols)
2. Rows තෝරාගැනීම (Indexing):
Rows තෝරාගැනීමට අපි .loc (label-based indexing) සහ .iloc (integer-based indexing) පාවිච්චි කරනවා.
.loc[row_label, column_label]: Row labels සහ column labels පාවිච්චි කරනවා..iloc[row_index, col_index]: Integer positions (0-based index) පාවිච්චි කරනවා.
# පළමු row එක තෝරාගන්නවා (iloc පාවිච්චි කරලා)
first_row = df.iloc[0]
print("\n--- පළමු row එක ---")
print(first_row)
# 1 සිට 3 දක්වා rows තෝරාගන්නවා (iloc)
rows_1_to_3 = df.iloc[1:4] # 4 වෙනි එකට කලින් ඉවර වෙනවා
print("\n--- 1 සිට 3 දක්වා rows ---")
print(rows_1_to_3)
# විශේෂිත row එකක් (label එකෙන්) සහ column එකක් තෝරාගන්නවා (loc)
kamali_details = df.loc[2, 'නගරය']
print(f"\nකමලී ඉන්න නගරය: {kamali_details}")
3. Conditional Selection (Filter කිරීම):
විශේෂිත කොන්දේසි වලට අනුව rows filter කරන්න පුළුවන්. මේක ගොඩක් ප්‍රයෝජනවත්.
# වයස 30ට වැඩි අය තෝරාගන්නවා
older_people = df[df['වයස'] > 30]
print("\n--- වයස 30ට වැඩි අය ---")
print(older_people)
# නගරය 'කොළඹ' වන අය තෝරාගන්නවා
colombo_residents = df[df['නගරය'] == 'කොළඹ']
print("\n--- කොළඹ පදිංචිකරුවන් ---")
print(colombo_residents)
# කොන්දේසි කිහිපයක් එකට පාවිච්චි කරන හැටි (AND - &, OR - |)
experienced_colombo_residents = df[(df['නගරය'] == 'කොළඹ') & (df['වයස'] > 25)]
print("\n--- කොළඹින්, වයස 25ට වැඩි අය ---")
print(experienced_colombo_residents)
දත්ත වර්ග සහ Indexing ගැටළු (Data Types and Indexing Issues)
Data type එක හරියට තියෙන එක Data Analysis වලදී ගොඩක් වැදගත්. සමහර වෙලාවට numerical data (අංක) වුණත් string විදියට load වෙන්න පුළුවන්, විශේෂයෙන්ම අපිට දත්ත CSV වගේ text file එකකින් එනකොට. මේ වගේ වෙලාවට අපිට ගණන් හදන්න බැරි වෙනවා. .dtypes attribute එකෙන් අපිට DataFrame එකේ තියෙන හැම column එකකම data type එක බලන්න පුළුවන්.
print("\n--- මුල් data types ---")
print(df.dtypes)
Output:
නම object
වයස int64
නගරය object
වැටුප int64
dtype: object
object කියන්නේ සාමාන්‍යයෙන් string data වලට. int64 කියන්නේ integers (පූර්ණ සංඛ්‍යා). හැබැයි, අපිට column එකක data type එක වෙනස් කරන්න ඕනේ නම්, .astype() method එක පාවිච්චි කරන්න පුළුවන්.
# 'වයස' column එක float type එකට වෙනස් කරන හැටි (උදාහරණයක් විදියට)
df['වයස'] = df['වයස'].astype(float)
print("\n--- 'වයස' float එකට වෙනස් කළාට පස්සේ ---")
print(df.dtypes)
Indexing කියන්නේත් වැදගත් දෙයක්. DataFrame එකක් හදනකොට Pandas විසින් ස්වයංක්‍රීයව numerical index එකක් (0, 1, 2...) දානවා. ඒත් සමහර වෙලාවට අපිට DataFrame එකේ තියෙන column එකක් index එක විදියට පාවිච්චි කරන්න ඕනේ වෙන්න පුළුවන් (උදා: ID column එකක්).
.set_index(): column එකක් index එක විදියට set කරන්න..reset_index(): index එක column එකක් විදියට ආපහු DataFrame එකට ගන්න.
# DataFrame එකට අලුත් ID column එකක් එකතු කරමු
df['ID'] = [101, 102, 103, 104, 105, 106]
print("\n--- ID column එක එකතු කළාට පස්සේ ---")
print(df.head())
# 'ID' column එක index එක විදියට set කරමු
df_indexed = df.set_index('ID')
print("\n--- 'ID' එක index එක විදියට set කළාට පස්සේ ---")
print(df_indexed)
# දැන් අපිට ID එකෙන් rows තෝරාගන්න පුළුවන් loc පාවිච්චි කරලා
person_103 = df_indexed.loc[103]
print(f"\nID 103 තියෙන කෙනා: {person_103['නම']}")
# Index එක reset කරනවා (ID column එක ආපහු සාමාන්‍ය column එකක් වෙනවා)
df_reset = df_indexed.reset_index()
print("\n--- Index එක reset කළාට පස්සේ ---")
print(df_reset.head())
හොඳ පුරුදු (Best Practices)
දැන් ඔයා Pandas Series සහ DataFrame ගැන මූලික දැනුමක් අරගෙන ඇති. මේ දේවල් මතක තියාගන්න එක ඔයාගේ Data Science journey එකට ගොඩක් උදව් වෙයි:
- දත්ත හොඳින් නිරීක්ෂණය කරන්න (Always Inspect Your Data): ඔයාට දත්ත ගොඩක් ලැබුණාම, මුලින්ම
.head(),.info(),.describe()වගේ methods පාවිච්චි කරලා ඒකේ තොරතුරු බලන්න. මේකෙන් missing values, වැරදි data types වගේ දේවල් මුලින්ම හඳුනාගන්න පුළුවන්. - Data Types ගැන අවබෝධයක් තියාගන්න (Understand Data Types): දත්ත වර්ග නිවැරදිව තියෙන එක analysis වලදී වැදගත්. අවශ්‍ය නම්
.astype()පාවිච්චි කරලා ඒවා වෙනස් කරන්න. - Vectorized Operations පාවිච්චි කරන්න (Use Vectorized Operations): Python වල
forloop එකක් පාවිච්චි කරනවට වඩා Pandas built-in methods (උදා:df['column'] * 2) පාවිච්චි කරන එක ගොඩක් වේගවත්. ඒක හරියට පොළට ගිහින් එකපාරටම එළවළු ටිකක් ගන්නවා වගේ මිසක්, එකින් එක ගන්නවා වගේ නෙවෙයි. - Missing Data (NaN) හැසිරවීම (Handle Missing Data): Real-world data වල හැම වෙලේම missing values (NaN) තියෙනවා.
.dropna()(missing values තියෙන rows/columns අයින් කරනවා) හෝ.fillna()(missing values වෙනත් value එකකින් පුරවනවා) වගේ methods ගැන ඉගෙනගන්න. - ඔයාගේ Code එක Document කරන්න (Document Your Code): ඔයා කරන දේවල් වලට comments දාන්න. අනිත් අයටත් ඔයාගේ code එක තේරුම් ගන්න ඒක ගොඩක් වැදගත්.
අවසන් වශයෙන් (Conclusion)
Pandas Series සහ DataFrames කියන්නේ Python Data Science වල අත්තිවාරම. මේවා හොඳින් තේරුම් ගත්තාම ඕනෑම සංකීර්ණ දත්ත set එකක් එක්ක වුණත් පහසුවෙන් වැඩ කරන්න ඔයාට පුළුවන් වෙනවා. අද අපි බැලුවා මේවා මොනවද, කොහොමද හදාගන්නේ, data inspect කරන්නේ, আর data types සහ indexing වල තියෙන වැදගත්කම මොකක්ද කියලා. ඒ වගේම හොඳ පුරුදු ටිකකුත් මතක් කර දුන්නා. මේ දැනුමෙන් ඔයාට data wrangling වලට හොඳ පදනමක් ලැබෙනවා.
දැන් ඔයාගේ වාරය! මේ ලිපියේ තියෙන examples ටික ඔයාගේ Python environment එකේ try කරලා බලන්න. ඊට පස්සේ, ඔයාම පුංචි dataset එකක් (ලැයිස්තුවකින්, dictionary එකකින් හදාගත්ත) අරගෙන මේ concepts ටික පුරුදු වෙන්න. මේ tutorial එක ගැන ඔයාගේ අදහස් පහළ comment section එකේ ලියන්න. Data Science journey එකේ ඊළඟ පියවරට යන්න මේ දැනුම ගොඩක් උදව් වේවි!