லாம்ப்டா மற்றும் உயர்-வரிசை செயல்பாடுகள்

ஒரு லாம்ப்டா என்பது ஒரு அநாமதேய செயல்பாடு, ஒற்றை வரியில் வரையறுக்கப்படுகிறது. தொடரியல்:

lambda parametri: espressione

defக்கு சமமானது, ஆனால் மிகவும் சுருக்கமானது மற்றும் "எறிந்துவிடுவதற்கு" ஏற்றது செயல்பாடுகள் மற்ற செயல்பாடுகளுக்கு அனுப்பப்படும்.

quadrato = lambda x: x ** 2
quadrato(5)    # 25

# equivalent to:
def quadrato(x):
    return x ** 2

def எதிராக வேறுபாடுகள்

லாம்ப்டாவிற்குள் return இல்லை: வெளிப்பாட்டின் மதிப்பு இதன் விளைவாகும்.

லாம்ப்டாவை எப்போது பயன்படுத்த வேண்டும்

கிட்டத்தட்ட எப்போதும்: வரிசைப்படுத்துதல் அல்லது தேர்வு செயல்பாடுகளுக்கான key வாதமாக.

parole = ["banana", "kiwi", "mela", "fragola"]
sorted(parole, key=len)
# ['kiwi', 'mela', 'banana', 'fragola']

key=len sorted கூறுகிறது: "இரண்டு கூறுகளை ஒப்பிட, அவற்றின் நீளத்தைப் பயன்படுத்தவும்". க்கு தனிப்பயன் அளவுகோல்கள், லாம்ப்டாவைப் பயன்படுத்தவும்:

utenti = [
    {"nome": "Ada", "eta": 36},
    {"nome": "Linus", "eta": 54},
    {"nome": "Grace", "eta": 85},
]
per_eta = sorted(utenti, key=lambda u: u["eta"])
# sorted by ascending age

மற்ற வழக்கமான பயன்பாடுகள்: min(...), max(...), filter(...), map(...).

nums = [-3, 1, -4, 1, -5, 9]
max(nums, key=lambda n: abs(n))   # -5 (maximum by absolute value)

உயர்-வரிசை செயல்பாடுகள்

ஒரு செயல்பாடு ஒரு வாதமாக ஏற்றுக்கொண்டால் அல்லது உயர்-வரிசை ஒன்று திரும்புகிறது. sorted, max, filter, map உயர்-வரிசை. லாம்ப்டா உயர்-வரிசை அழைப்புகளை எளிதாக்குவதற்கு துல்லியமாக உள்ளது.

லாம்ப்டா செயல்பாடுகளை எப்போது தவிர்க்க வேண்டும்

லாம்ப்டா செயல்பாடுகள் குறுகிய, தூக்கி எறியப்படும் செயல்பாடுகளுக்கு (விரைவான வரிசைப்படுத்தல் போன்றவை) பயனுள்ளதாக இருக்கும். இருப்பினும், நீங்கள் ஒரு மாறிக்கு (எ.கா. double = lambda x: x * 2) லாம்ப்டாவை ஒதுக்குவதைக் கண்டால், பொதுவாக def பிளாக்கைப் படிப்பது மற்றும் பிழைத்திருத்தம் நோக்கங்களுக்காகப் பயன்படுத்துவது விரும்பப்படுகிறது (**AGYTOK_INLINE_22 இல் **AGYTOK_INLINE_22 பிழையுடன் வரையறுக்கப்பட்ட செயல்பாடுகள் அவற்றின் உண்மையான பெயர்களில் இருக்கும் என்பதால்).

முயற்சி செய்து பாருங்கள்

மதிப்பாய்வு பயிற்சி

கூடுதல் சவால்