Python Lambda Functions: සරලව ඉගෙන ගනිමු! (A Simple Guide in Sinhala)

ආයුබෝවන්, ටෙක් ලෝකෙට ආදරය කරන යාළුවනේ!

අද අපි කතා කරන්න යන්නේ Python වල තියෙන මරුම feature එකක් ගැන. ඒ තමයි "Lambda Functions". නම ඇහුවම පොඩ්ඩක් සංකීර්ණ වගේ පෙනුනත්, මේවා අපේ code එක ගොඩක් ලස්සනට, කෙටියට ලියන්න උදව් වෙන නියම Tools ටිකක්. විශේෂයෙන්ම, ඔයාලා map, filter, sorted වගේ functions එක්ක වැඩ කරනවා නම්, මේ Lambda Functions කියන්නේ අත්‍යවශ්‍ය දෙයක්. එහෙනම්, අපි බලමු මේවා මොනවද, කොහොමද පාවිච්චි කරන්නේ, සහ කවදාද පාවිච්චි නොකර ඉන්න ඕනේ කියලා.

Lambda Functions කියන්නේ මොනවද?

සරලවම කිව්වොත්, Lambda Functions කියන්නේ "anonymous functions" නැත්නම් "නමක් නැති functions". සාමාන්‍යයෙන් අපි function එකක් ලියනකොට, def keyword එකෙන් පස්සේ නමක් දෙනවානේ. හැබැයි Lambda Functions වලට නමක් නෑ. මේවා ලියන්නේ එකම expression එකක් විදියට, ඒ කියන්නේ එක පේළියක. මේවා ප්‍රයෝජනවත් වෙන්නේ අපිට පුංචි වැඩකට, එක පාරක් විතරක් පාවිච්චි කරන්න අවශ්‍ය function එකක් ඕන වුණාමයි.

Syntax එක මෙහෙමයි:

lambda arguments: expression

• lambda: මේක keyword එක.
• arguments: function එකට pass කරන arguments. comma වලින් වෙන් කරලා කීයක් වුණත් දෙන්න පුළුවන්.
• expression: මේක තමයි function එකෙන් return කරන value එක. මේක එකම expression එකක් වෙන්න ඕනේ.

උදාහරණයක් විදියට, සංඛ්‍යාවක් දෙකෙන් වැඩි කරන function එකක් සාමාන්‍ය විදියට ලිව්වොත්:

def multiply_by_two(x):
    return x * 2

print(multiply_by_two(5)) # Output: 10

මේකම Lambda Function එකකින් ලිව්වොත් මෙහෙමයි:

multiply_by_two_lambda = lambda x: x * 2

print(multiply_by_two_lambda(5)) # Output: 10

දැක්කානේ, කොච්චර කෙටියෙන් ලියන්න පුළුවන්ද කියලා? මේක තමයි Lambda Functions වල මූලිකම සංකල්පය.

Lambda Functions කවදාද පාවිච්චි කරන්නේ?

Lambda Functions වලට නමක් නැති නිසා, මේවා "higher-order functions" එක්ක පාවිච්චි කරන එක තමයි වැඩියෙන්ම සිද්ධ වෙන්නේ. Higher-order functions කියන්නේ function එකක් argument එකක් විදියට ගන්න, නැත්නම් function එකක් return කරන functions. Python වල map, filter, sorted වගේ built-in functions මේ ගණයට අයත් වෙනවා. අපි ඒවා එකින් එක බලමු.

1. map() සමඟ Lambda Functions

map() function එක පාවිච්චි කරන්නේ list එකක, tuple එකක වගේ iterable එකක තියෙන හැම item එකකටම යම්කිසි function එකක් apply කරලා අලුත් iterable එකක් හදන්න. Lambda function එකක් මෙතනට නියමෙටම ගැලපෙනවා.

උදාහරණයක් විදියට, සංඛ්‍යා ලැයිස්තුවක හැම සංඛ්‍යාවක්ම වර්ග කරන්න (square කරන්න) අවශ්‍ය නම්:

numbers = [1, 2, 3, 4, 5]

# සාමාන්‍ය function එකක් එක්ක
def square(num):
    return num * num
squared_numbers_def = list(map(square, numbers))
print(f"සාමාන්‍ය function එකක් එක්ක: {squared_numbers_def}") # Output: සාමාන්‍ය function එකක් එක්ක: [1, 4, 9, 16, 25]

# Lambda function එකක් එක්ක
squared_numbers_lambda = list(map(lambda num: num * num, numbers))
print(f"Lambda function එකක් එක්ක: {squared_numbers_lambda}") # Output: Lambda function එකක් එක්ක: [1, 4, 9, 16, 25]

දැන් බලන්න, square කියන function එක වෙනම define නොකර, map එක ඇතුලෙම අපිට වැඩේ කරගන්න පුළුවන් වුණා. Code එක කොච්චර ලස්සනද, කෙටියද?

2. filter() සමඟ Lambda Functions

filter() function එක පාවිච්චි කරන්නේ iterable එකකින් යම්කිසි condition එකක් meet කරන item ටික තෝරගන්න. මෙතනටත් Lambda function එකක් හරියටම ගැලපෙනවා. Lambda function එකෙන් True නැත්නම් False කියන boolean value එකක් return කරන්න ඕනේ.

උදාහරණයක් විදියට, සංඛ්‍යා ලැයිස්තුවකින් ඉරට්ටේ සංඛ්‍යා (even numbers) විතරක් තෝරගන්න අවශ්‍ය නම්:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# සාමාන්‍ය function එකක් එක්ක
def is_even(num):
    return num % 2 == 0
even_numbers_def = list(filter(is_even, numbers))
print(f"සාමාන්‍ය function එකක් එක්ක: {even_numbers_def}") # Output: සාමාන්‍ය function එකක් එක්ක: [2, 4, 6, 8, 10]

# Lambda function එකක් එක්ක
even_numbers_lambda = list(filter(lambda num: num % 2 == 0, numbers))
print(f"Lambda function එකක් එක්ක: {even_numbers_lambda}") # Output: Lambda function එකක් එක්ක: [2, 4, 6, 8, 10]

මෙහිදීත්, is_even function එක වෙනම define කිරීමේ අවශ්‍යතාවයක් නෑ.

3. sorted() සමඟ Lambda Functions

sorted() function එක පාවිච්චි කරන්නේ iterable එකක තියෙන item ටික sort කරන්න. මේකේ තියෙන key argument එකට Lambda function එකක් දෙන්න පුළුවන්. ඒකෙන් පුළුවන් custom sorting logic එකක් apply කරන්න.

උදාහරණයක් විදියට, ශිෂ්‍යයන්ගේ නම් සහ ලකුණු (marks) තියෙන dictionaries ලැයිස්තුවක්, ලකුණු අනුව sort කරන්න අවශ්‍ය නම්:

students = [
    {'name': 'කමල්', 'marks': 85},
    {'name': 'අමල්', 'marks': 92},
    {'name': 'සුනිල්', 'marks': 78},
    {'name': 'නිරෝෂා', 'marks': 90}
]

# සාමාන්‍ය function එකක් එක්ක
def get_marks(student):
    return student['marks']
sorted_students_def = sorted(students, key=get_marks)
print("සාමාන්‍ය function එකක් එක්ක:")
for student in sorted_students_def:
    print(student)
# Output:
# සාමාන්‍ය function එකක් එක්ක:
# {'name': 'සුනිල්', 'marks': 78}
# {'name': 'කමල්', 'marks': 85}
# {'name': 'නිරෝෂා', 'marks': 90}
# {'name': 'අමල්', 'marks': 92}


# Lambda function එකක් එක්ක
sorted_students_lambda = sorted(students, key=lambda student: student['marks'])
print("\nLambda function එකක් එක්ක:")
for student in sorted_students_lambda:
    print(student)
# Output:
# Lambda function එකක් එක්ක:
# {'name': 'සුනිල්', 'marks': 78}
# {'name': 'කමල්', 'marks': 85}
# {'name': 'නිරෝෂා', 'marks': 90}
# {'name': 'අමල්', 'marks': 92}

මේ වගේ තැන් වලදී Lambda function එකක් පාවිච්චි කරන එක code එකට හොඳ clarity එකක් දෙනවා. මොකද sorting logic එක sorted() function එක ළඟම තියෙන නිසා.

Lambda Functions වල සීමාවන් සහ අවදානම්

Lambda Functions කියන්නේ නියම tool එකක් වුණාට, හැම වෙලාවෙම මේවා පාවිච්චි කරන්න බෑ. මේවට තියෙනවා සීමාවන් ටිකක්. ඒ වගේම, සමහර වෙලාවට මේවා පාවිච්චි කරන එක හොඳට වඩා නරක වෙන්නත් පුළුවන්.

1. තියෙන්නේ එකම Expression එකක් විතරයි!

Lambda function එකක් ලිවිය හැක්කේ එකම expression එකක් විදියට විතරයි. මේක තමයි ලොකුම සීමාව. ඒ කියන්නේ, if/else statements, for loops වගේ complex logic මේ ඇතුලේ ලියන්න බෑ. ඔයාට statements කිහිපයක් execute කරන්න ඕන නම්, def keyword එකෙන් define කරන සාමාන්‍ය function එකක් තමයි පාවිච්චි කරන්න වෙන්නේ.

# මේ වගේ දෙයක් කරන්න බෑ:
# lambda x: if x > 0: return x * 2 else: return x / 2  # Syntax Error!

# මේ වගේ ternary operator එකක් පාවිච්චි කරන්න පුළුවන්, හැබැයි ඒකත් expression එකක් විතරයි
# lambda x: x * 2 if x > 0 else x / 2

2. Overuse of Lambdas for Complex Logic (Lambda Functions වැඩියෙන් පාවිච්චි කිරීම)

සමහර අය code එක කෙටි කරන්න කියලා, එකිනෙකට nested වෙච්ච complex Lambda functions ලියනවා. මේකෙන් code එක කියවන්න (readability) අමාරු වෙනවා. Code එක කෙටි වුණාට වැඩක් නෑනේ තේරුම් ගන්න බැරිනම්?

උදාහරණයක් විදියට, අර student sort කරන එකේම, names සහ marks දෙකම බලලා sort කරන්න ඕනේ නම්:

students = [
    {'name': 'කමල්', 'marks': 85},
    {'name': 'අමල්', 'marks': 92},
    {'name': 'සුනිල්', 'marks': 78},
    {'name': 'නිරෝෂා', 'marks': 90},
    {'name': 'අමල්', 'marks': 80} # අලුතින් එකතු කළා
]

# මේ වගේ complex lambda එකක් readable නැහැ
# sorted_students_complex_lambda = sorted(students, key=lambda s: (s['marks'], s['name']))
# print(sorted_students_complex_lambda)

# මේක වෙනම function එකකින් ලිව්වොත් කොච්චර පැහැදිලිද?
def custom_sort_key(student):
    return (student['marks'], student['name']) # Marks අනුව, පසුව name අනුව

sorted_students_def_clear = sorted(students, key=custom_sort_key)
print("\nClearer way with def function:")
for student in sorted_students_def_clear:
    print(student)

දැන් බලන්න, custom_sort_key කියන function එකෙන් sorting logic එක පැහැදිලිව පේනවා. Lambda එකකින් මේක කරන්න ගියොත් code එක අවුල් වෙන්න පුළුවන්. ඒ නිසා, code එක කෙටි වුණාට වඩා, කියවන්න ලේසි (readable) වෙන එක ගැන සැලකිලිමත් වෙන්න ඕනේ.

හොඳම භාවිතාවන් (Best Practices)

Lambda Functions කාටත් ප්‍රයෝජනවත් වෙන tools. හැබැයි මේවා පාවිච්චි කරනකොට මේ කරුණු ටික මතක තියාගන්න:

1. සරලව තියාගන්න (Keep it Simple): Lambda Functions පාවිච්චි කරන්න ඕනේ සරල, එක expression එකක ලියන්න පුළුවන් functions වලට විතරයි.
2. එක් වරක් භාවිතය (Use for Single-Use, Throwaway Functions): වෙනම නමක් දීලා function එකක් define කරන්න තරම් සංකීර්ණ නැති, නැත්නම් එක පාරක් විතරක් පාවිච්චි කරන functions වලට මේවා නියමෙට ගැලපෙනවා.
3. කියවීමේ පහසුව (Prioritize Readability): ඔයාගේ code එක කියවන අයට තේරුම් ගන්න පුළුවන් විදියට තියෙන එක තමයි වැදගත්ම දේ. Lambda function එකක් නිසා code එක අවුල් වෙනවා නම්, අනිවාර්යයෙන්ම def function එකක් පාවිච්චි කරන්න.
4. Docstrings නැහැ (No Docstrings): Lambda Functions වලට Docstrings දාන්න බෑ. ඒ නිසා function එකේ purpose එක පැහැදිලි නැතිනම්, def function එකක් පාවිච්චි කරන එක හොඳයි.

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

ඉතින් යාළුවනේ, මේ අපි කතා කළේ Python වල Lambda Functions ගැනයි. මේවා Anonymous functions විදියට, විශේෂයෙන්ම map(), filter(), sorted() වගේ higher-order functions එක්ක පාවිච්චි කරනකොට අපේ code එක ගොඩක් clean සහ concise කරන්න උදව් වෙනවා. ඒ වගේම, මේවාට තියෙන සීමාවන් සහ හොඳම භාවිතාවන් ගැනත් අපි බැලුවා. හැම වෙලාවෙම මතක තියාගන්න, code එකේ readability එක තමයි වැදගත්ම දේ.

දැන් ඔයාලත් මේ concepts ටික ඔයාලගේම code එකේ try කරලා බලන්න. මොකද theory විතරක් මදි, practice කරන්නම ඕනේ. මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහලින් comment කරන්න. අපි ලබන සතියේ තවත් මේ වගේම වැදගත් මාතෘකාවකින් හම්බවෙමු! ටෙක් ලෝකේ දියුණු වෙන්න, දැනුම බෙදාගන්න අපි හැමෝටම පුළුවන්!