Python लैम्ब्डा फ़ंक्शन उदाहरणों के साथ

In Python, लैम्ब्डा एक्सप्रेशन (या लैम्ब्डा फॉर्म) का उपयोग अनाम फ़ंक्शन बनाने के लिए किया जाता है। ऐसा करने के लिए, आप इसका उपयोग करेंगे लैम्ब्डा कीवर्ड (जैसा कि आप उपयोग करते हैं डीईएफ़ सामान्य फ़ंक्शन को परिभाषित करने के लिए)। आपके द्वारा परिभाषित प्रत्येक अनाम फ़ंक्शन Python इसके 3 आवश्यक भाग होंगे:

• लैम्ब्डा कीवर्ड.
• पैरामीटर (या बाउंड वैरिएबल), और
• कार्य निकाय.

एक लैम्ब्डा फ़ंक्शन में किसी भी संख्या में पैरामीटर हो सकते हैं, लेकिन फ़ंक्शन बॉडी में केवल एक अभिव्यक्ति। इसके अलावा, लैम्ब्डा को कोड की एक ही पंक्ति में लिखा जाता है और इसे तुरंत लागू भी किया जा सकता है। आप आने वाले उदाहरणों में यह सब कार्रवाई में देखेंगे।

वाक्यविन्यास और उदाहरण

लैम्ब्डा फ़ंक्शन लिखने का औपचारिक सिंटैक्स नीचे दिया गया है:

lambda p1, p2: expression

यहाँ, p1 और p2 वे पैरामीटर हैं जो लैम्ब्डा फ़ंक्शन को पास किए जाते हैं। आप अपनी ज़रूरत के अनुसार ज़्यादा या कम पैरामीटर जोड़ सकते हैं।

हालाँकि, ध्यान दें कि हम नियमित फ़ंक्शन के साथ पैरामीटर के चारों ओर कोष्ठक का उपयोग नहीं करते हैं। अंतिम भाग (अभिव्यक्ति) कोई भी वैध पायथन अभिव्यक्ति है जो फ़ंक्शन को आपके द्वारा प्रदान किए गए पैरामीटर पर काम करती है।

उदाहरण 1

अब जब आप लैम्बडा के बारे में जानते हैं तो चलिए इसे एक उदाहरण के साथ आज़माते हैं। तो, अपना खोलें IDLE और निम्नलिखित टाइप करें:

adder = lambda x, y: x + y
print (adder (1, 2))

यहाँ उत्पादन है:

3

कोड स्पष्टीकरण

यहां, हम एक वेरिएबल परिभाषित करते हैं जो लैम्ब्डा फ़ंक्शन द्वारा लौटाए गए परिणाम को धारण करेगा।

1. लैम्ब्डा कीवर्ड का उपयोग अनाम फ़ंक्शन को परिभाषित करने के लिए किया जाता है।

2. x और y वे पैरामीटर हैं जिन्हें हम लैम्ब्डा फ़ंक्शन में पास करते हैं।

3. यह फ़ंक्शन का मुख्य भाग है, जो हमारे द्वारा पास किए गए 2 पैरामीटर जोड़ता है। ध्यान दें कि यह एक एकल अभिव्यक्ति है। आप लैम्ब्डा फ़ंक्शन के मुख्य भाग में कई कथन नहीं लिख सकते।

4. हम फ़ंक्शन को कॉल करते हैं और लौटाए गए मान को प्रिंट करते हैं।

उदाहरण 2

यह लैम्ब्डा के मूल सिद्धांतों और वाक्यविन्यास को समझने के लिए एक बुनियादी उदाहरण था। आइए अब लैम्ब्डा को प्रिंट करने और परिणाम देखने का प्रयास करें। फिर से, अपना खोलें IDLE और निम्नलिखित टाइप करें:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

अब अपनी फ़ाइल को सेव करें और प्रोग्राम को चलाने के लिए F5 दबाएँ। यह वह आउटपुट है जो आपको मिलना चाहिए।

आउटपुट:

<function <lambda> at 0x00000185C3BF81E0>

यहाँ क्या हो रहा है? आइए इसे और समझने के लिए कोड देखें।

कोड स्पष्टीकरण

1. यहाँ, हम एक परिभाषित करते हैं स्ट्रिंग जिसे आप लैम्ब्डा में पैरामीटर के रूप में पास करेंगे।
2. हम एक लैम्ब्डा घोषित करते हैं जो प्रिंट स्टेटमेंट को कॉल करता है और परिणाम प्रिंट करता है।

लेकिन प्रोग्राम हमारे द्वारा पास की गई स्ट्रिंग को प्रिंट क्यों नहीं करता? ऐसा इसलिए है क्योंकि लैम्बडा खुद एक फ़ंक्शन ऑब्जेक्ट लौटाता है। इस उदाहरण में, लैम्बडा का उपयोग नहीं किया जा रहा है बुलाया प्रिंट फ़ंक्शन द्वारा लेकिन बस लौटने फ़ंक्शन ऑब्जेक्ट और मेमोरी स्थान जहाँ इसे संग्रहीत किया जाता है। कंसोल पर यही प्रिंट होता है।

उदाहरण 3

हालाँकि, यदि आप इस तरह का प्रोग्राम लिखते हैं:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

और F5 दबाकर इसे चलाएं, आपको कुछ इस तरह का आउटपुट दिखाई देगा।

आउटपुट:

some kind of a useless lambda

अब, लैम्बडा को कॉल किया जा रहा है, और हमारे द्वारा पास की गई स्ट्रिंग कंसोल पर प्रिंट हो जाती है। लेकिन वह अजीब वाक्यविन्यास क्या है, और लैम्बडा परिभाषा को कोष्ठक में क्यों कवर किया गया है? आइए अब इसे समझते हैं।

कोड स्पष्टीकरण

1. यहां वही स्ट्रिंग है जिसे हमने पिछले उदाहरण में परिभाषित किया था।
2. इस भाग में, हम एक लैम्ब्डा को परिभाषित कर रहे हैं और स्ट्रिंग को तर्क के रूप में पास करके इसे तुरंत कॉल कर रहे हैं। इसे IIFE कहा जाता है, और आप इस ट्यूटोरियल के आगामी अनुभागों में इसके बारे में अधिक जानेंगे।

उदाहरण 4

आइए एक अंतिम उदाहरण देखें कि लैम्बडा और नियमित फ़ंक्शन कैसे निष्पादित होते हैं। तो, अपना खोलें IDLE और एक नई फ़ाइल में, निम्नलिखित टाइप करें:

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

अब, फ़ाइल को सेव करें और प्रोग्राम को चलाने के लिए F5 दबाएँ। अगर आपने कोई गलती नहीं की है, तो आउटपुट कुछ इस तरह होना चाहिए।

आउटपुट:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

कोड स्पष्टीकरण

1. गुरु नामक एक फ़ंक्शन जो किसी अन्य फ़ंक्शन को प्रथम पैरामीटर के रूप में लेता है तथा उसके बाद अन्य तर्क भी लेता है।
2. प्रिंटर_वन एक सरल फ़ंक्शन है जो इसे दिए गए पैरामीटर को प्रिंट करता है और उसे वापस कर देता है।
3. प्रिंटर_टू प्रिंटर_वन के समान है, लेकिन इसमें रिटर्न स्टेटमेंट नहीं है।
4. इस भाग में, हम गुरु फ़ंक्शन को कॉल कर रहे हैं और प्रिंटर फ़ंक्शन और स्ट्रिंग को पैरामीटर के रूप में पास कर रहे हैं।
5. यह चौथे चरण (अर्थात गुरु फ़ंक्शन को कॉल करना) को प्राप्त करने के लिए सिंटैक्स है, लेकिन लैम्ब्डा का उपयोग करके।

अगले भाग में, आप सीखेंगे कि लैम्ब्डा फ़ंक्शन का उपयोग कैसे करें नक्शा(), कम करना(), और फिल्टर () in Python.

लैम्ब्डा का उपयोग करना Python बनाया-इन

लैम्ब्डा फ़ंक्शन अंतर्निहित विधियों का उपयोग करके संचालन करने के लिए एक सुंदर और शक्तिशाली तरीका प्रदान करते हैं Pythonयह इसलिए संभव है क्योंकि लैम्ब्डा को तुरंत लागू किया जा सकता है और इन फंक्शनों में एक तर्क के रूप में पारित किया जा सकता है।

आईआईएफई में Python lambda

आईआईएफई के लिए खड़ा है तुरंत फ़ंक्शन निष्पादन लागू किया गया. इसका मतलब है कि लैम्ब्डा फ़ंक्शन को परिभाषित होते ही कॉल किया जा सकता है। आइए इसे एक उदाहरण से समझते हैं; अपना IDLE और निम्नलिखित टाइप करें:

 (lambda x: x + x)(2)

आउटपुट और कोड स्पष्टीकरण इस प्रकार है:

लैम्बडा को तुरंत लागू करने की यह क्षमता आपको उन्हें map() और reduce() जैसे फ़ंक्शन के अंदर उपयोग करने की अनुमति देती है। यह उपयोगी है क्योंकि आप इन फ़ंक्शन का फिर से उपयोग नहीं करना चाहेंगे।

फ़िल्टर में लैम्ब्डा()

फ़िल्टर फ़ंक्शन का उपयोग तत्वों के अनुक्रम से कुछ विशेष तत्वों को चुनने के लिए किया जाता है। अनुक्रम कोई भी इटरेटर हो सकता है जैसे कि सूचियाँ, सेट, टपल, आदि।

चुने जाने वाले तत्व कुछ पूर्व-निर्धारित बाध्यता पर आधारित होते हैं। इसमें 2 पैरामीटर लगते हैं:

• एक फ़ंक्शन जो फ़िल्टरिंग प्रतिबंध को परिभाषित करता है
• एक अनुक्रम (कोई भी पुनरावर्तक जैसे सूची, टपल, आदि)

उदाहरण के लिए,

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

यहाँ उत्पादन है:

[10, 8, 7, 5, 11]

कोड स्पष्टीकरण:

1. पहले कथन में, हम अनुक्रम नामक एक सूची परिभाषित करते हैं जिसमें कुछ संख्याएँ होती हैं।

2. यहां, हम फ़िल्टर्ड_रिजल्ट नामक एक वेरिएबल घोषित करते हैं, जो फ़िल्टर() फ़ंक्शन द्वारा लौटाए गए फ़िल्टर किए गए मानों को संग्रहीत करेगा।

3. एक लैम्ब्डा फ़ंक्शन जो सूची के प्रत्येक तत्व पर चलता है और यदि यह 4 से अधिक है तो सत्य लौटाता है।

4. फ़िल्टर फ़ंक्शन द्वारा लौटाए गए परिणाम को प्रिंट करें.

मानचित्र में लैम्ब्डा()

मैप फ़ंक्शन का उपयोग अनुक्रम में प्रत्येक तत्व पर एक विशेष ऑपरेशन लागू करने के लिए किया जाता है। फ़िल्टर() की तरह, यह भी 2 पैरामीटर लेता है:

1. एक फ़ंक्शन जो तत्वों पर निष्पादित करने के लिए ऑप को परिभाषित करता है
2. एक या अधिक अनुक्रम

उदाहरण के लिए, यहाँ एक प्रोग्राम है जो दी गई सूची में संख्याओं के वर्गों को प्रिंट करता है:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

आउटपुट:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

[केआर1]

कोड स्पष्टीकरण:

1. यहां, हम अनुक्रम नामक एक सूची परिभाषित करते हैं जिसमें कुछ संख्याएं होती हैं।
2. हम फ़िल्टर्ड_रिजल्ट नामक एक वैरिएबल घोषित करते हैं जो मैप किए गए मानों को संग्रहीत करेगा
3. एक लैम्ब्डा फ़ंक्शन जो सूची के प्रत्येक तत्व पर चलता है और उस संख्या का वर्ग लौटाता है।
4. मैप फ़ंक्शन द्वारा लौटाए गए परिणाम को प्रिंट करें.

कम करने में लैम्ब्डा()

मैप() की तरह रिड्यूस फ़ंक्शन का उपयोग अनुक्रम में प्रत्येक तत्व पर एक ऑपरेशन लागू करने के लिए किया जाता है। हालाँकि, यह अपने काम में मैप से अलग है। आउटपुट की गणना करने के लिए रिड्यूस() फ़ंक्शन द्वारा अपनाए जाने वाले चरण ये हैं:

चरण 1) अनुक्रम के पहले 2 तत्वों पर निर्धारित ऑपरेशन निष्पादित करें।

चरण 2) यह परिणाम सहेजें

चरण 3) सहेजे गए परिणाम और अनुक्रम में अगले तत्व के साथ ऑपरेशन निष्पादित करें।

चरण 4) तब तक दोहराएं जब तक कोई और तत्व शेष न बचे।

इसमें भी दो पैरामीटर होते हैं:

1. एक फ़ंक्शन जो निष्पादित किए जाने वाले ऑपरेशन को परिभाषित करता है
2. एक अनुक्रम (कोई भी पुनरावर्तक जैसे सूची, टपल, आदि)

उदाहरण के लिए, यहाँ एक प्रोग्राम है जो सूची में सभी तत्वों का गुणनफल लौटाता है:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

यहाँ उत्पादन है:

120

कोड स्पष्टीकरण:

1. functools मॉड्यूल से reduce आयात करें
2. यहां, हम अनुक्रम नामक एक सूची परिभाषित करते हैं जिसमें कुछ संख्याएं होती हैं।
3. हम product नामक एक चर घोषित करते हैं जो घटाए गए मान को संग्रहीत करेगा
4. एक लैम्ब्डा फ़ंक्शन जो सूची के प्रत्येक तत्व पर चलता है। यह पिछले परिणाम के अनुसार उस संख्या का गुणनफल लौटाएगा।
5. रिड्यूस फ़ंक्शन द्वारा लौटाए गए परिणाम को प्रिंट करें।

लैम्ब्डा फ़ंक्शन का उपयोग क्यों करें (और क्यों नहीं)?

जैसा कि आप अगले भाग में देखेंगे, लैम्बडा को इंटरप्रेटर स्तर पर नियमित फ़ंक्शन के समान ही माना जाता है। एक तरह से, आप कह सकते हैं कि लैम्बडा फ़ंक्शन लिखने के लिए कॉम्पैक्ट सिंटैक्स प्रदान करता है जो एकल अभिव्यक्ति लौटाता है।

हालाँकि, आपको पता होना चाहिए कि कब लैम्बडा का उपयोग करना अच्छा विचार है और कब उनसे बचना चाहिए। इस अनुभाग में, आप लैम्बडा लिखते समय पायथन डेवलपर्स द्वारा उपयोग किए जाने वाले कुछ डिज़ाइन सिद्धांतों को जानेंगे।

लैम्ब्डा के लिए सबसे आम उपयोग मामलों में से एक कार्यात्मक प्रोग्रामिंग में है Python प्रोग्रामिंग के एक प्रतिमान (या शैली) का समर्थन करता है जिसे कार्यात्मक प्रोग्रामिंग के रूप में जाना जाता है।

यह आपको किसी फ़ंक्शन को दूसरे फ़ंक्शन के लिए पैरामीटर के रूप में प्रदान करने की अनुमति देता है (उदाहरण के लिए, मैप, फ़िल्टर, आदि में)। ऐसे मामलों में, लैम्बडा का उपयोग करके एक बार का फ़ंक्शन बनाने और उसे पैरामीटर के रूप में पास करने का एक शानदार तरीका प्रदान किया जाता है।

आपको लैम्ब्डा का उपयोग कब नहीं करना चाहिए?

आपको कभी भी उत्पादन परिवेश में जटिल लैम्ब्डा फ़ंक्शन नहीं लिखना चाहिए। आपके कोड को बनाए रखने वाले कोडर के लिए इसे डिक्रिप्ट करना बहुत मुश्किल होगा। यदि आप खुद को जटिल वन-लाइनर एक्सप्रेशन बनाते हुए पाते हैं, तो उचित फ़ंक्शन को परिभाषित करना एक बेहतर अभ्यास होगा। एक सर्वोत्तम अभ्यास के रूप में, आपको यह याद रखना होगा कि सरल कोड हमेशा जटिल कोड से बेहतर होता है।

लैम्ब्डा बनाम नियमित फ़ंक्शन

जैसा कि पहले बताया गया है, लैम्बडा [vV4][J5] केवल फ़ंक्शन हैं जिनके साथ कोई पहचानकर्ता जुड़ा नहीं है। सरल शब्दों में, वे बिना नाम वाले फ़ंक्शन हैं (इसलिए, अनाम)। यहाँ पायथन में लैम्बडा और नियमित फ़ंक्शन के बीच अंतर को दर्शाने के लिए एक तालिका दी गई है।

lambdas

नियमित कार्य

सिंटेक्स:

lambda x : x + x

सिंटेक्स:

def (x) :
return x + x 

लैम्ब्डा फ़ंक्शन के मुख्य भाग में केवल एक ही अभिव्यक्ति हो सकती है।

नियमित कार्यों में अनेक अभिव्यक्तियाँ और कथन हो सकते हैं।

लैम्बडा के साथ कोई नाम जुड़ा नहीं होता। इसीलिए उन्हें अनाम फ़ंक्शन के रूप में भी जाना जाता है।

नियमित कार्यों में नाम और हस्ताक्षर होना चाहिए।

लैम्ब्डा में रिटर्न स्टेटमेंट नहीं होता क्योंकि बॉडी स्वचालित रूप से वापस आ जाती है।

जिन फंक्शनों को मान लौटाने की आवश्यकता होती है उनमें रिटर्न स्टेटमेंट शामिल होना चाहिए।

मतभेदों का स्पष्टीकरण?

लैम्ब्डा और रेगुलर फ़ंक्शन के बीच प्राथमिक अंतर यह है कि लैम्ब्डा फ़ंक्शन केवल एक ही अभिव्यक्ति का मूल्यांकन करता है और फ़ंक्शन ऑब्जेक्ट देता है। परिणामस्वरूप, हम लैम्ब्डा फ़ंक्शन के परिणाम को नाम दे सकते हैं और इसे अपने प्रोग्राम में उपयोग कर सकते हैं जैसा कि हमने पिछले उदाहरण में किया था।

उपरोक्त उदाहरण के लिए एक नियमित फ़ंक्शन इस तरह दिखेगा:

def adder (x, y):
return x + y 
print (adder (1, 2))

यहाँ, हमें एक परिभाषित करना है नाम उस फ़ंक्शन के लिए जो रिटर्न परिणाम तब हुआ जब हम कॉल यह। लैम्ब्डा फ़ंक्शन में रिटर्न स्टेटमेंट नहीं होता है क्योंकि इसमें केवल एक ही एक्सप्रेशन होगा जो हमेशा डिफ़ॉल्ट रूप से रिटर्न होता है। आपको लैम्ब्डा असाइन करने की भी ज़रूरत नहीं है क्योंकि इसे तुरंत इनवोक किया जा सकता है (अगला सेक्शन देखें)। जैसा कि आप निम्नलिखित उदाहरण में देखेंगे, लैम्ब्डा विशेष रूप से शक्तिशाली हो जाते हैं जब हम उनका उपयोग करते हैं Pythonके अंतर्निहित कार्यों का उपयोग करें।

हालाँकि, आप अभी भी सोच रहे होंगे कि लैम्बडा किसी ऐसे फ़ंक्शन से कैसे अलग है जो एक ही एक्सप्रेशन लौटाता है (जैसे कि ऊपर वाला)। इंटरप्रेटर स्तर पर, बहुत ज़्यादा अंतर नहीं है। यह आश्चर्यजनक लग सकता है, लेकिन कोई भी लैम्बडा फ़ंक्शन जिसे आप परिभाषित करते हैं Python दुभाषिया द्वारा इसे एक सामान्य कार्य के रूप में माना जाता है।

जैसा कि आप आरेख में देख सकते हैं, बाइटकोड में परिवर्तित होने पर दोनों परिभाषाएँ पायथन इंटरप्रेटर द्वारा एक ही तरीके से संभाली जाती हैं। अब, आप किसी फ़ंक्शन को नाम नहीं दे सकते लैम्ब्डा क्योंकि यह आरक्षित है Python, लेकिन कोई भी अन्य फ़ंक्शन नाम समान बाइटकोड देगा[KR6].

सारांश

• लैम्ब्डा, जिसे अनाम फ़ंक्शन के रूप में भी जाना जाता है, छोटे, प्रतिबंधित फ़ंक्शन होते हैं जिन्हें किसी नाम (अर्थात पहचानकर्ता) की आवश्यकता नहीं होती है।
• प्रत्येक लैम्ब्डा फ़ंक्शन Python इसके 3 आवश्यक भाग हैं:
• लैम्ब्डा कीवर्ड.
• पैरामीटर (या बाउंड वैरिएबल), और
• कार्य निकाय.
• लैम्ब्डा लिखने के लिए सिंटैक्स है: लैम्ब्डा पैरामीटर: अभिव्यक्ति
• लैम्ब्डा में किसी भी संख्या में पैरामीटर हो सकते हैं, लेकिन वे ब्रेसेज़ में संलग्न नहीं होते हैं
• एक लैम्ब्डा के फ़ंक्शन बॉडी में केवल 1 अभिव्यक्ति हो सकती है, जो डिफ़ॉल्ट रूप से लौटा दी जाती है।
• बाइटकोड स्तर पर, लैम्ब्डा और नियमित फ़ंक्शन को इंटरप्रेटर द्वारा कैसे प्रबंधित किया जाता है, इसके बीच बहुत अधिक अंतर नहीं है।
• लैम्ब्डा इस सिंटैक्स के माध्यम से IIFE का समर्थन करता है: (लैम्ब्डा पैरामीटर: अभिव्यक्ति)(तर्क)
• लैम्ब्डा का उपयोग सामान्यतः निम्नलिखित पायथन बिल्ट-इन्स के साथ किया जाता है:
• फ़िल्टर: फ़िल्टर (लैम्ब्डा पैरामीटर: अभिव्यक्ति, पुनरावृत्तीय-अनुक्रम)
• मानचित्र: मानचित्र (लैम्ब्डा पैरामीटर: अभिव्यक्ति, पुनरावृत्तीय-अनुक्रम)
• कम करें: कम करें (लैम्ब्डा पैरामीटर1, पैरामीटर2: अभिव्यक्ति, पुनरावृत्तीय-अनुक्रम)
• उत्पादन परिवेश में जटिल लैम्ब्डा फ़ंक्शन न लिखें क्योंकि यह कोड-मेंटेनर्स के लिए कठिन होगा।

[J5]मैंने एक तालिका जोड़ी है, लेकिन अंतर को समझने के लिए स्पष्टीकरण आवश्यक है।

यह कोड संपादन योग्य है। निष्पादित करने के लिए चलाएँ पर क्लिक करें