ආයුබෝවන්, හැමෝටම!

අපි හැමෝම code ලියනවා නේද? හැබැයි සමහර වෙලාවට අපේ code එක අපි හිතන්නේ නැති විදිහට හැසිරෙනවා, නැත්නම් Error එකක් දීලා වැඩේ නවතිනවා. මේ වගේ වෙලාවට අපිට හිතෙනවා 'අනේ! මේක මම හිතුවට වඩා අමාරුයි' කියලා. විශේෂයෙන්ම, real-world applications වලදී මේ වගේ unplanned breakdowns කියන්නේ usersලට ලොකු අපහසුතාවයක්. ඒ වගේම අපේ system එකේ විශ්වාසනීයත්වයටත් ඒක බලපානවා. එහෙනම්, කොහොමද මේ ගැටලුවට විසඳුමක් හොයාගන්නේ?

අන්න ඒකට තමයි Error Handling කියන concept එක අපිට උදව් වෙන්නේ. සරලවම කිව්වොත්, Error Handling කියන්නේ අපේ code එක run වෙනකොට එන unforeseen errors, නැත්නම් Exceptions, පිළිවෙලකට handle කරන එක. Python වගේ භාෂාවකදී මේකට try, except, else, finally කියන ප්‍රධාන tools ටිකක් තියෙනවා. අද අපි මේ ගැන විස්තරාත්මකව කතා කරමු, මොකද මේක ඕනෑම Software Engineer කෙනෙකුට අනිවාර්යෙන්ම දැනගන්න ඕන දෙයක්!

Error එකක් කියන්නේ මොකක්ද? (Exceptions vs. Syntax Errors)

මුලින්ම අපි බලමු Error එකක් කියන්නේ මොකක්ද කියලා. අපේ program එකේ Errors ප්‍රධාන වර්ග දෙකකට වෙන් කරන්න පුළුවන්:

1. Syntax Errors

මේවා තමයි program එකේ ව්‍යාකරණ (grammar) වැරදි. අපි code එක ලියනකොට කරන mistakes. Python interpreter එකට මේ code එක තේරුම් ගන්න බැරි වෙනවා. මේවා compile-time errors විදිහටත් හඳුන්වනවා, මොකද program එක run කරන්න කලින්ම මේ වැරදි පෙන්නනවා. උදාහරණයක් විදිහට, print function එකේ වරහන් (parentheses) දාන්න අමතක වුණොත්:

# Syntax Error උදාහරණයක්
print "Hello, World!"

මේ code එක run කරන්න හැදුවොත් අපිට SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello, World!")? වගේ error එකක් ලැබෙනවා. මේවා program එක ආරම්භ කරන්න කලින්ම හදාගන්න ඕන.

2. Exceptions

මේවා තමයි program එක run වෙනකොට (run-time) ඇතිවන වැරදි. Syntax එක නිවැරදි වුණත්, program එකේ logic එකේ හෝ external factors නිසා මේ වැරදි ඇති වෙන්න පුළුවන්. උදාහරණයක් විදිහට, බිංදුවෙන් බෙදීම, නැති file එකක් open කරන්න උත්සාහ කිරීම, හෝ data type එකක් වැරදි විදිහට පාවිච්චි කිරීම වගේ දේවල්.

# Exception උදාහරණයක්
result = 10 / 0
print(result)

මේ code එක run කළොත් අපිට ZeroDivisionError: division by zero කියන Exception එක ලැබෙනවා. අද අපි කතා කරන්නේ මේ Exceptions ගැනයි, මොකද මේවා තමයි අපිට try-except වගේ blocks පාවිච්චි කරලා handle කරන්න පුළුවන්.

try-except එකතුව: වැඩේ පටන් ගනිමු!

try-except block එක කියන්නේ Python වල Error Handling වල මූලිකම කොටස. මේක වැඩ කරන්නේ මෙහෙමයි:

• try block: මේ ඇතුලට අපි දාන්නේ error එකක් එන්න පුළුවන් කියලා හිතන code එක.
• except block: try block එක ඇතුලේ error එකක් ආවොත්, ඒ error එක handle කරන්න ඕන code එක මේක ඇතුලට දානවා. Error එකක් ආවේ නැත්නම් except block එක execute වෙන්නේ නැහැ.

සරල උදාහරණයක් බලමු:

print("-- සංඛ්‍යා දෙකක් බෙදීම --")
try:
    num1 = int(input("පළමු සංඛ්‍යාව ඇතුලත් කරන්න: "))
    num2 = int(input("දෙවන සංඛ්‍යාව ඇතුලත් කරන්න: "))
    
    result = num1 / num2
    print(f"පිළිතුර: {result}")
except ZeroDivisionError:
    print("වැරදීමක්! ඔබට බිංදුවෙන් බෙදිය නොහැක.")
except ValueError:
    print("වැරදීමක්! කරුණාකර වලංගු සංඛ්‍යාවක් ඇතුලත් කරන්න.")

print("වැඩසටහන අවසන්.")

මේ උදාහරණයේදී, අපි input එකක් ගන්නවා. දෙවැනි සංඛ්‍යාව 0 වුණොත් ZeroDivisionError එකක් එනවා. එහෙම නැත්නම්, user numeric value එකක් වෙනුවට text එකක් දුන්නොත් ValueError එකක් එනවා. මේ Exceptions දෙකම except blocks වලින් handle කරලා තියෙනවා. මේකෙන් වෙන්නේ program එක crash නොවී, user ට තේරෙන විදිහට message එකක් දාලා වැඩේ continue වෙන එක.

පොදු Exception වර්ග (ValueError, TypeError, FileNotFoundError)

Python වල ගොඩක් built-in Exception types තියෙනවා. අපි වැඩියෙන්ම දකින Exception වර්ග කිහිපයක් ගැන බලමු:

1. ValueError

මේක එන්නේ operation එකකට වලංගු නොවන අගයක් (invalid value) දුන්නම. ඒ කියන්නේ data type එක නිවැරදි වුණත්, value එක වැරදියි.

# ValueError උදාහරණය
try:
    age_str = input("ඔබගේ වයස ඇතුලත් කරන්න: ") # 'දහඅට' වගේ දෙයක් දුන්නොත්
    age = int(age_str)
    print(f"ඔබගේ වයස: {age}")
except ValueError:
    print("වැරදීමක්! කරුණාකර වයස සඳහා වලංගු සංඛ්‍යාවක් ඇතුලත් කරන්න.")

2. TypeError

මෙය එන්නේ operation එකකට වැරදි data type එකක් (invalid data type) දුන්නම. උදාහරණයක් විදිහට, string එකක් එක්ක integer එකක් එකතු කරන්න හැදුවොත්.

# TypeError උදාහරණය
try:
    name = "Sunil"
    age = 30
    # string එකක් සහ integer එකක් එකතු කිරීමට උත්සාහ කිරීම
    full_info = name + age 
    print(full_info)
except TypeError:
    print("වැරදීමක්! ඔබට string එකක් integer එකක් සමග කෙලින්ම එකතු කල නොහැක.")

3. FileNotFoundError

මෙය එන්නේ නැති file එකක් open කරන්න, read කරන්න, නැත්නම් write කරන්න උත්සාහ කළොත්.

# FileNotFoundError උදාහරණය
try:
    with open("non_existent_file.txt", "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("වැරදීමක්! එම ගොනුව (file) සොයාගත නොහැක.")
except Exception as e:
    print(f"සාමාන්‍ය දෝෂයක් සිදුවිය: {e}")

except බ්ලොක් ගොඩක්: එක එක අවුල් වලට එක එක විසඳුම්

ඔබට එක try block එකකට except blocks කීපයක් තියන්න පුළුවන්. මේකෙන් අපිට පුළුවන් එක එක Exception වර්ග වලට වෙනස් විදිහට handle කරන්න. Python Exception එකක් search කරන්නේ except blocks පිළිවෙලින්. ඒ නිසා, විශේෂිත Exception (specific exception) එකක් මුලින්ම ලියන්න ඕන, ඊට පස්සේ සාමාන්‍ය Exception (general exception) එකක් ලියන්න ඕන.

උදාහරණයක් විදිහට, userගෙන් සංඛ්‍යා දෙකක් අරගෙන බෙදන program එකක් අපි කලින් බැලුවා. ඒක තව ටිකක් දියුණු කරමු:

print("-- සංඛ්‍යා දෙකක් බෙදීම (වැඩි දියුණු කල)
--")
try:
    num1_str = input("පළමු සංඛ්‍යාව ඇතුලත් කරන්න: ")
    num2_str = input("දෙවන සංඛ්‍යාව ඇතුලත් කරන්න: ")
    
    num1 = int(num1_str)
    num2 = int(num2_str)
    
    result = num1 / num2
    print(f"පිළිතුර: {result}")

except ValueError:
    print("වැරදීමක්! කරුණාකර වලංගු සංඛ්‍යා පමණක් ඇතුලත් කරන්න. (උදා: 10, 5)")
except ZeroDivisionError:
    print("වැරදීමක්! ඔබට බිංදුවෙන් බෙදිය නොහැක. දෙවන සංඛ්‍යාව බිංදුව නොවිය යුතුය.")
except Exception as e: # ඕනෑම වෙනත් Exception එකක් අල්ලගනී
    print(f"නොදන්නා දෝෂයක් සිදුවිය: {e}")

print("වැඩසටහන අවසන්.")

මේ උදාහරණයේදී, අපි ValueError, ZeroDivisionError වගේ විශේෂිත Exceptions වලට වෙනම messages දෙනවා. except Exception as e: කියන එකෙන් වෙන්නේ මේ කිසිම Exception එකකට අයිති නැති වෙනත් ඕනෑම Exception එකක් ආවොත් ඒක handle කරන එක. e කියන variable එකෙන් actual error message එක ගන්න පුළුවන්.

else සහ finally: අමතර බලතල!

try-except වලට අමතරව else සහ finally කියන blocks දෙකකුත් තියෙනවා, ඒවත් හරිම වැදගත්.

else Block

else block එක execute වෙන්නේ try block එක ඇතුලේ කිසිම Exception එකක් ඇති වුණේ නැත්නම් විතරයි. මේක try block එකේ code එක successful වුණාම run කරන්න ඕන code වලට පාවිච්චි කරන්න පුළුවන්.

# else block උදාහරණය
try:
    x = int(input("සංඛ්‍යාවක් ඇතුලත් කරන්න: "))
    y = 50 / x
except ValueError:
    print("වැරදීමක්! කරුණාකර වලංගු සංඛ්‍යාවක් ඇතුලත් කරන්න.")
except ZeroDivisionError:
    print("වැරදීමක්! බිංදුවෙන් බෙදිය නොහැක.")
else:
    print(f"සාර්ථකව බෙදුවා. පිළිතුර: {y}")
    print("කිසිදු දෝෂයක් වාර්තා නොවීය.")

මේකේදී, try block එක සාර්ථක වුණොත්, else block එක execute වෙනවා. Error එකක් ආවොත්, except block එක execute වෙලා else block එක skip වෙනවා.

finally Block

finally block එක කියන්නේ try-except-else block sequence එකේ අවසානම පියවර. මේකේ තියෙන code එක අනිවාර්යෙන්ම execute වෙනවා, Exception එකක් ආවත් නැතත්, program එක crash වුණත්. Resources cleanup කරන්න, file එකක් close කරන්න, database connection එකක් වහන්න වගේ දේවල් වලට මේක ගොඩක් වැදගත්.

# finally block උදාහරණය
file = None
try:
    file = open("my_data.txt", "r")
    content = file.read()
    print("ගොනුව සාර්ථකව කියවන ලදී.")
    # සමහරවිට මෙතන Exception එකක් එන්න පුළුවන්
    # data = int(content) 
except FileNotFoundError:
    print("වැරදීමක්! 'my_data.txt' ගොනුව සොයාගත නොහැක.")
except Exception as e:
    print(f"අනපේක්ෂිත දෝෂයක්: {e}")
finally:
    if file:
        file.close()
        print("ගොනුව වසා දමන ලදී.")
    else:
        print("ගොනුව විවෘත කිරීමට නොහැකි විය.")

print("වැඩසටහන අවසන්.")

මේ උදාහරණයේදී, my_data.txt කියන file එක තිබුණත් නැතත්, Exception එකක් ආවත් නැතත්, finally block එකේ තියෙන file.close() කියන එක අනිවාර්යෙන්ම execute වෙනවා. ඒකෙන් වටිනා resources නිකරුණේ open වෙලා තියෙන එක නවතිනවා.

වැදගත් උපදෙස් (Best Practices): පිරිසිදු විදිහට වැඩ කරමු!

Error Handling කියන්නේ 그냥 code එකක් එන error එකකට වැටෙන්නේ නැතිව තියන්න විතරක් නෙමෙයි. ඒකෙන් අපේ code එකේ Quality එක, Maintainability එක, සහ User Experience එකත් වැඩිදියුණු වෙනවා. මේවා තමයි best practices කිහිපයක්:

1. Be Specific with Exceptions: හැම Exception එකක්ම අල්ලගන්න except Exception as e: වගේ general block එකක් පුළුවන් තරම් අඩුවෙන් පාවිච්චි කරන්න. ඒ වෙනුවට, ValueError, TypeError වගේ නිශ්චිත Exception වර්ග handle කරන්න. මේකෙන් අපිට ගැටලුව මොකක්ද කියලා හරියටම දැනගෙන ඒකට විතරක් අදාළ message එකක් දෙන්න පුළුවන්.
2. Clear and Informative Error Messages: User ට තේරෙන විදිහට error messages දෙන්න. 'Something went wrong' වගේ message එකක් දෙනවාට වඩා 'Invalid input: Please enter a number between 1 and 100' වගේ දෙයක් user ට වැඩිය ප්‍රයෝජනවත්.
3. Log Errors: Production system වලදී, errors එනවා නම් ඒ ටික log කරන්න. ඒ කියන්නේ file එකකට, database එකකට, නැත්නම් monitoring system එකකට මේ errors වල විස්තර save කරන්න. මේකෙන් අපිට පස්සේ errors troubleshoot කරන්න ලේසි වෙනවා. Python වල logging module එක මේකට පාවිච්චි කරන්න පුළුවන්.
4. Don't Suppress Errors Unnecessarily: සමහර අය error එකක් ආවම මුකුත්ම නොකර pass කරනවා. (e.g., except Exception: pass). මේක කවදාවත් කරන්න හොඳ නැහැ. මොකද එතකොට program එකේ hidden bugs ඇති වෙන්න පුළුවන්. හැම error එකක්ම handle කරන්න, නැත්නම් අඩුම ගානේ log කරන්න.
5. Keep try Blocks Small: try block එක ඇතුලේ අදාල නැති code ගොඩක් දාන්න එපා. Error එකක් එන්න පුළුවන් කියලා හිතන line එක විතරක් try block එක ඇතුලට දාන්න. එතකොට code එක කියවන්න ලේසියි වගේම, error එක ආවේ කොතනින්ද කියලා identify කරන්නත් ලේසියි.

අවසාන වශයෙන්…

දැන් ඔයාලට Python වල Error Handling වලට අදාළව try, except, else, finally කියන concepts ගැන හොඳ අවබෝධයක් ඇති කියලා හිතනවා. මේක පුහුණු වෙන්න ඕන දෙයක්. ඔයාලගේ code වලට මේ Error Handling methods එකතු කරලා බලන්න. එතකොට ඔයාලටම තේරෙයි මේක කොයිතරම් වැදගත්ද කියලා.

මතක තියාගන්න, හොඳ software engineer කෙනෙක් කියන්නේ error නැතුව code ලියන කෙනෙක් නෙමෙයි, එන errors බුද්ධිමත්ව handle කරන කෙනෙක්. එහෙනම්, ඔයාලගේ code වලට මේ techniques යොදාගෙන, තව තවත් ශක්තිමත් applications හදන්න.

ඔයාලට මේ post එක ගැන මොන වගේ අදහස්ද තියෙන්නේ? මේ වගේ topics ගැන තවත් දැනගන්න ඕනද? ඔයාලගේ අත්දැකීම් මොනවද? Comment section එකේ අපිට කියන්න. ඒ වගේම, මේ post එක යාළුවන්ටත් share කරන්න අමතක කරන්න එපා. තවත් මේ වගේම පට්ට technical post එකකින් නැවත හමුවෙමු!

Happy Coding!