परीक्षा के साथ पायथन लैंबडा फंक्शंस

पाइथन में लैम्बडा फंक्शन क्या है?

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

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

• लैम्ब्डा कीवर्ड।
• पैरामीटर (या बाध्य चर), और
• समारोह शरीर।

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

पायथन ट्यूटोरियल में इस लैम्ब्डा में, आप सीखेंगे:

• सिंटेक्स और उदाहरण
• पाइथन के साथ लैम्ब्डा का प्रयोग बिल्ट-इन
• फ़िल्टर में लैम्ब्डा ()
• नक्शे में लैम्ब्डा ()
• कम में लंबोदर ()
• क्यों और क्यों नहीं) लैम्ब्डा कार्यों का उपयोग करें?
• लम्बदा बनाम नियमित कार्य

सिंटेक्स और उदाहरण

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

lambda p1, p2: expression 

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

हालांकि, ध्यान दें कि हम मापदंडों के आसपास कोष्ठक का उपयोग नहीं करते हैं जैसा कि हम नियमित कार्यों के साथ करते हैं। अंतिम भाग (अभिव्यक्ति) किसी भी मान्य अजगर अभिव्यक्ति है जो आपके द्वारा प्रदान किए गए मापदंडों पर काम करता है।

उदाहरण 1

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

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

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

3

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

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

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

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

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

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

उदाहरण 2

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

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

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

आउटपुट:

 at 0x00000185C3BF81E0>

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

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

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

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

उदाहरण 3

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

#What a lambda returns #2x="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 FUNCTIONdef guru( funct, *args ):funct( *args )def printer_one( arg ):return print (arg)def printer_two( arg ):print(arg)#CALL A REGULAR FUNCTIONguru( printer_one, 'printer 1 REGULAR CALL' )guru( printer_two, 'printer 2 REGULAR CALL \n' )#CALL A REGULAR FUNCTION THRU A LAMBDAguru(lambda: printer_one('printer 1 LAMBDA CALL'))guru(lambda: printer_two('printer 2 LAMBDA CALL'))

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

आउटपुट:

प्रिंटर 1 रेगुलर कॉल

प्रिंटर 2 रेगुलर कॉल

प्रिंटर 1 LAMBDA कॉल

प्रिंटर 2 लैम्ब्डा कॉल

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

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

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

पाइथन के साथ लैम्ब्डा का प्रयोग बिल्ट-इन

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

पायथन लैम्ब्डा में IIFE

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

 (lambda x: x + x)(2) 

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

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

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

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

जिन तत्वों का चयन किया जाएगा वे कुछ पूर्व-परिभाषित बाधा पर आधारित हैं। यह 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, 121, 0, 1]

[केआर 1]

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

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

कम में लंबोदर ()

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

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

चरण 2) इस परिणाम को बचाएं

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

चरण 4) तब तक दोहराएं जब तक कि अधिक तत्व न बचे।

यह भी दो मापदंडों लेता है:

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

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

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

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

120

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

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

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

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

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

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

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

आपको Lambda कब नहीं लेना चाहिए?

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

लम्बदा बनाम नियमित कार्य

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

lambdas

नियमित कार्य

वाक्य - विन्यास:

lambda x : x + x 

वाक्य - विन्यास:

def (x) :return x + x

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

नियमित कार्यों में उनके शरीर में कई भाव और कथन हो सकते हैं।

लम्बदास का उनसे जुड़ा नाम नहीं है। इसलिए उन्हें गुमनाम कार्यों के रूप में भी जाना जाता है।

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

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

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

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

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

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

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

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

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

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

सारांश

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

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