Python Functions: මූලික සංකල්ප | Programming Basics Sinhala SC Guide

කොහොමද යාළුවනේ, ඔයාලා හැමෝටම සුභ දවසක්! අද අපි කතා කරන්න යන්නේ programming වල ගොඩක්ම වැදගත්, නිතරම භාවිතා වෙන, හැමෝටම අනිවාර්යයෙන්ම දැනගන්න ඕනම topic එකක් ගැන. ඒ තමයි Functions!

අපි හිතමු ඔයාලා software එකක් හදනවා කියලා. ඒකෙදි එකම වැඩේ, එකම code කෑල්ල ආයෙ ආයෙ ලියන්න වෙනවා කියලා. උදාහරණයක් විදියට, customer කෙනෙක්ගේ data validate කරන code එකක්. මේක customer create කරනකොටත් ඕන වෙනවා, customer update කරනකොටත් ඕන වෙනවා. එතකොට ඔයාලා මොකද කරන්නේ? ආයෙ ආයෙ ඒ code එකම copy-paste කරනවද? එහෙම කරොත්, පස්සේ කාලෙක ඒ validate කරන method එකේ පොඩි වෙනසක් කරන්න වුනොත්, ඒ copy කරපු හැම තැනකම ගිහින් වෙනස් කරන්න වෙනවා. හරිම කරදරයක් නේද? ඒ විතරක් නෙවෙයි, code එක ලොකුවට පැටලිලා යනවා, කියවන්නත් අමාරු වෙනවා.

ඔන්න ඔය වගේ වෙලාවට තමයි functions කියන concept එක අපේ rescue එකට එන්නේ! functions කියන්නේ, අපිට ඕන කරන code කෑල්ලක් එක තැනක ලියලා, ඒකට නමක් දීලා, අපිට ඕන ඕන තැනින් ඒ නමෙන් call කරලා භාවිතා කරන්න පුළුවන් විදියට හදන method එකක්. ඒක හරියට, ඔයාලා ගෙදර tea එකක් හදනකොට, "වතුර ටිකක් රත් කරන්න" කියලා පොඩි sub-recipe එකක් හදාගෙන, හැම තේ හදන වෙලාවකම ඒක use කරනවා වගේ වැඩක්.

අද අපි බලමු functions කියන්නේ මොනවද, ඒවගේ වැදගත්කම මොකක්ද, කොහොමද ඒවා හදාගන්නේ, පාවිච්චි කරන්නේ කියලා. ඒ වගේම functions use කරනකොට වෙන්න පුළුවන් පොඩි පොඩි වැරදි වළක්වා ගන්නේ කොහොමද කියලත් බලමු. එහෙනම්, අපි පටන් ගමු!

Functions මොකටද? (Why Functions?)

Functions පාවිච්චි කරන්න ප්‍රධාන හේතු කීපයක් තියෙනවා:

1. Code එක නැවත පාවිච්චි කිරීම (Reusability): උඩ කියපු උදාහරණය වගේ, එකම code කෑල්ලක් කීප තැනක අවශ්‍ය නම්, ඒක function එකක් විදියට ලියලා, ඕනෑම තැනකදී call කරන්න පුළුවන්. මේකෙන් වෙන්නේ ඔයාට code ලියන්න ගතවෙන වෙලාව අඩු වෙන එකයි, ඒ වගේම code එකේ consistency එකක් පවත්වා ගන්න පුළුවන් වෙන එකයි.
2. Code එක පිළිවෙලට තැබීම (Modularity): ලොකු program එකක් පොඩි පොඩි කොටස් වලට (functions වලට) කඩා ගන්න පුළුවන්. ඒක හරියට ලොකු building එකක් හදනකොට, බිත්ති, වහලය, ජනේල කියලා වෙන වෙනම කොටස් වලට හදාගන්නවා වගේ. මේකෙන් code එක තේරුම් ගන්න, maintain කරන්න, debug කරන්න හරිම ලේසියි.
3. පැහැදිලි බව (Readability): Functions වලට තේරුමක් තියෙන නම් දානකොට, code එක බලන කෙනෙකුට ඒ function එකෙන් මොකක්ද වෙන්නේ කියලා එක පාරටම තේරෙනවා. "add_numbers()" කියන function එකෙන් numbers add කරනවා කියලා ඕනම කෙනෙකුට තේරෙනවා නේද?
4. දෝෂ හඳුනා ගැනීම පහසු වීම (Easier Debugging): යම් කිසි error එකක් ආවොත්, ඒක ආවේ මොන function එකෙන්ද කියලා ඉක්මනින් හොයා ගන්න පුළුවන්. ඒ කියන්නේ, error එක හොයන්න මුළු code එකම search කරන්න ඕන වෙන්නේ නැහැ. Function එකක් ඇතුළේ විතරක් බැලුවම ඇති.

මේ හැම දෙයකින්ම වෙන්නේ ඔයාලගේ programming ජීවිතය ගොඩක් පහසු වෙන එකයි. ඒ නිසා functions කියන්නේ අනිවාර්යයෙන්ම ඉගෙන ගත යුතු දෙයක්!

Functions හදමු! (Defining Functions)

Python වල function එකක් හදන්න අපි def කියන keyword එක භාවිතා කරනවා. මේක තමයි function එකක මූලිකම දේ.

මූලික syntax එක:

def function_name():
    # Function එක ඇතුලේ run වෙන්න ඕන code එක
    print("මේක function එකක් ඇතුලේ තියෙනවා!")

• def: function එකක් define කරනවා කියන එක මේකෙන් කියවෙනවා.
• function_name: ඔයාගේ function එකට දාන නම. මේකේදී අර්ථවත් නමක් දෙන්න වග බලා ගන්න. (e.g., greet_user, calculate_total)
• (): මේවා තමයි parameters දාන තැන්. මේ ගැන අපි තව ටිකකින් කතා කරමු.
• :: function header එක ඉවර වෙන තැන. මේකට පස්සේ function එකේ body එක, අනිවාර්යයෙන්ම indent කරලා ලියන්න ඕන. Python වල indentation (ඉඩ තැබීම) ගොඩක් වැදගත්!

Function එකක් call කරන හැටි:

Function එකක් හැදුවට පස්සේ, ඒක ඇතුලේ තියෙන code එක run වෙන්නේ නිකන්ම නෙවෙයි. අපි ඒ function එකට call කරන්න ඕන. ඒ කියන්නේ, ඒකේ නම ලියලා, () දාලා execute කරන්න ඕන.

උදාහරණය:

# Function එක define කිරීම
def greet_user():
    print("ආයුබෝවන් යාළුවා! ඔයාට සුභ දවසක්!")

# Function එක call කිරීම
greet_user()

මේ code එක run කරාම output එක විදියට ආයුබෝවන් යාළුවා! ඔයාට සුභ දවසක්! කියලා print වෙයි. පට්ට නේද? ඕන තරම් පාරක් මේ greet_user() call කරන්න පුළුවන්.

Parameters, Arguments, සහ Return එක (Parameters, Arguments, and Return)

functions වලට තවත් වටිනාකමක් එකතු වෙන්නේ parameters සහ arguments එක්කයි, ඒ වගේම return statement එකත් එක්කයි.

Parameters සහ Arguments:

අපි හිතමු අපිට ඕන කරන්නේ user කෙනෙක්ගේ නම දීලා wish කරන්න කියලා. එතකොට හැම user කෙනෙකුටම වෙන වෙනම function එකක් හදන්න බැහැ නේද? ඔන්න ඔය වගේ වෙලාවට තමයි parameters උදව් කරන්නේ.

• Parameters: Function එක define කරනකොට () ඇතුළේ දාන variable name ටික. මේවා function එකට input ගන්නවා. හරියට ඔයාලගේ Blender එකට කපපු පළතුරු දානවා වගේ.
• Arguments: Function එක call කරනකොට parameters වලට දෙන actual values ටික. මේවා තමයි Blender එකට දාන actual පළතුරු ටික.

උදාහරණය:

# 'name' කියන parameter එක එක්ක function එක define කිරීම
def greet_specific_user(name):
    print(f"ආයුබෝවන් {name}! ඔයාට සුභ දවසක්!")

# 'Madhavi' කියන argument එක එක්ක function එක call කිරීම
greet_specific_user("Madhavi")

# 'Amara' කියන argument එක එක්ක function එක call කිරීම
greet_specific_user("Amara")

මේකෙන් වෙන්නේ, එකම greet_specific_user function එක පාවිච්චි කරලා, විවිධ නම් වලට wish කරන්න පුළුවන් වෙන එකයි. ගැම්මක් තමයි!

Return statement එක:

සමහර වෙලාවට functions වලින් වැඩක් කරලා අපිට ප්‍රතිඵලයක් (result එකක්) ආපහු ගන්න ඕන වෙනවා. උදාහරණයක් විදියට, numbers දෙකක් එකතු කරන function එකක් ලිව්වොත්, ඒකේ උත්තරේ අපිට ගන්න ඕන වෙනවා නේද? ඔන්න ඔය වෙලාවට return කියන statement එක පාවිච්චි කරනවා.

• return keyword එක function එකේ result එක function එක call කරපු තැනට ආපහු යවනවා.
• return statement එකක් run වුන ගමන්, function එකේ ඉතුරු code එක run වෙන්නේ නැහැ. Function එක එතනින් ඉවර වෙනවා.
• කිසිම return statement එකක් නැති function එකකින් automatically None කියන value එක return කරනවා.

උදාහරණය:

# Numbers දෙකක් එකතු කරන function එකක්
def add_numbers(num1, num2):
    sum_result = num1 + num2
    return sum_result # එකතු කරපු අගය ආපහු යවනවා

# Function එක call කරලා result එක variable එකකට ගන්නවා
result = add_numbers(5, 7)
print(f"අංක දෙකේ එකතුව: {result}") # Output: අංක දෙකේ එකතුව: 12

# තවත් උදාහරණයක්
another_sum = add_numbers(100, 200)
print(f"තවත් එකතුවක්: {another_sum}") # Output: තවත් එකතුවක්: 300

මේකෙන් පෙන්නන්නේ කොහොමද function එකකින් value එකක් return කරලා, ඒක program එකේ වෙනත් තැනක use කරන්නේ කියලා.

Docstrings - Code එකට Sinhala කතාවක්!

ඔයාලා function එකක් හදනකොට, ඒකෙන් මොකක්ද වෙන්නේ, මොන parameters ද ගන්නෙ, මොනවාද return කරන්නේ වගේ දේවල් අනිවාර්යයෙන්ම document කරන්න ඕන. මේකට තමයි Docstrings භාවිතා කරන්නේ.

• Docstrings කියන්නේ function එකක මුලටම (def line එකට පස්සේ) ත්‍රිත්ව quotations (""") ඇතුළේ ලියන String එකක්.
• මේක programmers ලාට function එකේ වැඩේ තේරුම් ගන්න උදව් වෙනවා.
• ඒ වගේම, Python වල help() function එක පාවිච්චි කරලා මේ Docstrings බලන්න පුළුවන්.

උදාහරණය:

def calculate_rectangle_area(length, width):
    """
    සෘජුකෝණාස්‍රයක වර්ගඵලය ගණනය කරයි.

    Parameters:
    length (int/float): සෘජුකෝණාස්‍රයේ දිග.
    width (int/float): සෘජුකෝණාස්‍රයේ පළල.

    Returns:
    float: ගණනය කරන ලද වර්ගඵලය.
    """
    area = length * width
    return area

# Docstring එක බලන්න:
print(help(calculate_rectangle_area))

# Function එක පාවිච්චි කිරීම
room_area = calculate_rectangle_area(10, 5)
print(f"කාමරයේ වර්ගඵලය: {room_area} වර්ග අඩි")

help(calculate_rectangle_area) කියලා print කරාම ඔයාලට මේ function එක ගැන ලියපු Docstring එක බලාගන්න පුළුවන් වෙයි. මේකෙන් ඔයාලට විතරක් නෙවෙයි, ඔයාලා එක්ක වැඩ කරන අනිත් අයටත් ගොඩක් උදව් වෙනවා.

වැරදුනොත් මොකද වෙන්නේ? (Troubleshooting Common Errors)

programming කරනකොට වැරදි වෙන එක සාමාන්‍ය දෙයක්. Functions වලදී වෙන්න පුළුවන් පොදු වැරදි කීපයක් සහ ඒවා නිවැරදි කරගන්නේ කොහොමද කියලා බලමු.

1. NameError: name 'function_name' is not defined

මේ error එක එන්නේ ඔයාලා define නොකරපු function එකක් call කරන්න ගියොත්. නැත්නම්, function එක define කරපු තැනට කලින් call කරන්න ගියොත්.

# වැරදි උදාහරණය:
say_hello()
# NameError: name 'say_hello' is not defined

def say_hello():
    print("Hello!")

නිවැරදි කිරීම: Function එක define කරලා ඉවර වෙලා තමයි call කරන්න ඕන. Python code එක line by line execute වෙන නිසා මේක මතක තියාගන්න.

# නිවැරදි උදාහරණය:
def say_hello():
    print("Hello!")

say_hello()

2. TypeError: function_name() missing N required positional arguments හෝ TypeError: function_name() takes X positional arguments but Y were given

මේ error එක එන්නේ function එකට දෙන arguments ගණන හරි නැත්නම්. ඒ කියන්නේ, function එක parameters X ගණනක් බලාපොරොත්තු වෙනකොට, ඔයාලා Y ගණනක් දුන්නොත්.

# වැරදි උදාහරණය 1: argument එකක් අඩුයි
def multiply(a, b):
    return a * b

result = multiply(5)
# TypeError: multiply() missing 1 required positional argument: 'b'

# වැරදි උදාහරණය 2: argument එකක් වැඩියි
def get_greeting():
    return "Hello!"

message = get_greeting("John")
# TypeError: get_greeting() takes 0 positional arguments but 1 was given

නිවැරදි කිරීම: function එක define කරලා තියෙන විදියට, ඒක බලාපොරොත්තු වෙන parameters ගණනට හරියටම ගැලපෙන්න arguments දෙන්න. අනිවාර්යයෙන්ම parameters වල data type එක ගැනත් සැලකිලිමත් වෙන්න.

# නිවැරදි උදාහරණය:
def multiply(a, b):
    return a * b

result = multiply(5, 10)
print(result)

def get_greeting():
    return "Hello!"

message = get_greeting()
print(message)

හොඳම පුරුදු (Best Practices)

Functions හදනකොට මේ හොඳ පුරුදු ටික මතක තියාගත්තොත්, ඔයාලගේ code එක තවත් quality වෙනවා.

1. Functions එකෙන් එකම වැඩේ හොඳින් කරන්න (Single Responsibility Principle - SRP): මේක ගොඩක් වැදගත් concept එකක්. Function එකක් හැම විටම එක වැඩක් විතරක් කරන්න ඕන. ඒකත් හරිම හොඳින්. උදාහරණයක් විදියට, process_customer_order() කියලා function එකක් හදනවා නම්, ඒක ඇතුළේ customer details validate කරන එක, order එක database එකට save කරන එක, payment process කරන එක, confirmation email එක යවන එක වගේ වැඩ ගොඩක් දාන්න එපා. ඒ හැම වැඩේටම වෙන වෙනම functions හදලා, process_customer_order() function එක ඇතුළේ ඒ functions call කරන්න. මේකෙන් code එක තේරුම් ගන්න, maintain කරන්න, test කරන්න හරිම ලේසියි.
2. පැහැදිලි සහ අර්ථවත් නම් (Clear and Meaningful Names): Functions වලට සහ parameters වලට අනිවාර්යයෙන්ම ඒවයින් මොකක්ද වෙන්නේ කියලා කියවෙන විදියට නම් දෙන්න. add_numbers කියන එක a_n_f කියන එකට වඩා ගොඩක් හොඳයි නේද?
3. Functions හැකිතාක් කුඩා කරන්න (Keep Functions Small): පොඩි functions maintain කරන්න සහ test කරන්න ලේසියි. ඒ වගේම, ඒවා නැවත පාවිච්චි කරන්නත් පහසුයි. එක function එකක් ඇතුළේ lines 500ක් 1000ක් තියෙනවා නම්, ඒකේ මොකක් හරි error එකක් හොයන එක මහා කරදරයක්.
4. Docstrings භාවිතා කරන්න: මේ ගැන අපි උඩින් කතා කරා. හැම function එකකටම අනිවාර්යයෙන්ම Docstring එකක් දාන්න පුරුදු වෙන්න.

මේ හොඳ පුරුදු ටික පාවිච්චි කරන එකෙන් ඔයාලා ලියන code එකේ quality එක ගොඩක් වැඩි වෙනවා. ඒ වගේම ඔයාලා Professional programmer කෙනෙක් විදියට දකින විදියත් වෙනස් වෙනවා.

අවසානය

ඔන්න යාළුවනේ, අද අපි Functions ගැන මූලික දැනුමක් ලබා ගත්තා. Functions කියන්නේ program එකක් ලස්සනට, කාර්යක්ෂමව, පහසුවෙන් maintain කරන්න උදව් වෙන සුපිරි tool එකක්. ඒක නැතුව software development කරන්න හිතන්නවත් බැහැ. Functions වල වැදගත්කම, ඒවා define කරන හැටි, parameters සහ arguments කියන්නේ මොනවද, return statement එකේ වැඩේ, Docstrings දාන හැටි, පොදු වැරදි සහ හොඳ පුරුදු ගැන ඔයාලා දැන් දන්නවා. මම හිතනවා මේ ලිපිය ඔයාලට ගොඩක් ප්‍රයෝජනවත් වෙන්න ඇති කියලා.

මේ concepts ඉගෙන ගත්තට මදි. අනිවාර්යයෙන්ම අදම මේ ගැන code කරලා practice කරන්න. පොඩි පොඩි functions ලියලා බලන්න. Numbers add කරන functions, string reverse කරන functions, temperature convert කරන functions වගේ දේවල් හදලා බලන්න.

මේ ලිපිය ගැන ඔයාලගේ අදහස් මොනවද? පහළින් comment section එකේ කියන්න. ඒ වගේම, ඔයාලා තවත් මොන වගේ programming topics ගැනද දැනගන්න කැමති කියලාත් comment කරන්න. අපි ඉදිරියේදී ඒ ගැන ලිපි ගේන්න බලමු.

එහෙනම්, හැමෝටම ජය වේවා! Code කරන්න පටන් ගන්න, වැරදුනොත් බය වෙන්න එපා, ආයෙ උත්සාහ කරන්න!