छंटनी के पीछे सिंटैक्स (कुंजी = लैम्ब्डा:…)

Question

मैं sorted()तर्क के पीछे के सिंटैक्स को नहीं समझता :

key=lambda variable: variable[0]

lambdaमनमानी नहीं है? ऐसा क्यों variableकहा जाता है dict?

Answer 1

keyएक ऐसा कार्य है जिसे तुलना करने से पहले संग्रह की वस्तुओं को बदलने के लिए कहा जाएगा। पारित पैरामीटर keyकुछ होना चाहिए जो कॉल करने योग्य हो।

lambdaएक अनाम फ़ंक्शन (जो कॉल करने योग्य है) का उपयोग करता है। sortedकॉल करने योग्य के मामले में केवल एक पैरामीटर लेता है। पायथन lambdaबहुत सरल है। यह केवल एक चीज कर सकता है और वास्तव में वापस कर सकता है।

का सिंटैक्स lambdaशब्द है lambdaजिसके बाद पैरामीटर नामों की सूची होती है फिर कोड का एक ब्लॉक होता है। पैरामीटर सूची और कोड ब्लॉक को बृहदान्त्र द्वारा चित्रित किया गया है। यह अजगर में अन्य निर्माणों के समान है while, जैसे कि for, ifऔर इसी तरह। वे सभी कथन हैं जो आमतौर पर एक कोड ब्लॉक होते हैं। लैम्ब्डा एक कोड ब्लॉक के साथ एक बयान का एक और उदाहरण है।

हम फंक्शन बनाने के लिए लैम्बडा के उपयोग की तुलना डिफ के साथ कर सकते हैं।

adder_lambda = lambda parameter1,parameter2: parameter1+parameter2
def adder_regular(parameter1, parameter2): return parameter1+parameter2

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

variable यहां दो बार उपयोग किया जाता है क्योंकि बृहदान्त्र के बाएं हाथ पर यह एक पैरामीटर का नाम है और दाहिने हाथ की तरफ इसका उपयोग कोड ब्लॉक में कुछ गणना करने के लिए किया जा रहा है।

Comments

नोट (ओपी के लिए): इसे एक लैम्ब्डा को एक नाम देने के लिए टाला जाना चाहिए (यानी इसे एक तरह से उपयोग करने के अलावा अन्य रक्षा के रूप में)। यदि आप अपने आप को ऐसा करते हुए पाते हैं तो आपको शायद सिर्फ एक का उपयोग करना चाहिए def।

— विम

Answer 2

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

पूर्णता की खातिर, मैं स्पष्ट सामने बताऊंगा: सॉर्ट किए गए () सॉर्ट किए गए तत्वों की एक सूची देता है और यदि हम किसी विशेष तरीके से सॉर्ट करना चाहते हैं या यदि हम तत्वों की एक जटिल सूची को सॉर्ट करना चाहते हैं (जैसे नेस्टेड सूची या टुपल्स की एक सूची) हम मुख्य तर्क को लागू कर सकते हैं।

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

1. अंततः लांबा का उपयोग करने का मतलब है कि आपको एक संपूर्ण फ़ंक्शन लिखना (परिभाषित करना) नहीं है, जैसे कि एक sblom ने एक उदाहरण प्रदान किया है। लैम्ब्डा फ़ंक्शंस बनाए जाते हैं, उपयोग किए जाते हैं, और तुरंत नष्ट हो जाते हैं - इसलिए वे आपके कोड को अधिक कोड के साथ फंक नहीं करते हैं जो केवल एक बार उपयोग किया जाएगा। यह, जैसा कि मैं इसे समझता हूं, लैम्बडा फ़ंक्शन की मुख्य उपयोगिता है और इस तरह की भूमिकाओं के लिए इसके अनुप्रयोग व्यापक हैं। इसका सिंटैक्स विशुद्ध रूप से सम्मेलन द्वारा होता है, जो कि सामान्य रूप से प्रोग्रामेटिक सिंटैक्स की प्रकृति का सार है। सिंटैक्स जानें और इसके साथ किया जाए।

लंबोदर सिंटैक्स इस प्रकार है:

lambda input_variable (ओं) : स्वादिष्ट एक लाइनर

जैसे

In [1]: f00 = lambda x: x/2

In [2]: f00(10)
Out[2]: 5.0

In [3]: (lambda x: x/2)(10)
Out[3]: 5.0

In [4]: (lambda x, y: x / y)(10, 2)
Out[4]: 5.0

In [5]: (lambda: 'amazing lambda')() # func with no args!
Out[5]: 'amazing lambda'

2. keyतर्क के पीछे का विचार यह है कि इसे निर्देशों के एक सेट में लिया जाना चाहिए जो अनिवार्य रूप से उन सूची तत्वों पर 'सॉर्ट किए गए ()' फ़ंक्शन को इंगित करेगा, जिन्हें क्रमबद्ध करना चाहिए। जब यह कहता है key=, इसका वास्तव में मतलब क्या है: जैसा कि मैं सूची के माध्यम से एक समय में एक तत्व (यानी सूची में ई के लिए) के माध्यम से पुनरावृत्ति करता हूं, मैं वर्तमान तत्व को उस फ़ंक्शन को पास करने जा रहा हूं जो मैं मुख्य तर्क में प्रदान करता हूं और उसका उपयोग करता हूं एक रूपांतरित सूची बनाने के लिए जो मुझे अंतिम क्रमबद्ध सूची के आदेश पर सूचित करेगी।

इसकी जांच - पड़ताल करें:

mylist = [3,6,3,2,4,8,23]
sorted(mylist, key=WhatToSortBy)

आधार उदाहरण:

sorted(mylist)

[२, ३, ३, ४, ६, 3, २३] # सभी संख्याएँ छोटे से बड़े क्रम में होती हैं।

उदाहरण 1:

mylist = [3,6,3,2,4,8,23]
sorted(mylist, key=lambda x: x%2==0)

[३, ३, २३, ६, २, ४, Does] # क्या यह क्रमबद्ध परिणाम आपके लिए सहज ज्ञान युक्त है?

ध्यान दें कि मेरे लैंबडा फंक्शन ने यह जांचने के लिए सॉर्ट किया कि क्या (ई) सॉर्ट करने से पहले या विषम था।

लेकिन रुकें! आप (या शायद) को दो चीजों पर आश्चर्य हो रहा होगा - पहला, मेरी बुराइयों से पहले मेरी मुश्किलें क्यों आ रही हैं (क्योंकि मेरा मुख्य मूल्य लगता है कि मेरे सॉर्ट किए गए कार्य को प्राथमिकता देने के लिए मॉड ऑपरेटर का उपयोग करके अपनी प्राथमिकताएं बता रहा है x%2==0)। दूसरा, मेरी बुरें आर्डर से बाहर क्यों हैं? 2 6 अधिकार से पहले आता है? इस परिणाम का विश्लेषण करके, हम इस बारे में कुछ गहराई से जानेंगे कि छांटे गए () 'कुंजी' तर्क कैसे काम करते हैं, विशेष रूप से अनाम लंबो फ़ंक्शन के साथ।

सबसे पहले, आप ध्यान देंगे कि जब बुराइयों के सामने आने वाले, खुद को हल नहीं किया जाता है। ऐसा क्यों है?? डॉक्स पढ़ने दें :

मुख्य कार्य पायथन 2.4 के साथ शुरू होते हैं, दोनों list.sort () और सॉर्ट किए गए () ने फ़ंक्शन को तुलना करने से पहले प्रत्येक सूची तत्व पर कॉल करने के लिए एक फ़ंक्शन निर्दिष्ट करने के लिए एक प्रमुख पैरामीटर जोड़ा।

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

तो एक modulo रिटर्न का उपयोग करके क्या उदाहरण है? एक बूलियन मान: True == 1, False == 0। तो इस कुंजी के साथ हल कैसे किया जाता है? यह मूल रूप से मूल सूची को 1s और 0s के अनुक्रम में बदल देता है।

[3,6,3,2,4,8,23] [0,1,0,1,1,1,0] बन जाता है

अब हम कहीं जा रहे हैं। जब आप रूपांतरित सूची को क्रमबद्ध करते हैं तो आपको क्या मिलता है?

[0,0,0,1,1,1,1]

ठीक है, तो अब हम जानते हैं कि बुराइयों के सामने आने की संभावना क्यों है। लेकिन अगला सवाल यह है कि मेरी अंतिम सूची में 6 अभी भी 2 से पहले क्यों आता है? वैसे यह आसान है - क्योंकि इसकी छंटाई केवल एक बार होती है! यानी वे 1s अभी भी मूल सूची मूल्यों का प्रतिनिधित्व करते हैं, जो एक दूसरे के सापेक्ष अपने मूल पदों पर हैं। चूंकि सॉर्टिंग केवल एक बार होती है, और हम किसी भी प्रकार के फ़ंक्शन को कॉल नहीं करते हैं, ताकि मूल मान भी निम्न से उच्चतर मान सकें, वे मान एक दूसरे के सापेक्ष अपने मूल क्रम में बने रहते हैं।

अंतिम प्रश्न यह है: मैं इस बारे में वैचारिक रूप से कैसे सोचता हूं कि जब मैं अंतिम क्रमबद्ध सूची का प्रिंट आउट करता हूं तो मेरे बूलियन मूल्यों का क्रम मूल मूल्यों में कैसे बदल जाता है?

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

तो यह सब कैसे मूल प्रश्न से संबंधित है, और इससे भी महत्वपूर्ण बात यह है कि हम अपने प्रमुख तर्क और लंबोदर के साथ क्रमबद्ध () को कैसे लागू करें?

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

निम्न कोड चलाने पर क्या होता है, इसकी कोशिश करें और भविष्यवाणी करें।

mylist = [(3, 5, 8), (6, 2, 8), ( 2, 9, 4), (6, 8, 5)]
sorted(mylist, key=lambda x: x[1])

मेरा sortedकॉल स्पष्ट रूप से कहता है, "कृपया इस सूची को क्रमबद्ध करें"। मुख्य तर्क यह कहता है कि mylist में प्रत्येक तत्व (x) के लिए, उस तत्व के रिटर्न इंडेक्स 1 के लिए कहकर थोड़ा अधिक विशिष्ट है , फिर मूल सूची के सभी तत्वों को 'mylist' द्वारा क्रमबद्ध सूची की क्रमबद्ध संख्या से क्रमबद्ध करें। मेमने का कार्य। चूंकि हमारे पास ट्यूपल्स की एक सूची है, हम उस ट्यूपल से एक अनुक्रमित तत्व वापस कर सकते हैं। तो हमें मिलता है:

[(6, 2, 8), (3, 5, 8), (6, 8, 5), (2, 9, 4)]

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

यह एक लंबी घुमावदार व्याख्या थी, लेकिन मुझे आशा है कि यह लैंबडा कार्यों के उपयोग पर आपके अंतर्ज्ञान को हल करने में महत्वपूर्ण तर्क के रूप में 'सॉर्ट' करने में मदद करता है।

Comments

उत्कृष्ट और व्यापक व्याख्या। यह उत्तर 100 अंकों का हकदार है। लेकिन मुझे आश्चर्य है कि इस उत्तर के लिए पसंद कम क्यों हैं।

— जावेद

गहरी व्याख्या के लिए धन्यवाद। मैं डॉक्स पढ़ता हूं और कैसे-कैसे छांटता हूं और यह keyकार्य के पीछे का विचार मेरे लिए स्पष्ट नहीं था । यदि आप sortedफ़ंक्शन को समझने की कोशिश कर रहे हैं , तो उन्हें lambdaसिंटैक्स केवल समझने के तरीके में हो जाता है।

— अभयारण्य

यह यहाँ का सबसे अच्छा विवरण है। यह मुझे यह समझने में मदद करने में वास्तव में उपयोगी था कि यह वास्तव में कैसे काम करता है - मैंने सॉर्टा ने लैम्ब्डा फ़ंक्शन को पकड़ लिया, लेकिन सॉर्ट किए गए () के संदर्भ में इसका उपयोग करने का कोई मतलब नहीं था। यह वास्तव में मदद की, धन्यवाद!

— TGWaffles

यह एक शानदार जवाब है। आपको प्रणाम सर।

— राजेश मप्पू

स्टैक ओवरफ्लो पर यह मेरे पसंदीदा उत्तरों में से एक है। धन्यवाद!

— एडीआर

Answer 3

lambdaएक पायथन कीवर्ड है जिसका उपयोग अनाम कार्यों को उत्पन्न करने के लिए किया जाता है ।

>>> (lambda x: x+2)(3)
5

Comments

प्रत्येक के चारों ओर कोष्ठक क्यों हैं?

— क्रिस्टोफर मार्किटा

Parens आसपास हैं 3क्योंकि यह एक फ़ंक्शन के लिए पारित किया जा रहा है। लंबन लैम्ब्डा के आसपास हैं, ताकि अभिव्यक्ति के रूप में पार्स नहीं किया गया है lambda x: x+2(3), जो कि 2एक फ़ंक्शन नहीं होने के बाद से अमान्य है।

— इग्नासियो वाज़क्वेज़-अब्राम्स

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

— user5179531

Answer 4

variableके बाईं :एक पैरामीटर नाम है। के उपयोग के variableअधिकार पर पैरामीटर का इस्तेमाल कर रही है।

इसका मतलब लगभग बिल्कुल वैसा ही है:

def some_method(variable):
  return variable[0]

Answer 5

उपयोग का एक और उदाहरण क्रमबद्ध () कुंजी = लैम्ब्डा के साथ कार्य करता है। आइए विचार करें कि आपके पास ट्यूपल्स की सूची है। प्रत्येक टुपल में आपके पास कार का एक ब्रांड, मॉडल और वजन होता है और आप ब्रांड, मॉडल या वजन द्वारा ट्यूपल्स की इस सूची को क्रमबद्ध करना चाहते हैं। आप इसे लंबोदर के साथ कर सकते हैं।

cars = [('citroen', 'xsara', 1100), ('lincoln', 'navigator', 2000), ('bmw', 'x5', 1700)]

print(sorted(cars, key=lambda car: car[0]))
print(sorted(cars, key=lambda car: car[1]))
print(sorted(cars, key=lambda car: car[2]))

परिणाम:

[('bmw', 'x5', '1700'), ('citroen', 'xsara', 1100), ('lincoln', 'navigator', 2000)]
[('lincoln', 'navigator', 2000), ('bmw', 'x5', '1700'), ('citroen', 'xsara', 1100)]
[('citroen', 'xsara', 1100), ('bmw', 'x5', 1700), ('lincoln', 'navigator', 2000)]

Answer 6

lambdaएक अनाम फ़ंक्शन है, एक मनमाना फ़ंक्शन नहीं है। स्वीकार किया जा रहा पैरामीटर वह चर होगा जिसके साथ आप काम कर रहे हैं, और वह कॉलम जिसमें आप इसे छांट रहे हैं।

Answer 7

चूँकि लैम्ब्डा के उपयोग के संदर्भ में पूछा गया था sorted(), इसलिए इस पर एक नज़र डालें https://wiki.python.org/moin/HowTo/Sorting/#Key_Functions

Answer 8

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

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

यदि आप कई गुणों को क्रमबद्ध करना चाहते हैं तो कुंजी = लैम्ब्डा x: (property1, property2) असाइन करें।

ऑर्डर-बाय निर्दिष्ट करने के लिए, तीसरे तर्क (वैकल्पिक। एक बूलियन के रूप में रिवर्स = सत्य पास करें। गलत तरीके से आरोही छँटेगा, सही क्रम में अवरोही क्रमबद्ध होगा। डिफ़ॉल्ट सॉर्ट किए गए फ़ंक्शन का है)।

Answer 9

पूछे जाने वाले प्रश्न के लिए एक उदाहरण के साथ सरल और समय लेने वाला उत्तर इस उदाहरण का पालन करें:

 user = [{"name": "Dough", "age": 55}, 
            {"name": "Ben", "age": 44}, 
            {"name": "Citrus", "age": 33},
            {"name": "Abdullah", "age":22},
            ]
    print(sorted(user, key=lambda el: el["name"]))
    print(sorted(user, key= lambda y: y["age"]))

सूची में नाम देखें, वे डी, बी, सी और ए के साथ शुरू करते हैं और यदि आप उम्र को देखते हैं, तो वे 55, 44, 33 और 22 हैं। पहला प्रिंट कोड

print(sorted(user, key=lambda el: el["name"]))

परिणाम:

[{'name': 'Abdullah', 'age': 22}, 
{'name': 'Ben', 'age': 44}, 
{'name': 'Citrus', 'age': 33}, 
{'name': 'Dough', 'age': 55}]

नाम को क्रमबद्ध करें, क्योंकि कुंजी = लंबो अल: एल ["नाम"] हम नामों को छांट रहे हैं और नाम वर्णानुक्रम में वापस आते हैं।

दूसरा प्रिंट कोड

print(sorted(user, key= lambda y: y["age"]))

परिणाम:

[{'name': 'Abdullah', 'age': 22},
 {'name': 'Citrus', 'age': 33},
 {'name': 'Ben', 'age': 44}, 
 {'name': 'Dough', 'age': 55}]

उम्र के अनुसार क्रमबद्ध करें, और इसलिए सूची उम्र के क्रम पर वापस आती है।

बेहतर समझ के लिए इस कोड को आज़माएं।