Python Functions වල Arguments ගැන සරලව - Positional, Keyword, Default SC Guide

ආයුබෝවන් කට්ටිය! කොහොමද ඉතින්? අද අපි කතා කරන්න යන්නේ ඔයාලා හැමෝටම වැදගත් වෙන, Software Engineering වලදී නිතරම වගේ පාවිච්චි වෙන, Functions වල Arguments ගැන. පොඩි පොඩි දේවල් වලින් පටන් අරන්, පියවරෙන් පියවරට මේකේ ගැඹුරටම යමු නේද?

Functions කියන්නේ මොනවද ඇත්තටම?

මුලින්ම බලමු මේ Functions කියන්නේ මොනවද කියලා. සරලවම කිව්වොත් Functions කියන්නේ අපිට ඕන කරන වැඩ ටිකක් එකට දාලා හදාගන්න පුළුවන් පොඩි program block එකක්. මේකෙන් අපිට පුළුවන් එකම code එක ආයෙ ආයෙ ලියන්නේ නැතුව, ඕන වෙලාවක පාවිච්චි කරන්න. වැඩේ තව ලේසි වෙනවා නේද? හරියට අපි ගෙදරදී තේ හදනකොට කිරි, සීනි, තේ කොළ දාලා කරනවා වගේ වැඩක්. හැමදාම තේ හදනකොට මුල ඉඳන් කිරි හදන්නේ නෑනේ? ඒ වගේ තමයි Functions.

Functions වලට Inputs විදියට අපි දෙන values වලට තමයි Arguments කියලා කියන්නේ. මේ Arguments වර්ග කීපයක් තියෙනවා. අපි එකින් එක පැහැදිලිව බලමු.

1. Positional Arguments: පිළිවෙලට වැඩේ කරමු!

මේ Positional Arguments කියන්නේ අපි function එකක් call කරනකොට ඒකට දෙන values. මේවායේ විශේෂත්වය තමයි දෙන පිළිවෙල අනුව තමයි function එක ඇතුලේ ඒ value එක අදාළ variable එකට assign වෙන්නේ. නමෙන්ම කියවෙනවා වගේ 'position' එක, ඒ කියන්නේ පිහිටීම, වැදගත්.

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

අපි හිතමු කෙනෙක්ට සුභ පැතුමක් යවන්න function එකක් හදනවා කියලා. ඒකට අවශ්‍ය වෙන්නේ නමයි, මොකක්ද සුභ පතන්නේ කියන එකයි.

def wish_someone(name, message):
    print(f"ආයුබෝවන් {name}! {message}!")

# Positional arguments භාවිතයෙන් function එක call කරන හැටි
wish_someone("කසුන්", "සුභ උපන්දිනයක්")
# Output: ආයුබෝවන් කසුන්! සුභ උපන්දිනයක්!

wish_someone("අනුෂා", "සුභ අලුත් අවුරුද්දක්")
# Output: ආයුබෝවන් අනුෂා! සුභ අලුත් අවුරුද්දක්!

මේ උදාහරණයේදී, අපි wish_someone function එකට name සහ message කියන arguments දෙක පිළිවෙලට දෙනවා. මුලින්ම කසුන් කියන එක name එකටත්, සුභ උපන්දිනයක් කියන එක message එකටත් යනවා. හරියටම පිළිවෙලට වැඩේ සිද්ධ වෙනවා.

හැබැයි වැරදිලා මේවායේ පිළිවෙල මාරු කළොත් මොකද වෙන්නේ?

wish_someone("සුභ උපන්දිනයක්", "කසුන්") # මෙතන Syntax Error එකක් නෑ, හැබැයි output එක අමුතුයි
# Output: ආයුබෝවන් සුභ උපන්දිනයක්! කසුන්!

මේක run කරාම ආයුබෝවන් සුභ උපන්දිනයක්! කසුන්! වගේ දෙයක් print වෙයි. ඒකෙන් පැහැදිලි වෙනවා Positional Arguments වලදී පිළිවෙල කොච්චර වැදගත්ද කියලා. සමහර වෙලාවට මේකෙන් bugs එන්න පුළුවන්, මොකද code එක run වුණත් output එක වැරදියි. පරිස්සමෙන් පාවිච්චි කරන්න ඕනේ!

2. Keyword Arguments: නමෙන් අඳුනගමු!

දැන් අපි බලමු Keyword Arguments ගැන. මේවායේදී arguments වල පිළිවෙල වැදගත් වෙන්නේ නෑ. අපි argument එකේ නම (parameter name) පාවිච්චි කරලා ඒකට අදාළ value එක දෙනවා. මේකෙන් code එක කියවන්න ලේසියි, මොකද මොකක්ද මේ දෙන value එක කියලා පැහැදිලිව පේනවා. අර කලින් වගේ පිළිවෙල වරදින්නේ නෑ.

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

කලින් wish_someone function එකම ගමු. මේක Keyword Arguments වලින් call කරන්නේ මෙහෙමයි:

def wish_someone(name, message):
    print(f"ආයුබෝවන් {name}! {message}!")

# Keyword arguments භාවිතයෙන් function එක call කරන හැටි
wish_someone(name="නිරෝෂා", message="සුභ ගමන්")
# Output: ආයුබෝවන් නිරෝෂා! සුභ ගමන්!

wish_someone(message="ඉක්මන් සුවය", name="සමන්") # පිළිවෙල මාරු වුණත් ප්‍රශ්නයක් නෑ
# Output: ආයුබෝවන් සමන්! ඉක්මන් සුවය!

දැක්කා නේද? දෙවෙනි function call එකේදී අපි message එක මුලින්ම දුන්නා. ඒත් කිසිම ප්‍රශ්නයක් නෑ, මොකද අපි argument එකේ නම පාවිච්චි කරපු නිසා. name එකට සමන් කියන value එකත්, message එකට ඉක්මන් සුවය කියන value එකත් හරියටම assign වෙනවා. මේකෙන් code එකේ clarity එක (පැහැදිලිකම) ගොඩක් වැඩි වෙනවා, විශේෂයෙන්ම function එකට arguments ගොඩක් තියෙනවා නම්.

3. Default Arguments: පෙරනිමි අගයන්!

Default Arguments කියන්නේ function එකක් define කරනකොටම arguments වලට default values දෙන එක. මේකෙන් වෙන්නේ, අපි function එක call කරනකොට ඒ argument එකට value එකක් දුන්නේ නැත්නම්, default value එක automatically assign වෙනවා. දුන්නොත්, අපි දෙන value එක assign වෙනවා (default value එක overwrite වෙනවා). මේක මාරම පහසුවක්, මොකද හැම වෙලාවෙම හැම argument එකටම value එකක් දෙන්න ඕන වෙන්නේ නෑ.

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

අපි හිතමු email එකක් යවන්න function එකක් හදනවා කියලා. ඒකට recipient, subject, sender, body වගේ දේවල් ඕන වෙනවා. හැබැයි sender හැම වෙලාවෙම එකම කෙනා වෙන්න පුළුවන්, නැත්නම් subject එකක් නැති email එකක් වෙන්නත් පුළුවන්.

def send_email(recipient, subject="No Subject", sender="[email protected]", body=""):
    print(f"Sender: {sender}")
    print(f"Recipient: {recipient}")
    print(f"Subject: {subject}")
    print(f"Body: {body}")
    print("Email sent successfully!\n")

# Default values භාවිතයෙන් function එක call කිරීම
send_email("[email protected]") # Subject එකයි, sender එකයි default. body එක හිස්
# Output:
# Sender: [email protected]
# Recipient: [email protected]
# Subject: No Subject
# Body: 
# Email sent successfully!

send_email("[email protected]", subject="Meeting Reminder") # Subject එක replace කරනවා
# Output:
# Sender: [email protected]
# Recipient: [email protected]
# Subject: Meeting Reminder
# Body: 
# Email sent successfully!

send_email("[email protected]", body="Hi, check this out!", sender="[email protected]") # Default sender සහ body replace කරනවා
# Output:
# Sender: [email protected]
# Recipient: [email protected]
# Subject: No Subject
# Body: Hi, check this out!
# Email sent successfully!

මේ උදාහරණයේදී subject එකට "No Subject" කියලත්, sender එකට "[email protected]" කියලත්, body එකට හිස් string එකකුත් default values විදියට දීලා තියෙනවා. අපි send_email("[email protected]") කියලා call කරද්දි, [email protected] කියන එක recipient එකට යනවා. අනිත් ඒවාට default values ටික යනවා. subject එකට "Meeting Reminder" කියලා දුන්නම default value එක overwrite වෙනවා. මේක මාරම useful feature එකක්!

වැදගත් කරුණක්: Default Arguments තියන්න ඕන කොහොමද?

Default Arguments හැමවෙලේම Non-Default Arguments වලට පස්සේ තියෙන්න ඕනේ. ඒ කියන්නේ, default value එකක් නැති arguments මුලින්ම තියෙන්න ඕනේ, ඊට පස්සේ තමයි default values තියෙන arguments තියන්න පුළුවන්. නැත්නම් SyntaxError එකක් එයි. අනිවාර්යයෙන්ම මේ පිළිවෙල මතක තියාගන්න:

# හරි ක්‍රමය
def correct_func(param_without_default, param_with_default="නියමයි"):
    print(f"පළමු අගය: {param_without_default}, දෙවන අගය: {param_with_default}")

correct_func("ආයුබෝවන්")
# Output: පළමු අගය: ආයුබෝවන්, දෙවන අගය: නියමයි

# වැරදි ක්‍රමය (SyntaxError එකක් එයි)
# def wrong_func(param_with_default="නියමයි", param_without_default):
#     print(f"පළමු අගය: {param_without_default}, දෙවන අගය: {param_with_default}")

මේක ඉතාම වැදගත්! මතක තියාගන්න.

Best Practices සහ Troubleshooting Tips: ගැටලු නැතුව වැඩේ කරමු!

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

Default Values overwrite වෙන හැටි:

Default argument වලට value එකක් දුන්නොත්, ඒක default value එක overwrite කරනවා. මේක මතක තියාගන්න. සමහර වෙලාවට default value එකක් තියෙද්දීත් අපි ඒකට value එකක් දෙනවා, මොකද අපිට ඕන විශේෂිත value එකක් නිසා.

def send_notification(user, message="Hello!", type="email"):
    print(f"Sending {type} to {user}: {message}")

send_notification("Kasun") # default message සහ type යනවා
# Output: Sending email to Kasun: Hello!

send_notification("Nimal", message="Welcome to our platform!") # message එක overwrite වෙනවා
# Output: Sending email to Nimal: Welcome to our platform!

send_notification("Amal", type="sms", message="Your OTP is 1234") # message සහ type දෙකම overwrite වෙනවා
# Output: Sending sms to Amal: Your OTP is 1234
        

Positional සහ Keyword Arguments එකට පාවිච්චි කරනකොට:

ඔයාලට පුළුවන් Positional arguments සහ Keyword arguments එකට පාවිච්චි කරන්න. හැබැයි මේකේදී වැදගත් දේ තමයි, හැමවෙලාවෙම Positional arguments මුලින්ම තියෙන්න ඕනේ. Keyword arguments පස්සේ එන්න ඕනේ.

def create_user(username, email, role="user", active=True):
    print(f"Creating user: {username}, Email: {email}, Role: {role}, Active: {active}")

# හරි ක්‍රමය: positional මුලින්, keyword පස්සේ
create_user("amal_perera", "[email protected]", role="admin")
# Output: Creating user: amal_perera, Email: [email protected], Role: admin, Active: True

# වැරදි ක්‍රමය: keyword මුලින්ම දාලා positional පස්සේ දාන්න බෑ (SyntaxError)
# create_user(role="admin", "amal_perera", "[email protected]") # මේක වැරදියි
        

Clarity එකට Keyword Arguments පාවිච්චි කරන්න:

ඔයාලා function එකකට arguments ගොඩක් දෙනවා නම්, විශේෂයෙන්ම ඒ arguments මොනවද කියලා කියවන්නාට පැහැදිලි නැත්නම්, Keyword Arguments පාවිච්චි කරන එක මාරම හොඳ පුරුද්දක්. "position" එක විතරක් මතක තියාගෙන code කරන එකට වඩා, "name" එකෙන් call කරන එකෙන් code එකේ readability එක ගොඩක් වැඩි වෙනවා.

# මේක කියවන්න අමාරුයි මොනවද මේ 100, 50, 0.5 කියලා
# calculate_discount(100, 50, 0.5, True)

# මේකෙන් වැඩේ පැහැදිලියි
def calculate_discount(original_price, discount_amount, tax_rate, is_member):
    # Calculation logic here
    pass

calculate_discount(original_price=100, discount_amount=50, tax_rate=0.5, is_member=True)
        

ඉතින්, ඔයාලා මොකද හිතන්නේ?

Functions කියන්නේ Software Engineering වල backbone එකක් වගේ දෙයක්. ඒක ඇතුලේ Arguments කියන්නේ අපි function එකට දෙන "fuel" එක වගේ. Positional, Keyword, Default කියන arguments වර්ග තුනම තේරුම් ගන්න එක ඔයාලගේ code එක තව හොඳට ලියන්න, වැරදි අඩු කරන්න, ඒ වගේම අනිත් අයගේ code කියවන්නත් මාරම උදව්වක් වෙයි.

මේ ගැන ඔයාලගේ අදහස් මොනවද? ඔයාලා මේවා කොහොමද පාවිච්චි කරන්නේ? මොනවගේ ගැටලු වලටද මුහුණ දීලා තියෙන්නේ? පහලින් comment section එකේ ඔයාලගේ අදහස් අපිට කියන්න. ඒ වගේම මේ concepts ටික ඔයාලගේම code එකක try කරලා බලන්නත් අමතක කරන්න එපා. මොකද, theory විතරක් මදි, practice තමයි වැඩේට තව ශක්තියක් වෙන්නේ!

ඊළඟ ලිපියෙන් හම්බවෙමු! ඔබට ජය!