Python Sinhala - Part 12: කෝඩ් එක Pro Level එකට ගෙනියමු! (Errors, Lambda & Decorators) 🚀🔥

අපි Python Series එකේ Part 01 ඉඳලා Part 11 වෙනකම් Basic Concepts, OOP, Tkinter වලින් GUI හදන හැටි වගේම Pygame වලින් සුපිරි ගේම් එකක් හදන හැටිත් කතා කළා. හැබැයි ඒ හැමදේම ඉගෙනගත්තත්, තාමත් ඔයා ලියන Code එකේ පොඩි "Beginner" ගතියක් තියෙනවා නේද?

හිතන්න ඔයා හදපු Software එක පාවිච්චි කරන කෙනෙක් වැරදි Data එකක් ඇතුළත් කළොත් මොකද වෙන්නේ? සම්පූර්ණ Software එකම Crash වෙලා වැහෙනවා! ඒ වගේම පේළි 10කින් ලියන For loop එකක් එක පේළියට ගේන්න පුළුවන් කියලා ඔයා දන්නවද?

අද KP Tech Gear අපි කතා කරන්න යන්නේ සාමාන්‍ය Coder කෙනෙක්, Professional Software Engineer කෙනෙක් බවට පත් කරන අතිශය වැදගත් මාතෘකා කිහිපයක් ගැන. ඒ තමයි Exception Handling, List Comprehensions, Lambda Functions සහ Decorators!

🛡️ 1. කෝඩ් එක Crash නොවී බේරගමු! (Exception Handling)

මතකද අපි Java Part 12 වලදී Try-Catch පාවිච්චි කරලා Errors අල්ලන හැටි කතා කළා? අන්න ඒ සංකල්පයම තමයි Python වලදිත් අපි පාවිච්චි කරන්නේ. හැබැයි Python වල මේක ටිකක් ලේසියි වගේම ගොඩක් Smart.

උදාහරණයක් විදියට අපි User ගෙන් අංක 2ක් ඉල්ලලා බෙදීමක් කරන (Division) ප්‍රෝග්‍රෑම් එකක් හදමු.

def divide_numbers():
    num1 = int(input("පළමු අංකය දෙන්න: "))
    num2 = int(input("දෙවන අංකය දෙන්න: "))
    answer = num1 / num2
    print(f"පිළිතුර: {answer}")

divide_numbers()

⚠️ ප්‍රශ්නය:
මේ කෝඩ් එක වැඩ කරනවා. හැබැයි User දෙවන අංකය විදියට 0 (බිංදුව) දුන්නොත් මොකද වෙන්නේ? ගණිතයේදී කිසිම සංඛ්‍යාවක් බිංදුවෙන් බෙදන්න බෑ. ඒ නිසා ZeroDivisionError කියලා Error එකක් ඇවිත් මුළු ප්‍රෝග්‍රෑම් එකම Crash වෙනවා!

මෙන්න මේ වගේ වෙලාවට තමයි අපි try සහ except පාවිච්චි කරන්නේ. අපි කෝඩ් එකට කියනවා "මේක ට්‍රයි කරලා බලන්න, හැබැයි වැරදුනොත් Crash වෙන්න එපා, මේ විදියට Handle කරන්න" කියලා.

def safe_division():
    try:
        # ප්‍රශ්නයක් වෙන්න පුළුවන් කෝඩ් එක මේක ඇතුලේ ලියනවා
        num1 = int(input("පළමු අංකය දෙන්න: "))
        num2 = int(input("දෙවන අංකය දෙන්න: "))
        answer = num1 / num2
        print(f"පිළිතුර: {answer}")

    except ZeroDivisionError:
        # බිංදුවෙන් බෙදුවොත් මේක වැඩ කරනවා
        print("❌ වැරදියි! කිසිම අගයක් 0 න් බෙදන්න බැහැ මචං.")

    except ValueError:
        # අංකයක් වෙනුවට අකුරක් ගැහුවොත් මේක වැඩ කරනවා
        print("❌ ඔයා ඇතුලත් කරේ අංකයක් නෙවෙයි!")

    except Exception as e:
        # වෙන ඕනෑම නොහිතපු Error එකක් ආවොත් (Catch all)
        print(f"❌ අපොයි! පොඩි අවුලක්: {e}")

    finally:
        # Error ආවත් නැතත් මේක අනිවාර්යයෙන්ම Run වෙනවා
        print("✅ ක්‍රියාවලිය අවසන්!")

💡 The Best Practice:

කවදාවත් නිකම්ම except: කියලා දාලා errors වහන්න එපා. අනිවාර්යයෙන්ම ඒ එන්නේ මොන Error එකද කියලා (උදා: ZeroDivisionError, FileNotFoundError) පැහැදිලිවම අල්ලන්න. ඒක තමයි හොඳම Software Engineer කෙනෙක්ගේ ලක්ෂණය!

⚡ 2. පේළි 5ක් එක පේළියට ගේන මැජික් එක! (List Comprehensions)

අපි හිතමු ඔයා ගාව අංක තියෙන List එකක් තියෙනවා. ඔයාට ඕනේ ඒ අංක වල වර්ගය (Square) හොයලා අලුත් List එකක් හදන්න. සාමාන්‍ය කෙනෙක් මේක ලියන්නේ for loop එකක් පාවිච්චි කරලා මෙහෙමයි:

# සාමාන්‍ය Beginner විදිය (Traditional For Loop)
numbers = [1, 2, 3, 4, 5]
squared_numbers = []

for n in numbers:
    squared_numbers.append(n * n)

print(squared_numbers) # [1, 4, 9, 16, 25]

මේක වැරදි නෑ. හැබැයි Python හදපු අය අපිට මීට වඩා ලස්සන, පට්ටම speed ක්‍රමයක් දීලා තියෙනවා. ඒකට කියන්නේ List Comprehensions කියලා. බලන්න අර පේළි 4ම අපි එක පේළියට ගේන හැටි!

# 🚀 Pro Level විදිය (List Comprehension)
numbers = [1, 2, 3, 4, 5]

# සූත්‍රය: [Expression for Item in Iterable]
squared_numbers = [n * n for n in numbers]

print(squared_numbers) # [1, 4, 9, 16, 25]

Condition එකක් (If) එක්ක List Comprehensions දාමු

අපිට ඕනේ අර List එකෙන් ඉරට්ටේ සංඛ්‍යා (Even numbers) විතරක් තෝරගන්න නම්?

# සාමාන්‍ය අංක ටික
nums = [1, 2, 3, 4, 5, 6, 7, 8]

# 2න් බෙදුවම ඉතිරිය බිංදුව වෙන (ඉරට්ටේ) අංක විතරක් ගන්නවා
even_nums = [x for x in nums if x % 2 == 0]

print(even_nums) # Output: [2, 4, 6, 8]

🎭 3. නමක් නැති Functions (Lambda) සහ Map/Filter

අපි Part 07 වල Functions (def පාවිච්චි කරලා) හදන හැටි ඉගෙනගත්තා නේද? හැබැයි සමහර වෙලාවට අපිට පොඩි වැඩක් කරගන්න සම්පූර්ණ Function එකක් ලිය ලිය ඉන්න කම්මැලියි. අන්න ඒ වෙලාවට පාවිච්චි කරන "නමක් නැති" (Anonymous) චූටි Functions වලට තමයි Lambda Functions කියන්නේ.

# සාමාන්‍ය Function එකක්
def add(a, b):
    return a + b

# ඒකම Lambda එකකින් ලියන හැටි
# සූත්‍රය: lambda arguments : expression
add_magic = lambda a, b : a + b

print(add_magic(10, 5)) # Output: 15

මේ Lambda ගොඩක්ම පාවිච්චි කරන්නේ map() සහ filter() කියන Built-in functions එක්ක.

🗺️ Map() Function:
List එකක තියෙන හැම Item එකකටම එකම Function එකක් Apply කරන එක තමයි Map එකෙන් කරන්නේ.

prices = [100, 200, 300]
# හැම ගානටම 10% ක Tax එකක් එකතු කරමු
final_prices = list(map(lambda x: x * 1.10, prices))

print(final_prices) # Output: [110.0, 220.0, 330.0]

🔍 Filter() Function:
List එකක තියෙන දේවල් වලින් යම්කිසි කොන්දේසියකට (Condition) ගැළපෙන දේවල් විතරක් පෙරලා (Filter කරලා) ගන්න මේක පාවිච්චි කරනවා.

ages = [15, 22, 17, 30, 12, 19]

# වයස අවුරුදු 18ට වැඩි (Adults) අය විතරක් තෝරමු
adults = list(filter(lambda x: x >= 18, ages))

print(adults) # Output: [22, 30, 19]

✨ 4. Object Oriented Programming වල සැඟවුණු බලවේග (Dunder Methods)

අපි Part 09 වලදී OOP ගැන කතා කළා. ඔයා දැකලා ඇති අපි Class එකක් ඇතුලේ __init__ කියලා Function එකක් හැදුවා. මේ වගේ දෙපැත්තේම Underscores දෙකක් තියෙන (Double Underscore = Dunder) Methods වලට අපි කියනවා Magic Methods කියලා.

මේවායින් පුළුවන් අපේ Objects හැසිරෙන විදිය සම්පූර්ණයෙන්ම වෙනස් කරන්න. උදාහරණයක් විදියට ඔයා Class එකකින් හදපු Object එකක් Print කරොත් සාමාන්‍යයෙන් එන්නේ කැත Memory Address එකක් (උදා: <__main__.Book object at 0x00...>). ඒක ලස්සන කරන්නේ __str__ කියන Dunder Method එකෙන්.

class Book:
    def __init__(self, title, pages):
        self.title = title
        self.pages = pages

    # Object එකක් Print කරද්දී පෙන්වන්න ඕනේ මොකක්ද කියලා මෙතනින් හදනවා
    def __str__(self):
        return f"'{self.title}' පොතේ පිටු {self.pages} ක් තියෙනවා."

    # පොත් දෙකක් එකතු කරද්දී (+) මොකද වෙන්නේ කියලා මෙතනින් කියනවා
    def __add__(self, other):
        total_pages = self.pages + other.pages
        return Book("පොත් එකතුව", total_pages)

# Objects නිර්මාණය කිරීම
book1 = Book("Python Basics", 200)
book2 = Book("Advanced Python", 350)

# __str__ එක නිසා දැන් ලස්සනට Print වෙනවා
print(book1)
# __add__ එක නිසා පොත් දෙකේ පිටු ගාණ එකතු කරන්න පුළුවන්!
combo_book = book1 + book2
print(combo_book)

🎁 5. අනුන්ගේ Functions වලට මැජික් කෑලි එකතු කරමු! (Decorators)

Decorator එකක් කියන්නේ තියෙන Function එකක් වෙනස් කරන්නේ නැතුව (Code එකට අත තියන්නේ නැතුව), ඒකට අලුත් හැකියාවක් (Feature එකක්) එකතු කරන එකටයි. හරියට ඔයාගේ ෆෝන් එක ගලවන්නේ නැතුව ඒකට අලුත් කවර් එකක් දාලා ලස්සන කරනවා වගේ!

හිතන්න ඔයාට ඕනේ ඔයාගේ හැම Function එකක්ම Run වෙන්න කොච්චර වෙලා යනවද (Execution Time) කියලා බලාගන්න. අපි ඒකට ලස්සන Decorator එකක් හදමු.

import time

# Decorator Function එක නිර්මාණය කිරීම
def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time() # පටන් ගත් වෙලාව
        result = func(*args, **kwargs) # ඇතුලේ තියෙන Function එක Run කරනවා
        end_time = time.time() # ඉවර වුණු වෙලාව
        print(f"⏳ '{func.__name__}' Run වෙන්න තත්පර {end_time - start_time:.4f} ක් ගියා!")
        return result
    return wrapper

# අපි හදපු Decorator එක පාවිච්චි කරන හැටි (@ ලකුණ දාලා)
@timer_decorator
def heavy_calculation():
    print("ගණනය කිරීම ආරම්භ කරනවා...")
    total = sum([x * x for x in range(1000000)]) # ලොකු ගණනය කිරීමක්
    print("අවසන්!")

# Function එක Call කිරීම
heavy_calculation()

💡 Note:
ඔයා Python වලින් වෙබ් සයිට් හදන්න (Django / Flask) ඉගෙනගද්දී මේ @ ලකුණෙන් පටන් ගන්න Decorators පට්ටම ගොඩක් පාවිච්චි වෙනවා. (උදා: @app.route, @login_required). ඉතින් මේ සංකල්පය තේරුම් අරන් ඉන්න එක ඔයාගේ අනාගතයට ගොඩක් වැදගත්!

💡 KP Tech Gear Conclusion:

දැන් ඔයාට පේනවා ඇති නේද සාමාන්‍ය කෝඩ් එකක් පේළි ගාණ අඩු කරලා (List Comprehensions), Crash වෙන්නේ නැති වෙන්න ආරක්ෂා කරලා (Exception Handling) සහ ලස්සනට Automate කරලා (Decorators) ලියන විදිය? මේ දේවල් ඔයාගේ ඊළඟ Project එකේ ඉඳන්ම ප්‍රායෝගිකව පාවිච්චි කරන්න පටන් ගන්න. එතකොට ඔයාගේ Code එක දකින ඕනම Senior Software Engineer කෙනෙක්ට තේරෙනවා "මේක නම් Pro කෙනෙක්ගේ වැඩක්" කියලා!

අද KP Tech Gear ලිපියෙන් අලුත් දෙයක් ඉගෙනගත්තා නම් අනිවාර්යයෙන්ම පහළින් කමෙන්ට් එකක් දාගෙන යන්න. ඒ වගේම ඔයාගේ Coder යාලුවන්ටත් මේක Share කරන්න. මීළඟ ලිපියෙන් තවත් සුපිරි Tech මාතෘකාවකින් සෙට් වෙමු! ජය වේවා! 👇