अजगर अधिकतम फ़ंक्शन 'की' और लैम्ब्डा एक्सप्रेशन का उपयोग करता है

Question

मैं ओओपी पृष्ठभूमि से आता हूं और अजगर को सीखने की कोशिश कर रहा हूं। मैं maxफ़ंक्शन का उपयोग कर रहा हूं जो सूची में Playerअधिकतम प्रकार के उदाहरण को वापस करने के लिए एक लंबोदर अभिव्यक्ति का उपयोग करता है ।totalScoreplayers

def winner():
    w = max(players, key=lambda p: p.totalScore)

फ़ंक्शन सही प्रकार Playerसे अधिकतम होने का उदाहरण देता है totalScore। मैं निम्नलिखित तीन चीजों के बारे में उलझन में हूं:

1. maxकार्य कैसे करता है ? इसके लिए क्या तर्क दिए जा रहे हैं? मैंने प्रलेखन को देखा, लेकिन समझने में विफल रहा।
2. keyअधिकतम फ़ंक्शन में कीवर्ड का उपयोग क्या है ? मुझे पता है कि यह sortफ़ंक्शन के संदर्भ में भी उपयोग किया जाता है
3. लंबोदर अभिव्यक्ति का अर्थ? उन्हें कैसे पढ़ा जाए? वो कैसे काम करते है?

ये सभी बहुत ही वैचारिक प्रश्न हैं, लेकिन मुझे भाषा को समझने में मदद करेंगे। अगर आप समझाने के लिए उदाहरण दे सकते हैं तो यह मदद करेगा। धन्यवाद

Comments

कौन सा पायथन संस्करण?

— चार्मलेसकॉइन

क्या आपने प्रलेखन से परामर्श किया है ?

— इबर रोज

@charmlessCoin python 2.7.5

— विजय

@ InbarRose मैंने अधिकतम फ़ंक्शन के लिए दस्तावेज़ की जाँच की। वास्तव में यह समझ में नहीं आया।

— विजय

@InbarRose यह पृष्ठ वास्तव में अब Google के लिए शीर्ष परिणाम है python max lambdaऔर शायद नए उपयोगकर्ताओं के लिए वास्तव में अधिक उपयोगी हो सकता है।

— मार्क

Answer 1

lambda एक अनाम फ़ंक्शन है, यह इसके बराबर है:

def func(p):
   return p.totalScore     

अब maxबन जाता है:

max(players, key=func)

लेकिन defकथनों के रूप में वे कथनों का उपयोग किया जाता है, जहां अभिव्यक्ति की आवश्यकता होती है, इसलिए कभी-कभी उनका उपयोग lambdaकिया जाता है।

ध्यान दें कि lambdaआप एक रिटर्न स्टेटमेंट में क्या डालते हैं, उसके बराबर है def। इस प्रकार, आप क के अंदर कथनों का उपयोग नहीं कर सकते lambda, केवल अभिव्यक्ति की अनुमति है।

---

क्या करता maxहै?

अधिकतम (ए, बी, सी, ... [, कुंजी = दुर्गंध) -> मूल्य

एक एकल पुनरावृत्त तर्क के साथ, इसकी सबसे बड़ी वस्तु लौटाते हैं। दो या अधिक तर्कों के साथ, सबसे बड़ा तर्क लौटाएं।

तो, यह केवल उस वस्तु को वापस करता है जो सबसे बड़ी है।

---

कैसे keyकाम करता है ?

पायथन 2 में डिफ़ॉल्ट रूप से वस्तुओं के प्रकार के आधार पर नियमों केkey एक सेट के आधार पर वस्तुओं की तुलना करता है (उदाहरण के लिए एक स्ट्रिंग हमेशा एक पूर्णांक से अधिक होता है)।

तुलना करने से पहले वस्तु को संशोधित करने के लिए, या किसी विशेष विशेषता / सूचकांक के आधार पर तुलना करने के लिए, आपको keyतर्क का उपयोग करना होगा ।

उदाहरण 1:

एक सरल उदाहरण, मान लीजिए कि आपके पास स्ट्रिंग रूप में संख्याओं की एक सूची है, लेकिन आप उन वस्तुओं की उनके पूर्णांक मान से तुलना करना चाहते हैं।

>>> lis = ['1', '100', '111', '2']

यहां maxउनके मूल मूल्यों का उपयोग करके आइटम की तुलना की जाती है (स्ट्रिंग्स की तुलना लेक्सिकोग्राफिक रूप से की जाती है ताकि आपको '2'आउटपुट के रूप में मिलें):

>>> max(lis)
'2'

keyएक साधारण के साथ उनके पूर्णांक मूल्य के उपयोग द्वारा वस्तुओं की तुलना करने के लिए lambda:

>>> max(lis, key=lambda x:int(x))  # compare `int` version of each item
'111'

उदाहरण 2: maxट्यूपल्स की सूची पर लागू करना।

>>> lis = [(1,'a'), (3,'c'), (4,'e'), (-1,'z')]

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

>>> max(lis)
(4, 'e')

लेकिन, क्या होगा यदि आप इंडेक्स 1 के मूल्य से प्रत्येक आइटम की तुलना करना चाहते हैं? सरल: उपयोग lambda:

>>> max(lis, key = lambda x: x[1])
(-1, 'z')

---

विभिन्न प्रकार की वस्तुओं वाले पुनरावृत्तियों में वस्तुओं की तुलना करना :

मिश्रित वस्तुओं के साथ सूची:

lis = ['1','100','111','2', 2, 2.57]

पायथन 2 में दो अलग-अलग प्रकार की वस्तुओं की तुलना करना संभव है :

>>> max(lis)  # works in Python 2
'2'
>>> max(lis, key=lambda x: int(x))  # compare integer version of each item
'111'

लेकिन पायथन 3 में आप ऐसा नहीं कर सकते :

>>> lis = ['1', '100', '111', '2', 2, 2.57]
>>> max(lis)
Traceback (most recent call last):
  File "<ipython-input-2-0ce0a02693e4>", line 1, in <module>
    max(lis)
TypeError: unorderable types: int() > str()

लेकिन यह काम करता है, क्योंकि हम प्रत्येक वस्तु के पूर्णांक संस्करण की तुलना कर रहे हैं:

>>> max(lis, key=lambda x: int(x))  # or simply `max(lis, key=int)`
'111'

Comments

मुझे लगता है कि यह पुराना है, लेकिन मुझे इस संबंध में एक सवाल था। मैं लैम्बडा फ़ंक्शन के लिए देखता हूं, चर x या i या कुछ और हमेशा सूची में उस इंडेक्स पर मूल्य का प्रतिनिधित्व करता है। क्या यह पुनरावृत्ति अधिकतम कार्य द्वारा या लंबोदर द्वारा की गई है? क्या लैम्ब्डा फ़ंक्शन हमेशा संभावित मूल्यों पर पुनरावृति करता है? उदाहरण के लिए: lengths = map(lambda word: len(word), words)जहां words=['It', 'is', 'raining', 'cats', 'and', 'dogs']मैं देखता हूं कि सूची में हर शब्द के ऊपर लंबोदर की अधिकता है। क्या यह हमेशा ऐसा करता है?

— Mo2

@ Mo2 Iteration maxनहीं lambda( keyarg वैकल्पिक है) द्वारा किया जाता है , और पुनरावृत्ति के दौरान प्रत्येक आइटम को निर्दिष्ट फ़ंक्शन में पास keyकिया जाता है और उसके बाद दिए गए मान का उपयोग तुलना के लिए किया जाता है।

— अश्विनी चौधरी

बस उन लोगों के लिए जो "अधिकतम प्रमुख पैरामीटर" को गुगली करके यहां आए थे। max(lis, key=lambda x:int(x))के रूप में सरल किया जा सकता है max(lis, key=int)। पायथन में एक अंतर्निहित फ़ंक्शन, इंट () है। इसी तरह आप किसी अन्य अंतर्निहित कार्यों को keyतर्क के रूप में उपयोग कर सकते हैं । उदाहरण के लिए आप सबसे लंबे समय तक स्ट्रिंग से प्राप्त कर सकते हैं lis=['a', 'aa', 'aaa']द्वाराmax(lis, key=len)

— युवा

@YOUNG हम प्रमुख तर्क कार्यों निर्मित नहीं बस के रूप में किसी भी समारोह का उपयोग कर सकते, केवल इस शर्त पर कि समारोह से इसे करने के लिए पारित कर दिया आइटम को स्वीकार करना चाहिए है max, min, sortedआदि ठीक से। साथ ही मैंने max(lis, key=int)अंत में सही उल्लेख किया है । :-)

— अश्विनी चौधरी

@ अश्विनी चौधरी .. मान लीजिए अगर मेरे पास [1,2,3,4,5] जैसी सूची है। यहाँ सभी आइटम अलग हैं। मैं दिए गए फंक्शन मैक्स (सेट (mylist), की = mylist.count) का उपयोग कर रहा हूं ताकि बार-बार मिलने वाली वस्तुओं को खोजा जा सके। चूंकि इस मामले में कोई तत्व नहीं है जो दोहरा रहा है। यह सबसे कम आइटम वापस कर रहा है। क्या हम कुछ ऐसा कर सकते हैं जिससे यह शून्य या शून्य हो जाए।

— विक्रांत राणा

Answer 2

इसका अत्यधिक सरल संस्करण max:

def max(items, key=lambda x: x):
    current = item[0]
    for item in items:
        if key(item) > key(current):
            current = item
    return current

लंबोदर के बारे में:

>>> ident = lambda x: x
>>> ident(3)
3
>>> ident(5)
5

>>> times_two = lambda x: 2*x
>>> times_two(2)
4

Answer 3

अधिकतम फ़ंक्शन कैसे काम करता है?

यह एक पुनरावृत्त में "सबसे बड़ी" आइटम की तलाश करता है। मुझे लगता है कि आप देख सकते हैं कि क्या है, लेकिन यदि नहीं, तो यह कुछ ऐसा है जिस पर आप सूची या स्ट्रिंग बना सकते हैं।

अधिकतम फ़ंक्शन में कीवर्ड कुंजी का उपयोग क्या है? मुझे पता है कि इसका उपयोग सॉर्ट फ़ंक्शन के संदर्भ में भी किया जाता है

Keyएक लंबोदर फ़ंक्शन है जो यह बताएगा कि maxचलने योग्य में कौन सी वस्तुएँ दूसरों की तुलना में बड़ी हैं। यह कहें कि क्या आप किसी ऐसी वस्तु को छांट रहे हैं, जिसे आपने खुद बनाया है, और कुछ स्पष्ट नहीं है, जैसे पूर्णांक।

लंबोदर अभिव्यक्ति का अर्थ? उन्हें कैसे पढ़ा जाए? वो कैसे काम करते है?

यह एक बड़ा सवाल है। सरल शब्दों में, एक मेमना एक ऐसा कार्य है जिसे आप चारों ओर से गुजर सकते हैं , और कोड के अन्य टुकड़े इसका उपयोग करते हैं। उदाहरण के लिए इसे लें:

def sum(a, b, f):
    return (f(a) + f(b))

यह दो ऑब्जेक्ट्स, aऔर b, और एक फंक्शन लेता है f। यह f()प्रत्येक ऑब्जेक्ट पर कॉल करता है, फिर उन्हें एक साथ जोड़ता है। तो इस कॉल को देखें:

>>> sum(2, 2, lambda a:  a * 2)
8

sum()उस 2पर लैंबडा एक्सप्रेशन लेता है और कॉल करता है। तो f(a)बन जाता है 2 * 2, जो 4 हो जाता है। यह इसके लिए ऐसा करता है b, और दोनों को एक साथ जोड़ता है।

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

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

Answer 4

maxफ़ंक्शन का उपयोग अधिकतम प्राप्त करने के लिए किया जाता है iterable।

पुनरावृत्तियां सूची, टुपल्स, तानाशाह वस्तुएं आदि हो सकती हैं या यहां तक ​​कि आपके द्वारा दिए गए उदाहरण में भी कस्टम ऑब्जेक्ट्स।

max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value

With a single iterable argument, return its largest item.
With two or more arguments, return the largest argument.

तो, key=funcमूल रूप से हमें keyफ़ंक्शन के लिए एक वैकल्पिक तर्क पास करने की अनुमति देता है जिसके आधार पर दिए गए पुनरावृत्ति / तर्क को क्रमबद्ध किया जाता है और अधिकतम वापस कर दिया जाता है।

lambdaएक पायथन कीवर्ड है जो एक छद्म फ़ंक्शन के रूप में कार्य करता है। इसलिए, जब आप playerइसे पास करते हैं, तो यह वापस आ जाएगा player.totalScore। इस प्रकार, कार्य करने के लिए पारित maxकिया जाने वाला key चलने योग्यplayer वस्तुओं के कुल स्कोर के अनुसार क्रमबद्ध हो जाएगा और playerजो अधिकतम होगा उसे वापस कर देगा totalScore।

यदि कोई keyतर्क प्रदान नहीं किया जाता है, तो अधिकतम को डिफ़ॉल्ट पायथन आदेशों के अनुसार लौटा दिया जाता है।

उदाहरण -

max(1, 3, 5, 7)
>>>7
max([1, 3, 5, 7])
>>>7

people = [('Barack', 'Obama'), ('Oprah', 'Winfrey'), ('Mahatma', 'Gandhi')]
max(people, key=lambda x: x[1])
>>>('Oprah', 'Winfrey')

Answer 5

प्रलेखन के अनुसार :

max (iterable [, key])
max (arg1, arg2, * args [, key])
सबसे बड़ी वस्तु को एक चलने योग्य या दो या अधिक तर्कों में सबसे बड़ा लौटाएं।

यदि एक स्थितीय तर्क प्रदान किया जाता है, तो पुनरावृत्त एक गैर-रिक्त चलने योग्य होना चाहिए (जैसे कि एक गैर-रिक्त स्ट्रिंग, टपल या सूची)। पुनरावृत्ति में सबसे बड़ी वस्तु वापस आ गई है। यदि दो या अधिक स्थितिगत तर्क प्रदान किए जाते हैं, तो स्थितिगत तर्कों में से सबसे बड़ा वापस आ जाता है।

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

यह क्या कह रहा है कि आपके मामले में, आप इस मामले में एक सूची प्रदान कर रहे हैं players। फिर maxफ़ंक्शन सूची में सभी वस्तुओं पर पुनरावृति करेगा और "अधिकतम" प्राप्त करने के लिए उनकी एक-दूसरे से तुलना करेगा।

जैसा कि आप कल्पना कर सकते हैं, playerतुलना के लिए इसके मूल्य का निर्धारण करने जैसी जटिल वस्तु के साथ मुश्किल है, इसलिए आपको keyयह निर्धारित करने के लिए तर्क दिया जाता है कि maxफ़ंक्शन प्रत्येक के मूल्य को कैसे तय करेगा player। इस मामले में, आप एक लैंबडा फ़ंक्शन का उपयोग करने के लिए कह रहे हैं "प्रत्येक pको playersपाने के लिए p.totalscoreऔर तुलना के लिए उसके मूल्य के रूप में उपयोग करें"।

Answer 6

maxफ़ंक्शन में बनाया गया है जो पहले तर्क लेता है iterable(जैसे सूची या टपल)

कीवर्ड तर्क keyमें इसका डिफ़ॉल्ट मूल्य है, Noneलेकिन यह फ़ंक्शन को मूल्यांकन करने के लिए स्वीकार करता है, इसे आवरण के रूप में मानें जो फ़ंक्शन के आधार पर चलने योग्य का मूल्यांकन करता है

इस उदाहरण शब्दकोश पर विचार करें:

d = {'aim':99, 'aid': 45, 'axe': 59, 'big': 9, 'short': 995, 'sin':12, 'sword':1, 'friend':1000, 'artwork':23}

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

>>> max(d.keys())
'sword'

जैसा कि आप देख सकते हैं कि क्या आप केवल kwarg (एक फ़ंक्शन key) के बिना चलने वाले को पास करते हैं, तो यह कुंजी का अधिकतम मान लौटा रहा है (वर्णमाला)

पूर्व। मुख्य वर्णमाला का अधिकतम मूल्य खोजने के बजाय आपको कुंजी की लंबाई से अधिकतम कुंजी खोजने की आवश्यकता हो सकती है:

>>>max(d.keys(), key=lambda x: len(x))
'artwork'

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

पूर्व।

>>> max(d.keys(), key=lambda x: d[x])
'friend'

इस उदाहरण में लैम्बडा फ़ंक्शन संबंधित शब्दकोश कुंजी का मान लौटा रहा है जिसका अधिकतम मूल्य है