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

लैम्ब्डा फ़ंक्शन क्या है? Python?

A लैम्ब्डा फ़ंक्शन Python प्रोग्रामिंग एक अनाम फ़ंक्शन या ऐसा फ़ंक्शन है जिसका कोई नाम नहीं है। यह एक छोटा और प्रतिबंधित फ़ंक्शन है जिसमें एक से ज़्यादा लाइन नहीं होती। एक सामान्य फ़ंक्शन की तरह, एक लैम्ब्डा फ़ंक्शन में एक अभिव्यक्ति के साथ कई तर्क हो सकते हैं।

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

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

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

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

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

lambda p1, p2: expression

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

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

उदाहरण 1

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

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

Code व्याख्या

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

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>

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

Code स्पष्टीकरण:

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

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

Code स्पष्टीकरण:

1. यह वही स्ट्रिंग है जिसे हमने पिछले उदाहरण में परिभाषित किया था।

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

उदाहरण 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

Code स्पष्टीकरण:

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

2. printer_one एक सरल फ़ंक्शन है जो इसे दिए गए पैरामीटर को प्रिंट करता है और उसे वापस लौटाता है।

3. printer_two, printer_one के समान है लेकिन इसमें रिटर्न स्टेटमेंट नहीं है।

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]

Code स्पष्टीकरण:

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

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

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

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

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

map फ़ंक्शन का उपयोग किसी अनुक्रम के प्रत्येक तत्व पर एक विशेष क्रिया लागू करने के लिए किया जाता है। filter() की तरह, यह भी 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]

Code स्पष्टीकरण:

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

2. हम filtered_result नामक एक वेरिएबल घोषित करते हैं जो मैप किए गए मानों को संग्रहीत करेगा।

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

Code स्पष्टीकरण:

1. functools मॉड्यूल से reduce को इम्पोर्ट करें।

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

3. हम product नामक एक वेरिएबल घोषित करते हैं जो कम किए गए मान को संग्रहीत करेगा।

4. एक लैम्डा फ़ंक्शन जो सूची के प्रत्येक तत्व पर चलता है। यह पिछले परिणाम के अनुसार उस संख्या का गुणनफल लौटाएगा।

5. रिड्यूस फ़ंक्शन द्वारा लौटाए गए परिणाम को प्रिंट करें।

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

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

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

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

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

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

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

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

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

lambda x : x + x

def (x) :
return x + x 

मतभेदों की व्याख्या

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

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

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

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

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

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

अक्सर पूछे जाने वाले प्रश्न