Python හි ලැම්ඩා ශ්රිතය
අපට <func යන ශ්රිතයක් ඇතැයි සිතමු,
එය පරාමිති ලෙස ලැයිස්තුවක් සහ
callback එකක් පිළිගනී. ශ්රිතය නව
ලැයිස්තුවක් සාදනු ඇත මුල් ලැයිස්තුවේ මූලද්රව්ය වලින්.
මේ අතරේ සෑම මූලද්රව්යයකටම callback එක යොදනු ලැබේ:
def func(lst, callback):
res = []
for el in lst:
res.append(callback(el))
return res
දැන් අපි <square යන ශ්රිතය සාදමු,
එය එයට ලබා දුන් අංකය
වර්ග කරයි:
def square(num):
return num ** 2
අපි <func හි පරාමිතීන්ට අංක ලැයිස්තුවක් සහ
<square ශ්රිතය callback එකක් ලෙස
ලබා දෙමු:
print( func([1, 2, 3], square) )
කොන්සෝලයේ නව ලැයිස්තුවක් ප්රදර්ශනය වනු ඇත, සමන්විත අංකවල වර්ග වලින්:
[1, 4, 9]
කෙසේ වෙතත්, මෙම කේතය සැලකිය යුතු ලෙස
කෙටි කළ හැකිය, <ලැම්ඩා-ශ්රිතය
භාවිතා කරමින්
- අනන්ය ශ්රිතයක්, එය ක්රියාත්මක කරනු ලබන්නේ
<lambda යන යතුරු වචනය භාවිතා කර සහ
එක් පේළියක ලියා ඇත. එබැවින්
ලැම්ඩා-ශ්රිතයට යළි ලිවිය හැක්කේ
කේතය එක් පේළියක් දිගට ගන්නා ශ්රිත පමණි.
ලැම්ඩා-ශ්රිතයේ වාක්ය ඛණ්ඩය මෙසේ පෙනේ:
lambda ශ්රිතයේ පරාමිතිය: ශ්රිත පරාමිතිය සමඟ මෙහෙයුම
දැන් අපි <square ශ්රිතය
ලැම්ඩා-ශ්රිතයක් භාවිතයෙන් නැවත ලියමු සහ එය
<func හි පරාමිතියට ලබා දෙමු:
print( func([1, 2, 3], lambda num: num ** 2) )
ලැම්ඩා-ශ්රිතය විචල්යයකට ලිවිය හැකිය:
square = lambda num: num ** 2
print( func([1, 2, 3], square) )
පහත කේතය ලැම්ඩා-ශ්රිතය හරහා නැවත ලියන්න:
def func(num, clb):
return clb(num)
def clb(num):
return num + 1
print( func(2, clb) )
පහත කේතය ලැම්ඩා-ශ්රිතය හරහා නැවත ලියන්න:
def func(num, clb1, clb2):
return (clb1(num), clb2(num))
def clb1(num):
return num + 1
def clb2(num):
return num - 1
print( func(2, clb1, clb2) )
පහත කේතය ලැම්ඩා-ශ්රිතය හරහා නැවත ලියන්න:
def func(num1, num2, clb):
res = clb(num1) + num2
return res
def clb(num):
return num ** 3
print(func(2, 6, clb))
