पायथन, लैम्ब्डा, न्यूनतम

Question

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

---

मैं इस तरह मेरी foreach समारोह का उपयोग करें:

o.foreach(lambda i: i.call()) 

या

o.foreach(I.call) 

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

मैं एक वर्ग है कि लगता है कि लिखने के लिए प्रबंधन, लेकिन उस की तुलना में कुछ बेहतर समाधान होना चाहिए:

class Min:           
    def __init__(self,i):       
     self.i = i        
    def get_min(self):        
     return self.i         
    def set_val(self,o):        
     if o.val < self.i: self.i = o.val 

m = Min(xmin) 
self.foreach(m.set_val)        
xmin = m.get_min() 

---

ठीक है, तो मुझे लगता है कि मेरी .foreach पद्धति गैर अजगर विचार है। मुझे अपनी कक्षा को पुन: प्रयोज्य करना चाहिए क्योंकि आपके सभी समाधान सूचियों पर आधारित हैं और फिर सबकुछ आसान हो जाएगा।

सी # में लैम्ब्डा फ़ंक्शन के साथ कोई समस्या नहीं होगी, इसलिए मैं उस पाइथन भी शक्तिशाली हूं।

Answer 1

foreach लेखन विधि बहुत pythonic नहीं है। आपको बेहतर इसे एक इटरेटर बनाना चाहिए ताकि यह min जैसे मानक पायथन कार्यों के साथ काम करे।

इसके बजाय कुछ इस तरह लिखने की

:

def foreach(self, f): 
    for d in self._data: 
     f(d) 

लिखने इस:

def __iter__(self): 
    for d in self._data: 
     yield d 

अब आप min(myobj) रूप min कॉल कर सकते हैं।

Answer 2

पायथन अंतर्निहित support for finding minimums:

>>> min([1, 2, 3]) 
1 

आप पहली बार एक समारोह के साथ सूची की प्रक्रिया पूरी की हैं, तो आप ऐसा कर सकते हैं map साथ:

>>> def double(x): 
... return x * 2 
... 
>>> min(map(double, [1, 2, 3])) 
2 

या आप के साथ फैंसी प्राप्त कर सकते हैं list comprehensions और generator expressions, उदाहरण के लिए:

>>> min(double(x) for x in [1, 2, 3]) 
2 

Answer 3

ठीक है, एक बात आपको समझने की जरूरत है: lambda आपके लिए एक फ़ंक्शन ऑब्जेक्ट बनाता है। लेकिन सादा, सामान्य def करता है। इस उदाहरण को देखें:

lst = range(10) 

print filter(lambda x: x % 2 == 0, lst) 

def is_even(x): 
    return x % 2 == 0 

print filter(is_even, lst) 

इन दोनों कार्य। वे एक ही समान परिणाम उत्पन्न करते हैं। lambda एक गैर-नामित फ़ंक्शन ऑब्जेक्ट बनाता है; def एक नामित फ़ंक्शन ऑब्जेक्ट बनाता है। filter() परवाह नहीं है कि फ़ंक्शन ऑब्जेक्ट का नाम है या नहीं।

तो, अगर lambda के साथ अपने ही समस्या यह है कि आप एक lambda में = उपयोग नहीं कर सकते है, तो आप सिर्फ एक समारोह def का उपयोग कर बना सकते हैं।

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

lst = range(10) 
print min(lst) 

संपादित करें: मैं मानता हूं कि स्वीकार किया गया उत्तर बेहतर है। मूल्यों की सूची लौटने की बजाय, __iter__() को परिभाषित करना और ऑब्जेक्ट को पुन: प्रयोज्य बनाना बेहतर है।

Answer 4

मान लीजिए आप कम से कम न्यूनतम

>>> min(seq, key=f) 
0 

निश्चित रूप से आप लैम्ब्डा भी उपयोग कर सकते हैं

पर एक्स का मान के लिए च

>>> min(f(x) for x in seq) 
-2 

के मूल्य के लिए

>>> seq = range(-4,4) 
>>> def f(x): 
... return x*x-2 

है

>>> min((lambda x:x*x-2)(x) for x in range(-4,4)) 
-2 

लेकिन यह है कि एक छोटे से बदसूरत, नक्शा यहाँ बेहतर लग रहा है है

>>> min(map(lambda x:x*x-2, seq)) 
-2 

>>> min(seq,key=lambda x:x*x-2) 
0 

Answer 5

मैं foreach समारोह जो हर तत्व है जो यह

ऐसा लगता है शामिल हैं पर निर्दिष्ट फ़ंक्शन को कॉल करने, टिप्पणी से है आपने बाद में पोस्ट किया, कि आपने अंतर्निहित map फ़ंक्शन का पुन: आविष्कार किया है।

ऐसा लगता है आप कुछ इस तरह की तलाश कर रहे हैं:

min(map(f, seq)) 

जहां f समारोह है कि आप सूची में हर आइटम पर कॉल करना चाहते है। ...

min(seq, key=f) 

जब तक आप सभी की लगाना चाहते हैं:

gnibbler पता चलता है, अगर आप अनुक्रम जिसके लिए f(x) रिटर्न सबसे कम मूल्य में मूल्य x खोजना चाहते हैं, तो आप उपयोग कर सकते हैं seq में आइटम जिसके लिए f सबसे कम मूल्य देता है। उदाहरण के लिए, यदि seq शब्दकोशों की एक सूची,

min(seq, key=len) 

आइटम, सभी शब्दकोशों कि आइटम की संख्या को शामिल नहीं की सबसे छोटी संख्या के साथ सूची में पहले शब्दकोश वापस आ जाएगी है।

values = map(f, seq) 
result = [seq[i] for (i, v) in enumerate(values) if v == min(values)] 

Answer 6

आप foreach और एक लैम्ब्डा के साथ ऐसा नहीं कर सकते:

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

l = [5,2,6,7,9,8] 
reduce(lambda a,b: a if a < b else b, l[1:], l[0])