निम्नलिखित कोड क्या करता है?
a = lambda _:True
इंटरएक्टिव प्रॉम्प्ट में मैंने जो पढ़ा और परीक्षण किया, उससे यह एक ऐसा कार्य प्रतीत होता है जो हमेशा लौटता है True।
क्या मुझे ये ठीक तरह से समझ आ रहा है? मुझे यह समझने की उम्मीद है कि अंडरस्कोर ( _) का उपयोग क्यों किया गया था।
_के बजाय, xया aया जो कुछ भी। यदि कोई जानना चाहता है कि लंबोदर समारोह कैसे लिखा जाए, जिसमें कोई तर्क न हो; यहाँ है कैसे: इसे इस तरह परिभाषित करें my_lambda = lambda : 255:। इसे इस तरह से कॉल करें: x = my_lambda()आप 255जो भी रिटर्न वैल्यू पसंद करते हैं उसे बदल सकते हैं।
जवाबों:
_चर नाम है। कोशिश करो। (यह चर नाम आमतौर पर एक उपेक्षित चर के लिए एक नाम है। बोलने के लिए एक प्लेसहोल्डर।)
अजगर:
>>> l = lambda _: True
>>> l()
<lambda>() missing 1 required positional argument: '_'
>>> l("foo")
True
तो इस लंबोदर को एक तर्क की आवश्यकता है । यदि आप बिना किसी तर्क के एक लंबोदर चाहते हैं जो हमेशा लौटता है True, तो यह करें:
>>> m = lambda: True
>>> m()
True
Python 3.6.2तहत परीक्षण किया Mac OS 10.12और यह काम करता है।
_का आमतौर पर उपयोग किया जाता है जब चर वास्तव में आवश्यक नहीं होता है। यह एक "फेंक-दूर-चर" की तरह है, बस एक प्लेसहोल्डर है जो किसी काम का नहीं है।
अंडरस्कोर एक अप्रयुक्त चर नाम देने के लिए एक पायथन सम्मेलन है (जैसे स्थैतिक विश्लेषण उपकरण इसे अप्रयुक्त चर के रूप में रिपोर्ट नहीं करता है)। आपके मामले में लैम्ब्डा तर्क अप्रयुक्त है, लेकिन निर्मित वस्तु एकल-तर्क फ़ंक्शन है जो हमेशा रिटर्न करता है True। इसलिए आपका लंबो गणित में लगातार स्थिर कार्य के अनुरूप है ।
यह एक ऐसा कार्य प्रतीत होता है जो सत्य की परवाह किए बिना लौटता है।
हाँ, यह एक फंक्शन (या लैम्ब्डा) है जो ट्रू रिटर्न करता है। अंडरस्कोर , जो आमतौर पर एक पर ध्यान नहीं दिया चर के लिए प्लेसहोल्डर है, इस मामले में अनावश्यक है।
इस तरह के एक फ़ंक्शन के लिए एक उदाहरण का उपयोग मामला (जो लगभग कुछ भी नहीं करता है):
dd = collections.defaultdict(lambda: True)
जब डिफॉल्ट के तर्क के रूप में उपयोग किया जाता है , तो आपके पास Trueसामान्य डिफ़ॉल्ट मान हो सकता है।
नीचे प्रश्न में कोड की पंक्ति है:
a = lambda _:True
यह एक इनपुट पैरामीटर वाला फ़ंक्शन बनाता है _:। अंडरस्कोर चर नाम का एक अजीब विकल्प है, लेकिन यह सिर्फ एक चर नाम है। आप _कहीं भी उपयोग कर सकते हैं , तब भी जब लैम्बडा फ़ंक्शंस का उपयोग नहीं कर रहे हों। उदाहरण के लिए, इसके बजाय ...।
my_var = 5
print(my_var)
आप लिख सकते हैं:
_ = 5
print(_)
हालाँकि, एक कारण _था जो कुछ के बजाय xया जैसे पैरामीटर नाम के नाम के रूप में उपयोग किया जाता था input। हम एक पल में मिल जाएगा।
सबसे पहले, हमें यह जानना होगा कि लैम्ब्डा-कीवर्ड एक फ़ंक्शन का निर्माण करता है def, लेकिन समान सिंटैक्स के साथ। लैम्ब्डा फ़ंक्शन की परिभाषा, a = lambda _:Trueलेखन के समान है:
def a(_):
return True
यह aएक इनपुट पैरामीटर के साथ एक फ़ंक्शन बनाता है _, और यह वापस आ जाता है True। एक अंडरस्कोर के बजाय a = lambda x:Trueएक आसानी से लिखा जा सकता है x। हालाँकि, कन्वेंशन को _वैरिएबल नाम के रूप में उपयोग करना है जब हम उस वैरिएबल का उपयोग करने का इरादा नहीं रखते हैं। निम्नलिखित को धयान मे रखते हुए:
for _ in range(1, 11):
print('pear')
ध्यान दें कि लूप इंडेक्स का उपयोग लूप-बॉडी के अंदर कभी नहीं किया जाता है। हम चाहते हैं कि लूप कई बार निर्दिष्ट संख्या को निष्पादित करे। जैसा winklerrrकि लिखा है, "परिवर्तनशील नाम _[...]" फेंक-दूर-चर "की तरह है, बस एक प्लेसहोल्डर है जो किसी काम का नहीं है।"
इसी तरह, `` a = लैंबडा x: फंक्शन के बॉडी के अंदर इनपुट पैरामीटर का उपयोग नहीं किया जाता है। यह वास्तव में मायने नहीं रखता कि इनपुट तर्क क्या है, जब तक कि एक है। उस लैम्बडा-फंक्शन के लेखक ने _कुछ इस तरह लिखा था जैसे xकि यह इंगित करना कि चर का उपयोग नहीं किया जाएगा।
ध्यान दें कि लैम्ब्डा है एक तर्क है, इसलिए, लेखन
a(), एक त्रुटि बढ़ाएगा।
अगर आप बिना किसी तर्क के एक लंबोदर चाहते हैं तो कुछ इस तरह लिखें:
bar = lambda: True
अब कॉलिंग bar(), बिना किसी आर्ग के, ठीक काम करेगा। एक लंबोदर जो कोई तर्क नहीं लेता है, उसे हमेशा एक ही मूल्य वापस करने की आवश्यकता नहीं होती है:
import random
process_fruit = lambda : random.random()
ऊपर लैंबडा फ़ंक्शन अधिक जटिल है कि बस एक ऐसी चीज जो हमेशा एक ही स्थिर लौटाती है।
एक कारण यह है कि प्रोग्रामर कभी-कभी हमें उन कार्यों के लिए lambdaकीवर्ड defकरते हैं जो विशेष रूप से लघु और सरल हैं। ध्यान दें कि एक lambdaपरिभाषा आमतौर पर सभी को एक पंक्ति में फिट कर सकती है, जबकि, एक डीफ स्टेटमेंट के साथ ऐसा करना मुश्किल है। एसएफ के lambdaबजाय उपयोग करने का एक और कारण defजब फ़ंक्शन फिर से उपयोग नहीं किया जाएगा। यदि हम फ़ंक्शन को बाद में फिर से कॉल नहीं करना चाहते हैं, तो फ़ंक्शन को नाम देने की कोई आवश्यकता नहीं है। उदाहरण के लिए निम्नलिखित कोड पर विचार करें:
def apply_to_each (बदलना, in_container): out_container = list () idx के लिए, enumerate में आइटम (कंटेनर, 0): out_container [idx] = transform (आइटम) return -container
अब हम निम्नलिखित कॉल करते हैं:
squares = apply_to_each(lambda x: x**2 range(0, 101))
ध्यान दें कि lambda x: x**2एक लेबल नहीं दिया गया है। ऐसा इसलिए है क्योंकि हम शायद इसे बाद में फिर से कॉल नहीं करेंगे, यह सिर्फ कुछ छोटा और सरल था जिसकी हमें अस्थायी रूप से आवश्यकता थी।
तथ्य यह है कि लैम्ब्डा कार्यों की आवश्यकता नहीं है, उन्हें वर्णन करने के लिए एक और नाम का स्रोत है: "अनाम फ़ंक्शन।"
यह भी ध्यान दें कि लैम्ब्डा-स्टेटमेंट एक फंक्शन-कॉल की तरह हैं जिसमें वे अपने द्वारा बनाए गए फंक्शन का संदर्भ देते हैं। निम्नलिखित अवैध है:
apply_to_each(def foo(x): x**2 , range(0, 101))
जबकि, apply_to_each(lambda x: x**2 range(0, 101))अभी ठीक है।
इसलिए, जब हम कुछ छोटा, मीठा चाहते हैं तो हम लंबे वेरिएबल नाम के बजाय और उपयोग lambdaकरते हैं defऔर _बाद में फिर से उपयोग नहीं करना चाहेंगे।
lambda : True