පයිතන් ලැම්බඩාස් ප්‍රයෝජනවත් වන්නේ ඇයි? [වසා ඇත]

මම උත්සාහ කරන්නේ පයිතන් ලැම්බඩස්. ලැම්බඩා සැබෑ ජීවිතයේ අමතක කළ යුතු “රසවත්” භාෂා අයිතම වලින් එකක් ද?

එය අවශ්‍ය විය හැකි අවස්ථා කිහිපයක් ඇති බව මට විශ්වාසයි, නමුත් එහි අපැහැදිලි බව සැලකිල්ලට ගෙන, අනාගත නිකුතුවලදී එය නැවත අර්ථ දැක්වීමේ විභවය (එහි විවිධ අර්ථකථන මත පදනම් වූ මගේ උපකල්පනය) සහ අඩු කළ කේතීකරණ පැහැදිලිකම - එසේ නම් වළක්වා ගත යුතුද?

මෙය මට මතක් කර දෙන්නේ සී වර්ගවල පිටාර ගැලීම (ස්වාරක්ෂක පිටාර ගැලීම) - ඉහළ විචල්‍යයට යොමු කිරීම සහ අනෙක් ක්ෂේත්‍ර අගයන් සැකසීම සඳහා අධික ලෙස පැටවීම. එය තාක්‍ෂණික සංදර්ශනයක් ලෙස පෙනේ, නමුත් නඩත්තු කෝඩර් බියකරු සිහිනයකි.

ඔබ කතා කරන්නේ ලැම්බඩා කාර්යයන් ගැනද? මෙන්

lambda x: x**2 + 2*x - 5

එම දේවල් ඇත්තෙන්ම බෙහෙවින් ප්‍රයෝජනවත් ය. පයිතන් ක්‍රියාකාරී ක්‍රමලේඛනය නමින් ක්‍රමලේඛන ශෛලියක් සඳහා සහාය වන අතර එහිදී ඔබට වෙනත් කාර්යයන් වෙත කාර්යයන් යැවිය හැකිය. උදාහරණයක්:

mult3 = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])

කට්ටල mult3කිරීමට [3, 6, 9], 3. මෙම ගුණාකාර බව මුල් ලැයිස්තුව හස්බන්ඩ් කෙටි (සහ, කෙනෙකුට තර්ක කළ හැකිය පැහැදිලි) වඩා

def filterfunc(x):
    return x % 3 == 0
mult3 = filter(filterfunc, [1, 2, 3, 4, 5, 6, 7, 8, 9])

ඇත්ත වශයෙන්ම, මෙම විශේෂිත අවස්ථාවෙහිදී, ඔබට ලැයිස්තු අවබෝධයක් ලෙස එකම දේ කළ හැකිය:

mult3 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x % 3 == 0]

(හෝ එසේ වුවද range(3,10,3)), නමුත් ඔබට ලැයිස්තු අවබෝධය භාවිතා කළ නොහැකි තවත් බොහෝ නවීන භාවිත අවස්ථා ඇති අතර ලැම්බඩා ශ්‍රිතය යමක් ලිවීමට ඇති කෙටිම ක්‍රමය විය හැකිය.

• වෙනත් ශ්‍රිතයකින් ශ්‍රිතයක් නැවත ලබා දීම

  >>> def transform(n):
  ...     return lambda x: x + n
  ...
  >>> f = transform(3)
  >>> f(4)
  7

  මෙය බොහෝ විට භාවිතා කරනුයේ පයිතන්ගේ සැරසිලි කරුවන් වැනි ක්‍රියාකාරී ආවරණ නිර්මාණය කිරීමට ය.

• සමඟ අනුක්‍රමික අනුක්‍රමයක මූලද්‍රව්‍ය ඒකාබද්ධ කිරීම reduce()

  >>> reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])
  '1, 2, 3, 4, 5, 6, 7, 8, 9'

• විකල්ප යතුරකින් වර්ග කිරීම

  >>> sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))
  [5, 4, 6, 3, 7, 2, 8, 1, 9]

මම නිතිපතා ලැම්බඩා කාර්යයන් භාවිතා කරමි. ඔවුන් සමඟ හුරු වීමට මට යම් කාලයක් ගත වූ නමුත් අවසානයේදී ඔවුන් භාෂාවේ ඉතා වටිනා කොටසක් බව මට වැටහුණි.

lambdaකියන්න විකාර ක්‍රමයක් function. එහි නම හැරුණු විට ඒ පිළිබඳව අපැහැදිලි, බිය ගැන්වීම් හෝ ගුප්ත කිසිවක් නොමැත. ඔබ පහත දැක්වෙන රේඛාව කියවන විට, වෙනුවට lambdaවිසින් functionඔබේ මනස තුළ:

>>> f = lambda x: x + 1
>>> f(3)
4

එය හුදෙක් ශ්‍රිතයක් අර්ථ දක්වයි x. තවත් සමහර භාෂා Rඑය පැහැදිලිව කියනවා:

> f = function(x) { x + 1 }
> f(3)
4

ඔයා බලන්න? එය ක්‍රමලේඛනයේදී කළ යුතු ස්වාභාවික දේවලින් එකකි.

පේළි දෙකේ සාරාංශය:

1. වසා දැමීම් : ඉතා ප්‍රයෝජනවත්. ඒවා ඉගෙන ගන්න, ඒවා භාවිතා කරන්න, ඔවුන්ට ආදරය කරන්න.
2. පයිතන්ගේ ප්‍රධාන lambdaපදය: අනවශ්‍ය, ඉඳහිට ප්‍රයෝජනවත්. ඔබ එය දුරස්ථව සංකීර්ණ දෙයක් කරන බව පෙනේ නම්, එය පසෙකට දමා සැබෑ ශ්‍රිතයක් අර්ථ දක්වන්න.

ලැම්බඩා යනු ඉහළ ඇණවුම් කාර්යයන් සමඟ කටයුතු කරන ඉතා වැදගත් වියුක්ත යාන්ත්‍රණයක කොටසකි. එහි වටිනාකම පිළිබඳ නිසි අවබෝධයක් ලබා ගැනීමට කරුණාකර ඇබෙල්සන් සහ සුස්මාන්ගෙන් උසස් තත්ත්වයේ පාඩම් බලන්න , සහ පොතක් කියවන්න SICP

මේවා නවීන මෘදුකාංග ව්‍යාපාරයේ අදාළ ගැටළු වන අතර වඩ වඩාත් ජනප්‍රිය වෙමින් පවතී.

මට සැකයි ලැම්බඩා නැති වෙයි කියලා. එය ඉවත් කිරීමට උත්සාහ කිරීම අත්හැරීම ගැන ගයිඩෝගේ ලිපිය බලන්න . ගැටුමේ දළ සටහනක් ද බලන්න .

පයිතන්ගේ ක්‍රියාකාරී අංග පිටුපස ඇති ගනුදෙනුව පිළිබඳ වැඩි විස්තර සඳහා ඔබට මෙම ලිපිය බලන්න: http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

කුතුහලය දනවන කරුණ නම්, ලැම්බඩා සහ අනෙකුත් ක්‍රියාකාරී අංග හඳුන්වාදීමට මුලින් පෙළඹවූ සිතියම, පෙරණය සහ අඩු කිරීමේ කාර්යයන් බොහෝ දුරට ලැයිස්තු අවබෝධය සහ උත්පාදක ප්‍රකාශන මගින් අභිබවා ගොස් ඇත. ඇත්ත වශයෙන්ම, අඩු කිරීමේ කාර්යය පයිතන් 3.0 හි ඇති බිල්ඩින් ශ්‍රිත ලැයිස්තුවෙන් ඉවත් කරන ලදි. (කෙසේ වෙතත්, ලැම්බඩා, සිතියම හෝ පෙරණය ඉවත් කිරීම පිළිබඳ පැමිණිලි යැවීම අවශ්‍ය නොවේ: ඒවා රැඳී තිබේ. :-)

මගේම ශත දෙක: පැහැදිලිකම යන තාක් දුරට ලැම්බඩා වටිනවා. සාමාන්‍යයෙන් ලැම්බඩා ඇතුළත් නොවන වඩාත් පැහැදිලි විසඳුමක් තිබේ.

GUI වැඩසටහන්කරණයේදී ලැම්බඩාස් අතිශයින් ප්‍රයෝජනවත් වේ. නිදසුනක් ලෙස, ඔබ බොත්තම් සමූහයක් නිර්මාණය කරන බවත්, බොත්තමකට අද්විතීය ඇමතුමක් ලබා ගැනීමට වඩා තනි පරාමිතිගත ඇමතුමක් භාවිතා කිරීමට ඔබට අවශ්‍ය බවත් කියමු. එය පහසුවෙන් ඉටු කර ගැනීමට ලැම්බඩා ඔබට ඉඩ දෙයි:

for value in ["one","two","three"]:
    b = tk.Button(label=value, command=lambda arg=value: my_callback(arg))
    b.pack()

(සටහන: මෙම ප්‍රශ්නය විශේෂයෙන් විමසනු ලැබුවද lambda, ඔබට එකම ආකාරයේ ප්‍රති result ල ලබා ගැනීම සඳහා functools.partial භාවිතා කළ හැකිය )

විකල්පය වන්නේ අනුපිටපත් කේත වලට තුඩු දිය හැකි එක් එක් බොත්තම සඳහා වෙනම ඇමතුමක් ලබා දීමයි.

පයිතන් හි, lambdaපේළිගත කිරීමේ කාර්යයන් නිර්වචනය කිරීමේ ක්‍රමයක් පමණි,

a = lambda x: x + 1
print a(1)

සහ..

def a(x): return x + 1
print a(1)

මෙම ..are නිශ්චිත එකම.

නිත්‍ය ශ්‍රිතයක් සමඟ ඔබට කළ නොහැකි ලැම්බඩා සමඟ ඔබට කළ හැකි කිසිවක් නැත - පයිතන් ශ්‍රිත යනු අන් සියල්ලටම සමාන වස්තුවක් වන අතර ලැම්බඩාස් හුදෙක් ශ්‍රිතයක් අර්ථ දක්වයි:

>>> a = lambda x: x + 1
>>> type(a)
<type 'function'>

මම අවංකවම හිතනවා lambda පයිතන්හි මූලික පදය අතිරික්තයක් ඇති බවය them මට ඒවා භාවිතා කිරීමේ අවශ්‍යතාවය කිසි විටෙකත් නොතිබුණි (හෝ නිත්‍ය ශ්‍රිතයක්, ලැයිස්තු අවබෝධයක් හෝ බොහෝ බිල්ඩින් ශ්‍රිතයන්ගෙන් එකක් වෙනුවට වඩා හොඳින් භාවිතා කළ හැකි තැනක් භාවිතා කර ඇති බව දැක ඇත)

සම්පූර්ණයෙන්ම අහඹු උදාහරණයක් සඳහා, "පයිතන්ගේ ලැම්බඩා කැඩී ඇත!" :

ලැම්බඩා කැඩී ඇති ආකාරය බැලීමට, fs=[f0,...,f9]කොතැනක ශ්‍රිත ලැයිස්තුවක් ජනනය කිරීමට උත්සාහ කරන්න fi(n)=i+n. පළමු උත්සාහය:

>>> fs = [(lambda n: i + n) for i in range(10)]
>>> fs[3](4)
13

මම තර්ක කරමි, එය ක්‍රියාත්මක වුවද, එය බිහිසුණු හා “අවිධිමත්” ය, එකම ක්‍රියාකාරීත්වය වෙනත් ආකාරවලින් ලිවිය හැකිය, උදාහරණයක් ලෙස:

>>> n = 4
>>> [i + n for i in range(10)]
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

ඔව්, එය එසේ නොවේ, නමුත් ලැයිස්තුවක් තුළ ලැම්බඩා ශ්‍රිත සමූහයක් උත්පාදනය කිරීම අවශ්‍ය වන හේතුවක් මා දැක නැත . එය වෙනත් භාෂාවලින් අර්ථවත් විය හැකි නමුත් පයිතන් හස්කල් නොවේ (හෝ ලිස්ප්, හෝ ...)

අපට ලැම්බඩා භාවිතා කළ හැකි අතර අපේක්ෂිත ප්‍රති results ල මේ ආකාරයෙන් ලබා ගත හැකි බව කරුණාවෙන් සලකන්න:

>>> fs = [(lambda n,i=i: i + n) for i in range(10)]
>>> fs[3](4)
7

සංස්කරණය කරන්න:

ලැම්බඩා ප්‍රයෝජනවත් වන අවස්ථා කිහිපයක් තිබේ, උදාහරණයක් ලෙස PyQt යෙදුම්වල සං als ා සම්බන්ධ කිරීමේදී බොහෝ විට එය පහසු ය:

w = PyQt4.QtGui.QLineEdit()
w.textChanged.connect(lambda event: dothing())

යන්තම් කරන්නේ w.textChanged.connect(dothing)ද ගැටලුවක් වනු ඇත dothingඅතිරේක සමඟ ක්රමය eventතර්කය හා දෝෂයක් ඇති විය. ලැම්බඩා භාවිතා කිරීම යනු එතීමේ ශ්‍රිතයක් නිර්වචනය නොකර අපට තර්කය පිළිවෙලින් අතහැර දැමිය හැකිය.

එකම, නමුත් විවිධ තත්වයන් සඳහා කරන කාර්යයන් ලැයිස්තුවක් සඳහා ලැම්බඩා ප්‍රයෝජනවත් බව මට පෙනේ.

මොසිල්ලා බහුවිධ නීති මෙන් :

plural_rules = [
    lambda n: 'all',
    lambda n: 'singular' if n == 1 else 'plural',
    lambda n: 'singular' if 0 <= n <= 1 else 'plural',
    ...
]
# Call plural rule #1 with argument 4 to find out which sentence form to use.
plural_rule[1](4) # returns 'plural'

ඔබට ඒ සියල්ල සඳහා ශ්‍රිතයක් නිර්වචනය කිරීමට සිදුවුවහොත් එය අවසන් වන විට ඔබට පිස්සු වැටෙනු ඇත.
එසේම, ඒ වගේ කාර්යය නම් සමග ලස්සන වන්නේ නැහැ plural_rule_1, plural_rule_2ආදිය, සහ ඔබට අවශ්ය කියලා eval()ඔබ විචල්ය කාර්යය id මත පදනම්ව කරන විට එය.

ඔබට කළ හැකි ඕනෑම දෙයක් lambda නම් කරන ලද කාර්යයන් හෝ ලැයිස්තුව සහ උත්පාදක ප්‍රකාශන සමඟ වඩා හොඳින් කළ හැකිය.

එහි ප්‍රති, ලයක් වශයෙන්, බොහෝ දුරට ඔබ මූලික වශයෙන් ඕනෑම තත්වයක සිටින අයගෙන් එක් අයෙකු පමණක් විය යුතුය (අන්තර්ක්‍රියාකාරී පරිවර්තකයේ ලියා ඇති සීරීම් කේතය හැර).

මම අවුරුදු කීපයක් තිස්සේ පයිතන් භාවිතා කර ඇති අතර, මම කිසි විටෙකත් ලැම්බඩා අවශ්‍ය අවස්ථාවකට නොගියෙමි. ඇත්ත වශයෙන්ම, නිබන්ධනයේ සඳහන් වන පරිදි, එය සින්ටැක්ටික් සීනි සඳහා පමණි.

පයිතන් විසින් විශේෂයෙන් ලැම්බඩා ක්‍රියාත්මක කිරීම ගැන මට කතා කළ නොහැක, නමුත් සාමාන්‍යයෙන් ලැම්බඩා කාර්යයන් සැබවින්ම පහසුය. ඒවා ක්‍රියාකාරී ක්‍රමලේඛනයේ මූලික තාක්‍ෂණයකි (සමහර විට තාක්‍ෂණය පවා), ඒවා වස්තු-නැඹුරු වැඩසටහන් වලද ඉතා ප්‍රයෝජනවත් වේ. සමහර ආකාරයේ ගැටළු සඳහා, ඒවා හොඳම විසඳුම වන බැවින් නිසැකවම අමතක නොකළ යුතුය!

වසා දැමීම් සහ සිතියම් ක්‍රියාකාරිත්වය (පයිතන් ලියකියවිලි සමඟ සම්බන්ධ වන නමුත් එය ක්‍රියාකාරී ඉදිකිරීම් සඳහා සහය දක්වන සෑම භාෂාවකම පාහේ පවතී) එය ප්‍රයෝජනවත් වන්නේ මන්දැයි බැලීමට මම ඔබට යෝජනා කරමි .

ලැම්බඩා ශ්‍රිතය එය ශ්‍රිතයක් නිර්මාණය කිරීම සඳහා නිලධාරිවාදී නොවන ක්‍රමයකි.

ඒක තමයි. නිදසුනක් ලෙස, ඔබේ ප්‍රධාන කාර්යය සහ වර්ග අගයන් අවශ්‍ය යැයි අපි සිතමු. මෙය කිරීමට සාම්ප්‍රදායික ක්‍රමය සහ ලැම්බඩා ක්‍රමය බලමු:

සාම්ප්‍රදායික ක්‍රමය:

def main():
...
...
y = square(some_number)
...
return something

def square(x):
    return x**2

ලැම්බඩා මාර්ගය:

def main():
...
square = lambda x: x**2
y = square(some_number)
return something

වෙනස බලන්න?

ලැයිස්තු අවබෝධය හෝ සිතියම වැනි ලැයිස්තු සමඟ ලැම්බඩා කාර්යයන් ඉතා හොඳින් ගමන් කරයි. ඇත්ත වශයෙන්ම, ලැයිස්තු අවබෝධය එය ලැම්බඩා භාවිතා කරමින් ප්‍රකාශ කිරීමට “පයිතොනික්” ක්‍රමයකි. උදා:

>>>a = [1,2,3,4]
>>>[x**2 for x in a]
[1,4,9,16]

සින්ටැක්ස් හි එක් එක් අංගවල තේරුම කුමක්දැයි බලමු:

[]: "මට ලැයිස්තුවක් දෙන්න"

x ** 2: "මෙම අලුත උපන් ශ්‍රිතය භාවිතා කිරීම"

a හි x සඳහා: "a හි එක් එක් මූලද්‍රව්‍යයට"

ඒක පහසුද? මේ වගේ කාර්යයන් නිර්මාණය කිරීම. ලැම්බඩා භාවිතයෙන් එය නැවත ලියමු:

>>> square = lambda x: x**2
>>> [square(s) for x in a]
[1,4,9,16]

දැන් අපි සිතියම භාවිතා කරමු, එය එකම දෙයයි, නමුත් වඩා භාෂා-මධ්‍යස්ථයි. සිතියම් තර්ක 2 ක් ගනී:

(i) එක් ශ්‍රිතයක්

(ii) නැවත කළ හැකි

තවද, එක් එක් මූලද්‍රව්‍යයේ ක්‍රියාකාරීත්වයේ එක් එක් මූලද්‍රව්‍යයට අදාළ වන ශ්‍රිත ලැයිස්තුවක් ඔබට ලබා දෙයි.

එබැවින්, සිතියම භාවිතා කිරීමෙන් අපට ඇත්තේ:

>>> a = [1,2,3,4]
>>> squared_list = map(lambda x: x**2, a)

ඔබ ලැම්බඩාස් සහ සිතියම්කරණය ප්‍රගුණ කළහොත්, දත්ත හැසිරවීමට සහ සංක්ෂිප්ත ආකාරයකින් ඔබට විශාල බලයක් ලැබෙනු ඇත. ලැම්බඩා කාර්යයන් අපැහැදිලි හෝ කේත පැහැදිලිකම ඉවත් නොකරයි. අමාරු දෙයක් අලුත් දෙයක් සමඟ පටලවා නොගන්න. ඔබ ඒවා භාවිතා කිරීමට පටන් ගත් පසු, ඔබට එය ඉතා පැහැදිලිව පෙනෙනු ඇත.

ලස්සන දේවල් වලින් එකක් lambdaමගේ මතය අනුව අවතක්සේරු කර ඇති නම්, වටිනාකම අවශ්‍ය වන තෙක් සරල ආකෘති සඳහා ඇගයීමක් කල් දැමීමයි. මට පැහැදිලි කරන්න දෙන්න.

බොහෝ පුස්තකාල චර්යාවන් ක්‍රියාත්මක කරනු ලබන අතර එමඟින් ඇතැම් පරාමිතීන් ඇමතීමට ඉඩ සලසයි (ඔවුන්ගෙන් ලැම්බඩා එකකි). අදහස නම් සත්‍ය වටිනාකම ගණනය කරනු ලබන්නේ එය භාවිතා කිරීමට යන වේලාවේදී පමණි (ඒ වෙනුවට එය හැඳින්වූ විට). කාරණය නිදර්ශනය කිරීමට (උපක්‍රමශීලී) උදාහරණයක් උපකාරී වේ. දී ඇති කාලරාමුව ලොග් කිරීමට ඔබ පුරුද්දක් කර ඇතැයි සිතමු. වර්තමාන කාලය us ණ මිනිත්තු 30 භාවිතා කිරීමට ඔබට අවශ්‍යය. ඔබ එය එසේ කියනු ඇත

log_timestamp(datetime.datetime.now() - datetime.timedelta(minutes = 30))

දැන් සත්‍ය ශ්‍රිතය කැඳවනු ලබන්නේ කිසියම් සිදුවීමක් සිදු වූ විට පමණක් යැයි සිතමු. ඔබට අවශ්‍ය වන්නේ කාලරාමුව ගණනය කිරීම එම අවස්ථාවේ දී පමණි. ඔබට මෙය එසේ කළ හැකිය

log_timestamp(lambda : datetime.datetime.now() - datetime.timedelta(minutes = 30))

log_timestampමෙවැනි ඇමතුම් හැසිරවිය හැකි යැයි උපකල්පනය කිරීමෙන් , එය අවශ්‍ය වූ විට මෙය ඇගයීමට ලක් කරනු ඇති අතර ඔබට එම අවස්ථාවේ කාලරාමුව ලැබෙනු ඇත.

ඇත්ත වශයෙන්ම මෙය කිරීමට විකල්ප ක්‍රම තිබේ ( operatorඋදාහරණයක් ලෙස මොඩියුලය භාවිතා කරමින් ) නමුත් මම කාරණය ප්‍රකාශ කළෙමි.

යාවත්කාලීන කිරීම : මෙන්න තරමක් සංයුක්ත සැබෑ ලෝක උදාහරණයකි.

යාවත්කාලීන 2 : මම හිතන්නේ මෙය මාපටැඟිල්ලක් ලෙස හැඳින්වෙන දෙයට උදාහරණයක් .

ලැම්බඩස් ඇත්ත වශයෙන්ම ක්‍රියාකාරී ක්‍රමලේඛනයේ අදහස් වලින් පැන නගින ඉතා ප්‍රබල ඉදිකිරීම් වන අතර එය නුදුරු අනාගතයේ දී පයිතන්හි පහසුවෙන් සංශෝධනය කිරීම, නැවත අර්ථ දැක්වීම හෝ ඉවත් කිරීම සිදු නොවේ. කාර්යයන් ඔබට පරාමිතීන් ලෙස සම්මත කිරීමට ඉඩ සලසන බැවින් වඩා බලවත් කේත ලිවීමට ඒවා ඔබට උදව් කරයි, එබැවින් පළමු පන්තියේ පුරවැසියන් ලෙස කාර්යයන් පිළිබඳ අදහස.

ලැම්බඩාස් ව්‍යාකූල වීමට නැඹුරු වන නමුත් ස්ථිර අවබෝධයක් ලබා ගත් පසු ඔබට මේ ආකාරයට පිරිසිදු අලංකාර කේතයක් ලිවිය හැකිය:

squared = map(lambda x: x*x, [1, 2, 3, 4, 5])

ඉහත කේත රේඛාව මඟින් ලැයිස්තුවේ ඇති සංඛ්‍යා වල වර්ග ලැයිස්තුවක් ලබා දේ. ඇත්ත වශයෙන්ම, ඔබට එයද එසේ කළ හැකිය:

def square(x):
    return x*x

squared = map(square, [1, 2, 3, 4, 5])

කලින් කේතය කෙටි බව පැහැදිලිය, ඔබ සිතියම් ශ්‍රිතය (හෝ පරාමිතියක් ලෙස ශ්‍රිතයක් ගන්නා ඕනෑම සමාන ශ්‍රිතයක්) එකම ස්ථානයක භාවිතා කිරීමට අදහස් කරන්නේ නම් මෙය විශේෂයෙන් සත්‍ය වේ. මෙය කේතය වඩාත් බුද්ධිමත් හා අලංකාර කරයි.

ඩේවිඩ් සාස්ලාව්ස්කි සිය පිළිතුරෙහි සඳහන් කළ පරිදි, ලැයිස්තු අවබෝධය සැමවිටම යා යුතු මාර්ගය නොවේ, විශේෂයෙන් ඔබේ ලැයිස්තුවට කිසියම් අපැහැදිලි ගණිතමය ආකාරයකින් අගයන් ලබා ගත යුතු නම්.

වඩාත් ප්‍රායෝගික දෘෂ්ටි කෝණයකින් බලන කල, ලැම්බඩාස්හි විශාලතම වාසියක් වූයේ මෑතකදී GUI සහ සිදුවීම් මත පදනම් වූ වැඩසටහන්කරණයයි. ඔබ ටින්කර්හි ඇමතුම් ආපසු බැලීමක් කළහොත්, ඔවුන් තර්ක ලෙස සලකන්නේ ඒවා අවුලුවන සිදුවීම පමණි. උදා

def define_bindings(widget):
    widget.bind("<Button-1>", do-something-cool)

def do-something-cool(event):
    #Your code to execute on the event trigger

දැන් ඔබට සම්මත කිරීමට තර්ක කිහිපයක් තිබේ නම් කුමක් කළ යුතුද? මූසික ක්ලික් කිරීමක ඛණ්ඩාංක ගබඩා කිරීම සඳහා තර්ක 2 ක් සම්මත කිරීම තරම් සරල දෙයක්. ඔබට පහසුවෙන් මේ ආකාරයට කළ හැකිය:

def main():
    # define widgets and other imp stuff
    x, y = None, None
    widget.bind("<Button-1>", lambda event: do-something-cool(x, y))

def do-something-cool(event, x, y):
    x = event.x
    y = event.y
    #Do other cool stuff

ගෝලීය විචල්‍යයන් භාවිතයෙන් මෙය කළ හැකි යැයි දැන් ඔබට තර්ක කළ හැකිය, නමුත් මතක කළමනාකරණය සහ කාන්දු වීම ගැන කරදර වෙමින් ඔබේ හිස ගසා දැමීමට ඔබට අවශ්‍යද? විශේෂයෙන් ගෝලීය විචල්‍යය එක්තරා ස්ථානයක භාවිතා කරනු ඇත. එය දුර්වල වැඩසටහන් ශෛලියක් වනු ඇත.

කෙටියෙන් කිවහොත්, ලැම්බඩාස් නියමයි, කිසි විටෙකත් අවතක්සේරු නොකළ යුතුය. පයිතන් ලැම්බඩාස් LISP ලැම්බඩා වලට සමාන නොවේ (ඒවා වඩා බලවත්), නමුත් ඔබට ඔවුන් සමඟ ඉන්ද්‍රජාලික දේවල් රාශියක් කළ හැකිය.

ඉහත සඳහන් කළ පරිදි, පයිතන්හි ලැම්බඩා ක්‍රියාකරු නිර්නාමික ශ්‍රිතයක් නිර්වචනය කරන අතර පයිතන් ශ්‍රිතවල වසා දැමීම් වේ. වසා දැමීමේ සංකල්පය ක්‍රියාකරු ලැම්බඩා සමඟ පටලවා නොගැනීම වැදගත් වන අතර එය හුදෙක් සින්ටැක්ටික් මෙතඩෝනයකි.

මම මීට වසර කිහිපයකට පෙර පයිතන්හි ආරම්භ කරන විට, ලැයිස්තු අවබෝධය සමඟ මම සිසිල් යැයි සිතමින් ලැම්බඩාස් ගොඩක් භාවිතා කළෙමි. කෙසේ වෙතත්, මම ක්‍රියාකාරී ස්ථාන දහස් ගණනක අනුපිළිවෙල මත පයිතන් හි ලියා ඇති විශාල වෙබ් අඩවියක් ලිවීමට හා නඩත්තු කිරීමට සිදුවේ. අත්දැකීම් වලින් මම ඉගෙන ගෙන ඇත්තේ ලැම්බඩස් සමඟ මූලාකෘතිකරණය කිරීම සුදුසු විය හැකි නමුත් යතුරු පුවරු කිහිපයක් ඉතිරි කිරීම හෝ සමහර විට එසේ කිරීම හැරෙන්නට පේළිගත කිරීමේ කාර්යයන් (වසා දැමීම් ලෙස නම් කර ඇති) කිසිවක් ඉදිරිපත් නොකරයි.

මූලික වශයෙන් මෙය කරුණු කිහිපයක් දක්වා උනු වේ:

• අර්ථවත් නම් භාවිතයෙන් පැහැදිලිව ලියා ඇති මෘදුකාංග කියවීම පහසුය. නිර්වචනය අනුව නිර්නාමික වසා දැමීම් වලට නමක් නොමැති බැවින් අර්ථවත් නමක් තිබිය නොහැක. මෙම සංක්ෂිප්තය යම් හේතුවක් නිසා ලැම්බඩා පරාමිතීන් ආසාදනය වන බව පෙනේ, එබැවින් අපි බොහෝ විට ලැම්බඩා x: x + 1 වැනි උදාහරණ දකිමු
• නමක් ඇති විට ඒවා කිහිප වතාවක්ම හැඳින්විය හැකි බැවින් නම් කරන ලද වසා දැමීම් නැවත භාවිතා කිරීම පහසුය.
• ලැම්බඩාස් වෙනුවට නම් කරන ලද වසා දැමීම් භාවිතා කරන කේතය නිදොස්කරණය කිරීම පහසුය, මන්දයත් නම ලුහු ce ු සටහන් වල සහ දෝෂය වටා දිස්වන බැවිනි.

ඒවා වට කර නම් කරන ලද වසා දැමීම් බවට පරිවර්තනය කිරීමට එය ප්‍රමාණවත් හේතුවකි. කෙසේ වෙතත්, මම නිර්නාමික වසා දැමීම් වලට එරෙහිව තවත් අමනාප දෙකක් දරමි.

පළමු අමනාපය වන්නේ ඒවා භාෂාව අවුල් කරන තවත් අනවශ්‍ය මූල පදයක් වීමයි.

දෙවන අමනාපය ගැඹුරු වන අතර පරමාදර්ශී මට්ටමින්, එනම් ඔවුන් ක්‍රියාකාරී-ක්‍රමලේඛන ශෛලියක් ප්‍රවර්ධනය කිරීමට මා කැමති නැත, මන්ද එම ශෛලිය පණිවුඩය යැවීම, වස්තු දිශානත හෝ ක්‍රියා පටිපාටි රටාවන්ට වඩා නම්‍යශීලී වන නිසා ලැම්බඩා කැල්කියුලස් ටියුරින් නොවන බැවිනි. සම්පුර්ණයි (වාසනාවකට මෙන් පයිතන්හි, අපට තවමත් ලැම්බඩා ඇතුළත පවා එම සීමාවෙන් ඉවත් විය හැකිය). ලැම්බඩාස් මෙම විලාසිතාව ප්‍රවර්ධනය කිරීමට මට හැඟෙන හේතු:

• ව්‍යංග ප්‍රතිලාභයක් ඇත, එනම් ඒවා ක්‍රියාකාරී විය යුතු යැයි පෙනේ.

• ඒවා වෙනත්, වඩාත් පැහැදිලි, වඩා කියවිය හැකි, නැවත භාවිතා කළ හැකි සහ වඩාත් පොදු යාන්ත්‍රණයකට විකල්ප රාජ්‍ය සැඟවීමේ යාන්ත්‍රණයකි: ක්‍රම.

ලැම්බඩා රහිත පයිතන් ලිවීමට මම දැඩි උත්සාහයක් දරමි. මම හිතන්නේ පයිතන් ලැම්බඩාස් නොමැතිව තරමක් හොඳ භාෂාවක් වනු ඇත, නමුත් එය මගේ මතය පමණි.

ලැම්බඩාස් සාමාන්‍යයෙන් ක්‍රියාකාරී ක්‍රමලේඛන ශෛලියට ගැඹුරින් බැඳී ඇත. සමහර දත්ත වලට ශ්‍රිතයක් යෙදීමෙන් සහ ප්‍රති results ල ඒකාබද්ධ කිරීමෙන් ඔබට ගැටලු විසඳා ගත හැකිය යන අදහස ගූගල් එහි ඇල්ගොරිතම බොහොමයක් ක්‍රියාත්මක කිරීමට භාවිතා කරයි.

ක්‍රියාකාරී ක්‍රමලේඛන ශෛලියේ ලියා ඇති වැඩසටහන් පහසුවෙන් සමාන්තරගත වන අතර එබැවින් නවීන බහු-මූලික යන්ත්‍ර සමඟ වඩ වඩාත් වැදගත් වේ. එබැවින් කෙටියෙන් කිවහොත්, ඔබ ඒවා අමතක නොකළ යුතුය.

ලැම්බඩා හඳුනා ගැනීමට සමත් වූ පළමු සුබ පැතුම්. මගේ මතය අනුව මෙය සැබවින්ම බලගතු ඉදිකිරීමකි. ක්‍රියාකාරී ක්‍රමලේඛන භාෂාවන් කෙරෙහි මේ දිනවල ඇති ප්‍රවණතාවය නිසැකවම එය වළක්වා නොගත යුතු බවට හෝ නුදුරු අනාගතයේ දී එය නැවත අර්ථ දැක්විය නොහැකි බවට දර්ශකයකි.

ඔබ ටිකක් වෙනස් ලෙස සිතිය යුතුය. මට විශ්වාසයි ඉක්මනින් ඔබ එයට ආදරය කරනු ඇත. නමුත් ඔබ පයිතන් සමඟ පමණක් ගනුදෙනු කරන්නේ නම් ප්‍රවේශම් වන්න. ලැම්බඩා සැබෑ වසා දැමීමක් නොවන නිසා එය කෙසේ හෝ "කැඩී" ඇත: පයිතන් ලැම්බඩා කැඩී ඇත

මම දැන් පයිතන් ආරම්භ කර මුලින්ම ලැම්බඩා වෙතට දිව ගියෙමි.

මෙය කිසිවක් හෙළා දැකීමක් නොවන බව සලකන්න. සෑම කෙනෙකුටම වෙනස් නොවන දේවල් සමූහයක් ඇත.

ලැම්බඩා සැබෑ ජීවිතයේ අමතක කළ යුතු 'රසවත්' භාෂා අයිතම වලින් එකක් ද?

නැත.

මට විශ්වාසයි එය අවශ්‍ය විය හැකි අවස්ථා කිහිපයක් ඇති නමුත් එහි අපැහැදිලි බව සැලකිල්ලට ගෙන,

එය අපැහැදිලි නොවේ. මම වැඩ කළ පසුගිය කණ්ඩායම් දෙක, සෑම කෙනෙක්ම සෑම විටම මෙම අංගය භාවිතා කළහ.

අනාගත නිකුතුවලදී එය නැවත අර්ථ දැක්වීමේ විභවය (එහි විවිධ අර්ථකථන මත පදනම් වූ මගේ උපකල්පනය)

මීට වසර කිහිපයකට පෙර වසා දැමීමේ අර්ථ නිරූපණය නිවැරදි කිරීමට වඩා එය පයිතන් හි නැවත අර්ථ දැක්වීම සඳහා බරපතල යෝජනා කිසිවක් මා දැක නැත.

සහ අඩු කරන ලද කේතීකරණ පැහැදිලිකම - එය වළක්වා ගත යුතුද?

ඔබ එය නිවැරදිව භාවිතා කරන්නේ නම් එය එතරම් පැහැදිලි නැත. ඊට පටහැනිව, වැඩි භාෂා ප්‍රමාණයක් තිබීම වැඩි වේ ව්‍යුහයක් තිබීම පැහැදිලි බව කරයි.

මෙය මට මතක් කර දෙන්නේ සී වර්ගවල පිටාර ගැලීම (ස්වාරක්ෂක පිටාර ගැලීම) - ඉහළ විචල්‍යයට යොමු කිරීම සහ අනෙක් ක්ෂේත්‍ර අගයන් සැකසීම සඳහා අධික ලෙස පැටවීම ... තාක්‍ෂණික ප්‍රදර්ශනයක් හෝ නඩත්තු කෝඩර් බියකරු සිහිනයක් ..

ලැම්බඩා බෆරය පිටාර ගැලීමකට සමානද? වොව්. ඔබ "නඩත්තු බියකරු සිහිනයක්" යැයි සිතන්නේ නම් ඔබ ලැම්බඩා භාවිතා කරන්නේ කෙසේදැයි මට සිතාගත නොහැකිය.

කේත අනුපිටපත් කිරීමෙන් වැළකීමට මම ලැම්බඩාස් භාවිතා කරමි. එමඟින් ශ්‍රිතය පහසුවෙන් තේරුම්ගත හැකි වනු ඇත උදා:

def a_func()
  ...
  if some_conditon:
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)
  else
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)

මම එය තාවකාලික ලැම්බඩා සමඟ ආදේශ කරමි

def a_func()
  ...
  call_big_f = lambda args_that_change: call_some_big_func(arg1, arg2, arg3, args_that_change)
  if some_conditon:
     ...
     call_big_f(argX)
  else
     ...
     call_big_f(argY)

මම අද ඩේවිඩ් මර්ට්ස්ගේ පොත කියවීමට පටන් ගත්තේ 'පයිතන්හි පෙළ සැකසීම' යනුවෙනි. පළමු පරිච්ඡේදයේ උපග්‍රන්ථයේ A හි පැහැදිලි කිරීම් සමඟ ලැම්බඩාගේ උදාහරණ පිළිබඳව ඔහු තරමක් තදින් විස්තර කර ඇති අතර, ඔවුන් මා වෙනුවෙන් පිටුවෙන් පැනීමට (අවසානයේ) හේතු වූ අතර හදිසියේම ඒවායේ වටිනාකම මට වැටහුණි. ඔහුගේ පැහැදිලි කිරීම ඔබ වෙනුවෙන් වැඩ කරනු ඇති බවක් නොකියන අතර මම තවමත් සොයාගැනීමේ අවධියේ සිටිමි, එබැවින් පහත සඳහන් කරුණු හැරුණු විට මෙම ප්‍රතිචාර වලට එකතු කිරීමට මම උත්සාහ නොකරමි: මම පයිතන්ට අලුත් වෙමි මම ඕඕපී ලැම්බඩාස්ට අලුත් වෙමි දැන් මම මර්ට්ස් කියවා ඇති විට, මම හිතන්නේ මම ඒවා ලබා ගත් අතර ඒවා ක්‍රමලේඛනයට වඩා පිරිසිදු ප්‍රවේශයකට ඉඩ දෙන බව මා සිතන තරමට ඒවා ප්‍රයෝජනවත් යැයි මම සිතමි.

ඔහු පයිතන්හි සෙන් ප්‍රතිනිෂ්පාදනය කරයි, එහි එක් පේළියක් සරල නම් සංකීර්ණ වේ. OOP නොවන ක්‍රමලේඛකයෙකු ලෙස ලැම්බඩාස් සමඟ කියවීමේ කේතයක් (සහ පසුගිය සතිය දක්වා ලැයිස්තු අවබෝධය) මම සිතුවෙමි- මෙය සරලද ? . ඇත්ත වශයෙන්ම මෙම අංගයන් කේතයට වඩා කියවිය හැකි සහ විකල්පයට වඩා තේරුම් ගත හැකි බව මම අද අවසාන වශයෙන් තේරුම් ගතිමි. එය කිසියම් ආකාරයක ලූපයකි. මූල්‍ය ප්‍රකාශන මෙන් - පයිතන් නවක පරිශීලකයා සඳහා නිර්මාණය කර නැති බවත්, එය අධ්‍යාපනය ලැබීමට කැමති පරිශීලකයා සඳහා නිර්මාණය කර ඇති බවත් මම තේරුම් ගතිමි. මෙම භාෂාව කෙතරම් බලවත්දැයි මට විශ්වාස කළ නොහැක. එය මා වෙත පැමිණි විට (අවසාන වශයෙන්) ලැම්බඩාස් වල අරමුණ හා වටිනාකම මට අවශ්‍ය වූයේ වැඩසටහන් 30 ක් පමණ ඉරා දමා සුදුසු තැනක ලැම්බඩා දැමීම ආරම්භ කිරීමටය.

ලැම්බඩාස් භාවිතා කිරීම සඳහා ප්‍රයෝජනවත් අවස්ථාවක් වන්නේ දිගු ලැයිස්තු අවබෝධයේ කියවීමේ හැකියාව වැඩි දියුණු කිරීමයි . මෙම උදාහරණයේ දී loop_dicපැහැදිලිකම සඳහා කෙටි නමුත් loop_dicඉතා දිගු යැයි සිතන්න . ඔබ iඑම අගයේ ලැම්බඩා අනුවාදය වෙනුවට සරල අගයක් භාවිතා කරන්නේ නම් ඔබට ලැබෙනු ඇත NameError.

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> loop_dic = lambda i: {"name": i["name"] + " Wallace" }
>>> new_lis = [loop_dic(i) for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

වෙනුවට

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> new_lis = [{"name": i["name"] + " Wallace"} for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

මට ඇත්ත වශයෙන්ම ලැම්බඩා බැරෑරුම් ලෙස අවශ්‍ය වූ උදාහරණයක් ඔබට දෙන්න පුළුවන්. මම චිත්‍රක වැඩසටහනක් සාදමි, එහිදී භාවිතා කිරීම ගොනුවක් මත දකුණු ක්ලික් කර විකල්ප තුනෙන් එකක් පවරයි. Tkinter හි (මම මෙය ලියන GUI අතුරුමුහුණත් වැඩසටහන), යමෙකු බොත්තමක් එබූ විට, එය තර්ක විතර්කයකට ගෙන යා නොහැකි බව පෙනේ. එබැවින් මම විකල්පයන්ගෙන් එකක් තෝරාගෙන මගේ තේරීමේ ප්‍රති result ලය වීමට අවශ්‍ය නම්:

print 'hi there'

එහෙනම් ලොකු දෙයක් නැහැ. නමුත් විශේෂිත විස්තරයක් ලබා ගැනීමට මගේ තේරීම අවශ්‍ය නම් කුමක් කළ යුතුද? උදාහරණයක් ලෙස, මම තේරීම A තෝරා ගන්නේ නම්, එය A, B හෝ C තේරීම මත රඳා පවතින යම් තර්කයක් ගන්නා ශ්‍රිතයක් ලෙස හැඳින්වේ, TKinter ට මේ සඳහා සහාය විය නොහැක. ඇත්ත වශයෙන්ම මෙය වටහා ගත හැකි එකම විකල්පය ලැම්ඩා ය ...

මම එය බොහෝ විට භාවිතා කරමි, ප්‍රධාන වශයෙන් ශුන්‍ය වස්තුවක් ලෙස හෝ පරාමිතීන් අර්ධ වශයෙන් ශ්‍රිතයකට බන්ධනය කිරීමට ය.

මෙන්න උදාහරණ:

ශුන්‍ය වස්තු රටාව ක්‍රියාත්මක කිරීමට:

{
    DATA_PACKET: self.handle_data_packets
    NET_PACKET: self.handle_hardware_packets
}.get(packet_type, lambda x : None)(payload)

පරාමිති බන්ධනය සඳහා:

මට පහත API ඇති බව කියමු

def dump_hex(file, var)
    # some code
    pass

class X(object):
    #...
    def packet_received(data):
        # some kind of preprocessing
        self.callback(data)
    #...

පසුව, ලැබුනු දත්ත ඉක්මනින් ගොනුවකට දැමිය නොහැකි විට මම එය කරන්නේ:

dump_file = file('hex_dump.txt','w')
X.callback = lambda (x): dump_hex(dump_file, x)
...
dump_file.close()

මම පාවිච්චි කරනවා lambdaපරාමිතීන් ඇතුළත් වන ඇමතුම් ලබා ගැනීමට . එකම ක්‍රියාකාරීත්වයක් සිදු කිරීම සඳහා ක්‍රමවේදයක් ලිවීමට වඩා එක් පේළියක ලැම්බඩා ලිවීම වඩා පිරිසිදු ය.

උදාහරණයක් වශයෙන්:

import imported.module

def func():
    return lambda: imported.module.method("foo", "bar")

විරුද්ධ ලෙස:

import imported.module

def func():
    def cb():
        return imported.module.method("foo", "bar")
    return cb

මම පයිතන් ආරම්භකයෙක්, එබැවින් ලැම්බඩා පිළිබඳ පැහැදිලි අදහසක් ලබා ගැනීම සඳහා මම එය 'සඳහා' ලූපයක් සමඟ සංසන්දනය කළෙමි; කාර්යක්ෂමතාව අනුව. මෙන්න කේතය (පයිතන් 2.7) -

import time
start = time.time() # Measure the time taken for execution

def first():
    squares = map(lambda x: x**2, range(10))
    # ^ Lambda
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0 seconds

def second():
    lst = []
    for i in range(10):
        lst.append(i**2)
    # ^ a 'for' loop
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0019998550415 seconds.

print abs(second() - first()) # Gives 0.0019998550415 seconds!(duh)

ලැම්බඩා යනු ක්‍රියා පටිපාටිය සාදන්නෙකි. පයිතන්ගේ ලැම්බඩා ඉතා බලවත් නොවුවද, ක්‍රියාත්මක වන වේලාවට ඔබට වැඩසටහන් සංස්ලේෂණය කළ හැකිය. ස්වල්ප දෙනෙක් එම ආකාරයේ ක්‍රමලේඛනය තේරුම් ගෙන ඇති බව සලකන්න.