Pandas Data Selection & Filtering Sinhala Guide | loc, iloc, Boolean Indexing
ඉතින් කොහොමද යාලුවනේ!
Data Science කියන ලෝකේ, අපි වැඩ කරන Data set එකෙන් අපිට ඕන දත්ත ටික විතරක් තෝරාගන්න එකයි, අනවශ්‍ය දේවල් අයින් කරලා Filter කරගන්න එකයි හරිම වැදගත්. හිතන්න, ලොකු supermarket එකක දිනපතා අලෙවි වෙන දේවල් තියෙන Data set එකක් තියෙනවා කියලා. අපිට ඕනේ මේකෙන් කොළඹ ශාඛාවේ විතරක් ගිය සතියේ අලෙවි වුණු කිරිපිටි වර්ග මොනවද කියලා දැනගන්න. මේ වගේ අවස්ථාවලට තමයි Pandas වල Data Selection & Filtering techniques ගොඩක් ප්‍රයෝජනවත් වෙන්නේ.
Pandas කියන්නේ Python වල Data Science වලට අත්‍යවශ්‍යම Library එකක්. මේකේ තියෙන DataFrame කියන Data structure එක Data tables වගේ. ඒ Data tables වලින් අපිට ඕන විදිහට දත්ත තෝරාගන්නයි, Filter කරන්නයි පුළුවන් ක්‍රම ගණනාවක් තියෙනවා. මේ ටියුටෝරියල් එකෙන් අපි ඒ ගැන සවිස්තරාත්මකව කතා කරනවා, සිංහලෙන්, සරලව!
අපි මේ ටියුටෝරියල් එකෙන් කතා කරනවා:
- Pandas වල Data Selection වල මූලික අදහස.
locසහilocකියන බලගතු මෙවලම්.- Boolean Indexing පාවිච්චි කරලා කොන්දේසි මත Data Filter කරන හැටි.
query()method එක පාවිච්චි කරලා Data තෝරාගන්න හැටි.- වැදගත් Best Practices සහ ගැටළු මගහරවාගන්නා ආකාරය.
ඉතින්, අපි පටන් ගමු!
Pandas Data Selection වල මූලික අදහස
Data Selection කියන්නේ Data Frame එකක තියෙන රෝ (rows) හෝ කොලම් (columns) හෝ දෙකම, අපිට අවශ්‍ය විදිහට තෝරාගැනීම. උදාහරණයක් විදිහට, ඔබට Data Frame එකක තියෙන 'වයස' කියන කොලම් එක විතරක් බලන්න ඕන වෙන්න පුළුවන්, නැත්නම් වයස අවුරුදු 30ට වැඩි අය විතරක් තෝරාගන්න ඕන වෙන්න පුළුවන්.
මේ සඳහා Pandas අපිට විවිධ ක්‍රමවේද ලබා දෙනවා, ඒවා තමයි loc, iloc, සහ Boolean Indexing වගේ දේවල්.
මුලින්ම, අපි අපේ වැඩ වලට පොඩි Data Frame එකක් හදාගමු. මේක තමයි අපේ උදාහරණ වලට පදනම වෙන්නේ.
import pandas as pd
data = {
'නම': ['අනුර', 'බන්දු', 'චාමර', 'දිල්රුක්', 'එරංග', 'ෆර්හාන්'],
'වයස': [25, 30, 22, 28, 35, 29],
'නගරය': ['කොළඹ', 'ගාල්ල', 'මහනුවර', 'කොළඹ', 'ගම්පහ', 'ගාල්ල'],
'ලකුණු': [85, 92, 78, 95, 88, 80]
}
df = pd.DataFrame(data)
print(df)
Output එක මෙහෙම වෙයි:
නම වයස නගරය ලකුණු
0 අනුර 25 කොළඹ 85
1 බන්දු 30 ගාල්ල 92
2 චාමර 22 මහනුවර 78
3 දිල්රුක් 28 කොළඹ 95
4 එරංග 35 ගම්පහ 88
5 ෆර්හාන් 29 ගාල්ල 80
Indexing Heroes: loc සහ iloc
Pandas වල Data Selection වලට ප්‍රධාන වශයෙන් පාවිච්චි කරන Tools දෙක තමයි loc සහ iloc. මේ දෙකේ වෙනස හොඳට තේරුම් ගන්න එක ගොඩක් වැදගත්.
loc (Label-based indexing)
loc කියන්නේ Label-based indexing වලට. ඒ කියන්නේ අපි දත්ත තෝරාගැනීමට යොදාගන්නේ rows වල නම් (index labels) සහ columns වල නම් (column names). numeric indexes (0, 1, 2...) වෙනුවට, අපිට තියෙන Data Frame එකේ තියෙන labels පාවිච්චි කරනවා.
loc වල පොදු භාවිතය df.loc[row_label, column_label] වගේ.
එක රෝ එකක් තෝරාගැනීම
අපේ Data Frame එකේ default index එක 0, 1, 2... විදිහට තියෙන නිසා, අපිට 0 වෙනි රෝ එක තෝරාගන්න පුළුවන් මේ විදිහට:
print(df.loc[0])
නම අනුර
වයස 25
නගරය කොළඹ
ලකුණු 85
Name: 0, dtype: object
රෝස් කිහිපයක් තෝරාගැනීම
අපිට 0 වෙනි, 2 වෙනි, 4 වෙනි රෝස් තෝරාගන්න ඕන නම්:
print(df.loc[[0, 2, 4]])
නම වයස නගරය ලකුණු
0 අනුර 25 කොළඹ 85
2 චාමර 22 මහනුවර 78
4 එරංග 35 ගම්පහ 88
කොලම් කිහිපයක් තෝරාගැනීම
ඔබට 'නම' සහ 'නගරය' කියන කොලම් විතරක් ඕන නම්:
print(df.loc[:, ['නම', 'නගරය']]) # ':' කියන්නේ "සියලුම රෝස්" කියන එක.
නම නගරය
0 අනුර කොළඹ
1 බන්දු ගාල්ල
2 චාමර මහනුවර
3 දිල්රුක් කොළඹ
4 එරංග ගම්පහ
5 ෆර්හාන් ගාල්ල
රෝස් සහ කොලම් දෙකම තෝරාගැනීම
අපිට 1 සහ 3 වෙනි රෝස් වල 'නම' සහ 'වයස' විතරක් ඕන නම්:
print(df.loc[[1, 3], ['නම', 'වයස']])
නම වයස
1 බන්දු 30
3 දිල්රුක් 28
Slice කරන හැටි
loc වලදී slicing කරද්දී end-point එකත් ඇතුලත් වෙනවා. (Python list slicing වල වගේ නෙවෙයි, එතන end-point එක ඇතුලත් වෙන්නේ නෑ.)
print(df.loc[0:2, 'නම':'නගරය']) # 0 ඉඳන් 2 වෙනි index වෙනකම් සහ 'නම' ඉඳන් 'නගරය' කොලම් එක වෙනකම්.
නම වයස නගරය
0 අනුර 25 කොළඹ
1 බන්දු 30 ගාල්ල
2 චාමර 22 මහනුවර
iloc (Integer-location based indexing)
iloc කියන්නේ Integer-location based indexing වලට. මේක Python list indexing වලට සමානයි. අපි දත්ත තෝරාගන්න යොදාගන්නේ rows සහ columns වල numeric positions (0, 1, 2...).
iloc වල පොදු භාවිතය df.iloc[row_index, column_index] වගේ.
එක රෝ එකක් තෝරාගැනීම (index වලින්)
print(df.iloc[0]) # 0 වෙනි position එකේ තියෙන රෝ එක
නම අනුර
වයස 25
නගරය කොළඹ
ලකුණු 85
Name: 0, dtype: object
රෝස් කිහිපයක් තෝරාගැනීම (index වලින්)
print(df.iloc[[0, 2, 4]]) # 0, 2, 4 positions වල තියෙන රෝස්
නම වයස නගරය ලකුණු
0 අනුර 25 කොළඹ 85
2 චාමර 22 මහනුවර 78
4 එරංග 35 ගම්පහ 88
කොලම් කිහිපයක් තෝරාගැනීම (index වලින්)
අපිට 0 වෙනි (නම) සහ 2 වෙනි (නගරය) කොලම් විතරක් ඕන නම්:
print(df.iloc[:, [0, 2]]) # සියලුම රෝස්, 0 සහ 2 වෙනි position එකේ තියෙන කොලම්
නම නගරය
0 අනුර කොළඹ
1 බන්දු ගාල්ල
2 චාමර මහනුවර
3 දිල්රුක් කොළඹ
4 එරංග ගම්පහ
5 ෆර්හාන් ගාල්ල
රෝස් සහ කොලම් දෙකම තෝරාගැනීම (index වලින්)
අපිට 1 සහ 3 වෙනි රෝස් වල 0 (නම) සහ 1 (වයස) වෙනි කොලම් විතරක් ඕන නම්:
print(df.iloc[[1, 3], [0, 1]])
නම වයස
1 බන්දු 30
3 දිල්රුක් 28
Slice කරන හැටි
iloc වලදී slicing කරද්දී end-point එක ඇතුලත් වෙන්නේ නෑ. (Python list slicing වල වගේ).
print(df.iloc[0:3, 0:3]) # 0 ඉඳන් 2 වෙනි index (3ට අඩු) වෙනකම් රෝස් සහ 0 ඉඳන් 2 වෙනි index (3ට අඩු) වෙනකම් කොලම්.
නම වයස නගරය
0 අනුර 25 කොළඹ
1 බන්දු 30 ගාල්ල
2 චාමර 22 මහනුවර
තත්ත්වයන්ට අනුව Data Filter කිරීම: Boolean Indexing
Boolean Indexing කියන්නේ අපිට Data Frame එකක Data filter කරන්න තියෙන හරිම බලගතු ක්‍රමයක්. මේකේදී අපි Data Frame එකට True හෝ False වටිනාකම් තියෙන Series එකක් දෙනවා. True තියෙන රෝස් විතරක් තෝරාගන්නවා.
Single condition එකකින් Filter කිරීම
අපිට වයස අවුරුදු 30ට වැඩි අය විතරක් ඕන නම්:
filter_condition = df['වයස'] > 28
print(filter_condition) # මේක Boolean Series එකක්.
print("\nFiltered DataFrame:")
print(df[filter_condition])
0 False
1 True
2 False
3 False
4 True
5 True
Name: වයස, dtype: bool
Filtered DataFrame:
නම වයස නගරය ලකුණු
1 බන්දු 30 ගාල්ල 92
4 එරංග 35 ගම්පහ 88
5 ෆර්හාන් 29 ගාල්ල 80
මේක කෙලින්ම Data Frame එක ඇතුලෙම ලියන්නත් පුළුවන්:
print(df[df['වයස'] > 28])
Multiple conditions (`&`, `|`, `~`)
අපිට කොන්දේසි කිහිපයක් එකට පාවිච්චි කරන්න පුළුවන්. ඒ සඳහා අපි & (AND), | (OR), සහ ~ (NOT) operators පාවිච්චි කරනවා. හැම condition එකක්ම වරහන් ඇතුලේ දාන්න මතක තියාගන්න, නැත්නම් Error වෙන්න පුළුවන්.
- AND (`&`): වයස අවුරුදු 28ට වැඩි සහ 'නගරය' 'ගාල්ල' වන අය.
print(df[(df['වයස'] > 28) & (df['නගරය'] == 'ගාල්ල')])
නම වයස නගරය ලකුණු
1 බන්දු 30 ගාල්ල 92
5 ෆර්හාන් 29 ගාල්ල 80
- OR (`|`): 'නගරය' 'කොළඹ' වන හෝ 'ලකුණු' 90ට වඩා වැඩි අය.
print(df[(df['නගරය'] == 'කොළඹ') | (df['ලකුණු'] > 90)])
නම වයස නගරය ලකුණු
0 අනුර 25 කොළඹ 85
1 බන්දු 30 ගාල්ල 92
3 දිල්රුක් 28 කොළඹ 95
- NOT (`~`): 'නගරය' 'කොළඹ' නොවන අය.
print(df[~(df['නගරය'] == 'කොළඹ')])
නම වයස නගරය ලකුණු
1 බන්දු 30 ගාල්ල 92
2 චාමර 22 මහනුවර 78
4 එරංග 35 ගම්පහ 88
5 ෆර්හාන් 29 ගාල්ල 80
isin() method එක
නිශ්චිත වටිනාකම් කිහිපයක් ඇතුලත් වන Data තෝරාගැනීමට isin() method එක පාවිච්චි කරන්න පුළුවන්. උදාහරණයක් විදිහට, 'නගරය' 'කොළඹ' හෝ 'ගාල්ල' වන අය.
print(df[df['නගරය'].isin(['කොළඹ', 'ගාල්ල'])])
නම වයස නගරය ලකුණු
0 අනුර 25 කොළඹ 85
1 බන්දු 30 ගාල්ල 92
3 දිල්රුක් 28 කොළඹ 95
5 ෆර්හාන් 29 ගාල්ල 80
Smart Querying: query() method එක
Boolean Indexing තරමක් සංකීර්ණ විය හැකි අවස්ථාවලදී, විශේෂයෙන් කොන්දේසි ගොඩක් තිබේ නම්, query() method එක කෝඩ් එක කියවීමට පහසු කරවනවා. මේක String expressions පාවිච්චි කරලා Data filter කරන්න අපිට ඉඩ දෙනවා.
වයස අවුරුදු 28ට වැඩි සහ 'නගරය' 'කොළඹ' වන අය තෝරාගැනීමට query() පාවිච්චි කරන හැටි බලමු:
print(df.query('වයස > 28 and නගරය == "කොළඹ"'))
Empty DataFrame
Columns: [නම, වයස, නගරය, ලකුණු]
Index: []
මේ උදාහරණය අනුව අපේ Data Frame එකේ එහෙම කට්ටිය නැහැ. ඒක Empty DataFrame එකක් දුන්නා. 'නගරය' 'ගාල්ල' වන අය තෝරාගමු.
print(df.query('වයස > 28 and නගරය == "ගාල්ල"'))
නම වයස නගරය ලකුණු
1 බන්දු 30 ගාල්ල 92
5 ෆර්හාන් 29 ගාල්ල 80
query() method එක ඇතුලේ අපිට වෙනත් Python variables පාවිච්චි කරන්නත් පුළුවන්. ඒ සඳහා variable එකට ඉස්සරහින් @ ලකුණක් දාන්න ඕනේ.
min_score = 90
print(df.query('ලකුණු > @min_score'))
නම වයස නගරය ලකුණු
1 බන්දු 30 ගාල්ල 92
3 දිල්රුක් 28 කොළඹ 95
වැදගත් දේවල් සහ Best Practices
දැන් අපි Data Selection & Filtering කරන විවිධ ක්‍රම ගැන දන්නවා. දැන් අපි බලමු මේවා භාවිතා කරද්දී මතක තියාගන්න ඕන වැදගත් කරුණු සහ Best Practices මොනවද කියලා.
Chained Indexing Warnings (SettingWithCopyWarning)
මේක Data Science වලදී ගොඩක් අයට මුලදී එන පොදු ගැටළුවක්. ඔබ DataFrame එකක කොටසක් තෝරාගෙන ඒකට අගයක් assign කරන්න උත්සාහ කරද්දී මේ warning එක එන්න පුළුවන්.
උදාහරණයක් විදිහට, මේ වගේ කෝඩ් එකක් ලියන එකෙන් වැළකෙන්න:
# වැරදි ක්‍රමය: SettingWithCopyWarning එකක් එන්න පුළුවන්
# df[df['නගරය'] == 'කොළඹ']['ලකුණු'] = 100
මේකේදී Pandas වලට හරියටම තේරෙන්නේ නැහැ, ඔබ original DataFrame එකේම Data වෙනස් කරන්නද හදන්නේ, නැත්නම් ඒකේ copy එකක් අරගෙන ඒකේ Data වෙනස් කරන්නද කියලා. ඒ නිසා, මේ වගේ Warning එකක් එනවා.
මේක මගහරවාගන්න, හැමවිටම loc පාවිච්චි කරන්න. loc වලදී ඔබට එක වරම රෝස් සහ කොලම් දෙකම නිශ්චිතවම specify කරන්න පුළුවන්.
# නිවැරදි ක්‍රමය: loc පාවිච්චි කිරීම
df.loc[df['නගරය'] == 'කොළඹ', 'ලකුණු'] = 100
print(df)
නම වයස නගරය ලකුණු
0 අනුර 25 කොළඹ 100
1 බන්දු 30 ගාල්ල 92
2 චාමර 22 මහනුවර 78
3 දිල්රුක් 28 කොළඹ 100
4 එරංග 35 ගම්පහ 88
5 ෆර්හාන් 29 ගාල්ල 80
දැන් බලන්න, කොළඹ නගරයේ අයගේ ලකුණු 100ට වෙනස් වෙලා තියෙනවා. මෙතනදී කිසිම Warning එකක් ආවේ නැහැ.
loc සහ iloc explicit විදිහට පාවිච්චි කරන්න
Data selection කරද්දී හැමවිටම loc හෝ iloc පැහැදිලිවම පාවිච්චි කරන්න පුරුදු වෙන්න. මේකෙන් ඔබේ කෝඩ් එක කියවන්න ලේසියි, වරදවා වටහාගැනීම් අඩු වෙනවා, සහ SettingWithCopyWarning වගේ දේවල් වලින් බේරෙන්න පුළුවන්.
# හොඳ පුරුද්දක්:
selected_data = df.loc[df['වයස'] > 25, ['නම', 'ලකුණු']]
print(selected_data)
නම ලකුණු
1 බන්දු 92
3 දිල්රුක් 95
4 එරංග 88
5 ෆර්හාන් 80
කාර්යක්ෂමතාව (Performance)
විශාල Data sets එක්ක වැඩ කරද්දී Performance කියන එක ගොඩක් වැදගත්. query() method එක Pandas වලට C-level speed එකකින් Data filter කරන්න පුළුවන් නිසා, ගොඩක් විශාල Data sets වලට මේක වේගවත් වෙන්න පුළුවන්. Boolean Indexing සාමාන්‍යයෙන් හොඳින් ක්‍රියාත්මක වුවත්, සංකීර්ණ Multiple conditions වලදී query() method එක කියවීමට පහසු සහ සමහර විට වේගවත් වෙන්න පුළුවන්.
නිගමනය
Pandas වල Data Selection & Filtering කියන්නේ Data Analysis වලදී අනිවාර්යයෙන්ම දැනගත යුතුම දේවල්. loc, iloc, Boolean Indexing, සහ query() method එක පාවිච්චි කරලා ඔබට ඕන Data Frame එකක ඕනෑම කොටසක් තෝරාගන්නත්, කොන්දේසි මත Filter කරන්නත් පුළුවන්.
මේ Tools හොඳින් භාවිතා කරන්න පුළුවන් නම්, Data Cleaning, Data Preprocessing, සහ Data Analysis වලදී ඔබේ වැඩ ගොඩක් පහසු කරගන්න පුළුවන්. මතක තියාගන්න, SettingWithCopyWarning එක වගේ දේවල් වලින් පරිස්සම් වෙලා, හැමවිටම loc සහ iloc පැහැදිලිවම පාවිච්චි කරන්න.
දැන් ඉතින් පුළුවන් මේක ඔයාලගේම Data sets වලට Apply කරලා බලන්න. ඔයාලගේ Data Science Project වලට මේවා කොහොමද පාවිච්චි කරන්නේ? ඔයාලට ගැටළු ආවද? Comment section එකේ කියන්න! Data Science ලෝකයේ ඉදිරියට යන්නට මේ දැනුම ඔබට ගොඩක් උපකාරී වේවි. සුභ ගමන්!