विधि अजगर

Question

में चेनिंग (itertools.chain साथ भ्रमित होने की नहीं)

मैं निम्नलिखित पढ़ रहा था: http://en.wikipedia.org/wiki/Method_chaining

मेरा प्रश्न है: अजगर में विधि श्रृंखलन लागू करने के लिए सबसे अच्छा तरीका क्या है? यदि बुला method(*args)self.o को संशोधित करता है लेकिन None वापस नहीं करता है

class chain(): 
    def __init__(self, my_object): 
     self.o = my_object 

    def __getattr__(self, attr): 
     x = getattr(self.o, attr) 
     if hasattr(x, '__call__'): 
      method = x 
      return lambda *args: self if method(*args) is None else method(*args) 
     else: 
      prop = x 
      return prop 

list_ = chain([1, 2, 3, 0]) 
print list_.extend([9, 5]).sort().reverse() 

""" 
C:\Python27\python.exe C:/Users/Robert/PycharmProjects/contests/sof.py 
[9, 5, 3, 2, 1, 0] 
""" 

एक समस्या है:

यहाँ मेरी प्रयास है। (तो मुझे self वापस करना चाहिए या method(*args) रिटर्न वापस करना चाहिए)।

क्या किसी के पास चेनिंग लागू करने के बेहतर तरीके हैं? ऐसा करने के लिए शायद कई तरीके हैं।

क्या मुझे लगता है कि एक विधि हमेशा None लौटाती है तो मैं हमेशा self.o वापस कर सकता हूं?

Answer 1

एक बहुत ही रोचक Pipe लाइब्रेरी है जो आपके प्रश्न का उत्तर हो सकती है। उदाहरण :: के लिए

seq = fib() | take_while(lambda x: x < 1000000) \ 
      | where(lambda x: x % 2) \ 
      | select(lambda x: x * x) \ 
      | sum() 

Answer 2

किसी ऑब्जेक्ट की किसी भी विधि को जंजीर करने की इजाजत देने का कोई सामान्य तरीका नहीं होने वाला है, क्योंकि आप नहीं जानते कि विधि किस तरह का मूल्य लौटाती है और क्यों नहीं कि यह विशेष विधि कैसे काम करती है। किसी भी कारण से None वापस कर सकते हैं; इसका मतलब यह नहीं है कि विधि ने वस्तु को संशोधित किया है। इसी तरह, वे विधियां जो एक मूल्य वापस करती हैं, वे अभी भी एक मूल्य वापस नहीं कर सकते हैं जिसे जंजीर बनाया जा सकता है। list.index: fakeList.index(1).sort() जैसी विधि को श्रृंखलाबद्ध करने का कोई तरीका नहीं है, काम करने की अधिक उम्मीद नहीं हो सकती है, क्योंकि index का पूरा बिंदु यह एक संख्या देता है, और उस संख्या का मतलब कुछ है, और मूल पर श्रृंखला के लिए अनदेखा नहीं किया जा सकता वस्तु।

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

Answer 3

यह इतना है कि तरीकों self.data सीधे संशोधित नहीं है, लेकिन बजाय संशोधित संस्करण वापसी अगर आप केवल pure functions का उपयोग संभव है। आपको Chainable उदाहरण वापस लौटना होगा।

यहाँ सूचियों के साथ collection pipelining का उपयोग कर एक उदाहरण है:

import itertools 

try: 
    import builtins 
except ImportError: 
    import __builtin__ as builtins 


class Chainable(object): 
    def __init__(self, data, method=None): 
     self.data = data 
     self.method = method 

    def __getattr__(self, name): 
     try: 
      method = getattr(self.data, name) 
     except AttributeError: 
      try: 
       method = getattr(builtins, name) 
      except AttributeError: 
       method = getattr(itertools, name) 

     return Chainable(self.data, method) 

    def __call__(self, *args, **kwargs): 
     try: 
      return Chainable(list(self.method(self.data, *args, **kwargs))) 
     except TypeError: 
      return Chainable(list(self.method(args[0], self.data, **kwargs))) 

इस तरह यह प्रयोग करें:

chainable_list = Chainable([3, 1, 2, 0]) 
(chainable_list 
    .chain([11,8,6,7,9,4,5]) 
    .sorted() 
    .reversed() 
    .ifilter(lambda x: x%2) 
    .islice(3) 
    .data) 
>> [11, 9, 7] 

ध्यान दें कि .chainitertools.chain को संदर्भित करता है और न ओपी के chain।