如何添加功能

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'

Python中没有可能的函数代数还是我只是犯了一个愚蠢的错误？

编辑：很久以后，我正在阅读Python的函数式编程的官方介绍（http://docs.python. org/howto/tical.html），并且在底部它引用了第三方包“function”（http://oakwinter.com/code/tical/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

这里 < code>+ 重载为逐点加法，* 重载为复合。当然，您可以做任何您喜欢的事情。

---

对于 Python 专家来说，有趣的问题是：为什么下面的代码不起作用（尽管它是肮脏的黑客）？

>>> 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 需要是一个类，而不是一个函数。如果您有一个类，则可以实现一个 add(self, other) 方法来重载 + 运算符。

Answer 4

嗯，我想我得到了一些有趣的东西来添加功能。这是关于 lambda 函数的，它可以解决您的问题。至少它修复了我的问题：

>>> 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 5

有点晚了，但是使用 lambda 函数可以轻松完成这种代数：

>>> 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
>>>

（f 和 g 不需要是 lambda 函数）

您可以用它做各种有趣的事情。假设您要为给定的 n 定义函数 f(x) = 1 + x + x**2 + ... + x**n。您可以这样做：

>>> 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

要了解为什么我以这种方式创建 lambda (lambda x, j = i + 1, k = f:)，最好阅读以下内容： https://docs.python.org/3.5/faq/programming.html#why-do-lambdas-define-in-a-loop-with- different-values-all-return-the-same-result

长话短说：lambda 函数中的参数没有本地副本。如果我像 lambda x, k = f: k(x) + x**(i + 1) 那样使用循环中的 i，我们就会得到函数f(x) = 1 + x**3 + x**3 + x**3。