फ़ंक्शन कैसे जोड़ें

Question

मैंने पूरी तरह से देखा है लेकिन बिना किसी शोर के खोजना कठिन विषय है।

def f(arg): 
    return arg * arg 

def add(self, other): 
    return self * other 

f.__add__ = add 

cubefunction = f + f 

लेकिन मैं काम पर त्रुटियों की तरह cubefunction के लिए मिलता है:

TypeError: unsupported operand type(s) for +: 'function' and 'function' 

वहाँ कोई समारोह बीजगणित अजगर में संभव है या मैं सिर्फ एक गूंगा गलती कर रहा हूँ मैं कुछ इस तरह करना चाहते हैं?

संपादित करें: बहुत बाद में, मैं कार्यात्मक प्रोग्रामिंग (http://docs.python.org/howto/functional.html) करने के लिए अजगर की आधिकारिक परिचय पढ़ रहा था, और नीचे की ओर यह एक तीसरी पार्टी पैकेज "कार्यात्मक" (http://oakwinter.com/code/functional/documentation/) है, जो कार्यों की रचना कर सकते हैं, यानी संदर्भ:

>>> from functional import compose 
>>> def add(a, b): 
...  return a + b 
... 
>>> def double(a): 
...  return 2 * a 
... 
>>> compose(double, add)(5, 6) 
22 

Answer 1

मुझे नहीं लगता कि आप ऐसा कर सकते हैं। हालांकि, __call__ जादू पद्धति का उपयोग करके आप अपने खुद के प्रतिदेय वर्ग जो एक समारोह के रूप में कार्य करता है परिभाषित करने और जिस पर आप __add__ परिभाषित कर सकते हैं कर सकते हैं: संरचना के *

>>> class FunctionalFunction(object): 
...  def __init__(self, func): 
...    self.func = func 
... 
...  def __call__(self, *args, **kwargs): 
...    return self.func(*args, **kwargs) 
... 
...  def __add__(self, other): 
...    def summed(*args, **kwargs): 
...      return self(*args, **kwargs) + other(*args, **kwargs) 
...    return summed 
... 
...  def __mul__(self, other): 
...    def composed(*args, **kwargs): 
...      return self(other(*args, **kwargs)) 
...    return composed 
... 
>>> triple = FunctionalFunction(lambda x: 3 * x) 
>>> times_six = triple + triple 
>>> times_six(2) 
12 
>>> times_nine = triple * triple 
>>> times_nine(3) 
27 

यहाँ + pointwise इसके अलावा करने के लिए ओवरलोड हो गया है, और। बेशक, आप जो भी चाहें कर सकते हैं।

---

पायथन गुरु के लिए दिलचस्प सवाल: निम्नलिखित क्यों काम नहीं करते हैं (गंदी हैक हालांकि यह है)?

>>> from types import MethodType, FunctionType 
>>> f = lambda: None 
>>> f.__add__ = MethodType(lambda self, other: "summed!", f, FunctionType) 
>>> f.__add__(f) 
'summed!' 
>>> f + f 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: unsupported operand type(s) for +: 'function' and 'function' 

Answer 2

मुझे लगता है कि तुम क्या करने का मतलब क्या है:

cubefunction = (lambda x: add(f(x), f(x))) 

Answer 3

आपके कोड में, f को एक वर्ग होने की आवश्यकता है, न कि फ़ंक्शन। यदि आपके पास कक्षा है, तो आप (स्वयं, अन्य) विधि को लागू कर सकते हैं जो + ऑपरेटर को अधिभारित करेगा।

Answer 4

चरण 1. इसे पढ़ें। http://en.wikipedia.org/wiki/Function_composition_(computer_science)#First-class_composition

चरण 2. इसे पढ़ें। http://en.wikipedia.org/wiki/Haskell_(programming_language)

चरण 3. इसे पढ़ें। http://en.wikipedia.org/wiki/Scheme_(programming_language)

यह पायथन के लिए मीठा स्थान नहीं है।

Answer 5

ठीक है मुझे लगता है कि मुझे कार्यों को जोड़ने में कुछ दिलचस्प मिला है। यह लैम्ब्डा फ़ंक्शन के बारे में है और यह आपकी समस्या को ठीक कर सकता है।कम से कम यह मेरा तय:

>>> def func(x) : 
>>>  return x 
>>> 
>>> f = lambda x : func(x) 
>>> sum_of_f = [ f for i in range(5) ] 
>>> F = lambda x : sum([ i(x) for i in sum_of_f ]) 
>>> F(1) 
5 
>>> F(2) 
10 

और जो रुचि रखते हैं के लिए मानकों

>>> def func(x, p) : 
>>>  return x * p 
>>> 
>>> param = [ 0, 1, 2, 3, 4 ] 
>>> 
>>> f = lambda x, p : func(x, p) 
>>> sum_of_f = [ f for i in range(5) ] 
>>> F_bis = lambda x : sum([ sum_of_f[i](x, param[i]) for i in range(5) ]) 
>>> F_bis(1) 
10 
>>> F_bis(2) 
20 

Answer 6

थोड़ा देर से पारित करने के लिए है, लेकिन बीजगणित इस तरह लैम्ब्डा कार्यों का उपयोग कर आसानी से किया जा सकता है:

>>> f = lambda x: x*x 
>>> g = lambda x: x*x 
>>> h = lambda x: f(g(x)) 
>>> h(2) 
16 
>>> j = lambda x: f(x) + g(x) 
>>> j(2) 
8 
>>> 

(एफ और जी को लैम्ब्डा फ़ंक्शन होने की आवश्यकता नहीं है)

आप सभी प्रकार के कर सकते हैं इसके साथ दिलचस्प चीजों का। आइए मान लें कि आप दिए गए n के लिए फ़ंक्शन f(x) = 1 + x + x**2 + ... + x**n को परिभाषित करना चाहते हैं। आप कर सकते हैं: कारण है कि मैं लैम्ब्डा कि जिस तरह से (lambda x, j = i + 1, k = f:) बनाया

>>> n = 3 
>>> f = lambda x: 1 
>>> for i in range(n): 
...  f = lambda x, j = i + 1, k = f: k(x) + x**j 
... 
>>> f(2) 
15 

समझने के लिए इस पढ़ने के लिए बेहतर है: https://docs.python.org/3.5/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result

लंबी कहानी कम: एक लैम्ब्डा समारोह में पैरामीटर स्थानीय प्रतिलिपि की जरूरत नहीं है । अगर मैंने लूप से i का उपयोग lambda x, k = f: k(x) + x**(i + 1) में किया था, तो हमारे पास f(x) = 1 + x**3 + x**3 + x**3 फ़ंक्शन था।