Python 从其他函数列表中以编程方式定义新函数

我有：

我想做一个新函数：

def f(x, y): return x**2 + y**2
def g(x, y): return x**3 + y**3
def h(x, y): return x**4 + y**4

但是，我找不到一种编程方式来实现这一点。 也就是说，采取如下方式：

def J(x, y):
    return f(x,y)*g(x,y)*h(x,y)

并返回一个新函数

J

，该函数返回

f

、

g

和

h

的乘积

另一个问题是，虽然

f

，

g

和

h

的参数数量总是相同的，但这个数字可能会改变。也就是说，他们都可以有五个论点，而不是两个

期望的行为：

myFunctions = [f,g,h]

---

编辑

myFunctions

中的函数数也是任意的。

---

我认为我的问题中暗示了这一点，但重读后我发现我根本没有说清楚。很抱歉。

您可以允许

J

根据需要获取尽可能多的参数，然后将f、g和h给出的最终列表相乘：

print(J(2, 2)) # 4096

---

由于f、g和h将具有相同数量的参数，这应适用于所有情况。

您可以允许

J

根据需要获取尽可能多的参数，然后乘以f、g和h给出的最终列表：

print(J(2, 2)) # 4096

---

由于f、g和h将具有相同数量的参数，这应适用于所有情况。

可变数量的参数问题可以通过以下方法解决：

def f(x, y): return x**2 + y**2

def g(x, y): return x**3 + y**3

def h(x, y): return x**4 + y**4

def multiply(mylist):
    return reduce(lambda a, b: a*b, mylist)

myfuncs = [f,g,h]
def J(*args):
    return multiply([myfunc(*args) for myfunc in myfuncs])

然后您可以简单地定义

J

函数

def f(*args): return sum(map(lambda x: x**2, args))

def g(*args): return sum(map(lambda x: x**3, args))

def h(*args): return sum(map(lambda x: x**4, args))

如果希望支持可变数量的函数，那么可以将J定义为以下内容，并将函数列表作为列表的第一项传入，将参数作为以下内容传入

def J(*args):
    return f(*args)*g(*args)*h(*args)

---

可变参数数问题可以通过以下方法解决：

def f(x, y): return x**2 + y**2

def g(x, y): return x**3 + y**3

def h(x, y): return x**4 + y**4

def multiply(mylist):
    return reduce(lambda a, b: a*b, mylist)

myfuncs = [f,g,h]
def J(*args):
    return multiply([myfunc(*args) for myfunc in myfuncs])

然后您可以简单地定义

J

函数

def f(*args): return sum(map(lambda x: x**2, args))

def g(*args): return sum(map(lambda x: x**3, args))

def h(*args): return sum(map(lambda x: x**4, args))

如果希望支持可变数量的函数，那么可以将J定义为以下内容，并将函数列表作为列表的第一项传入，将参数作为以下内容传入

def J(*args):
    return f(*args)*g(*args)*h(*args)

---

函数可以接受任意多个参数，如下所示：

def J(*args):
    funcs = args[0]            
    args = args[1:]           
    temp = map(lambda x: x(*args), funcs)
    return reduce(lambda x,y: x*y, temp, 1)

def J(*args):

这将把所有

J

的参数存储在列表

args

中。然后可以将该列表转换回多个参数，以调用其他函数，如下所示：

def J(*args):
    funcs = args[0]            
    args = args[1:]           
    temp = map(lambda x: x(*args), funcs)
    return reduce(lambda x,y: x*y, temp, 1)

def J(*args):

这就解决了参数数量变化的问题。现在让我们来处理这个事实，可以有任意多个函数。首先，我们需要调用列表中的函数。我们可以通过对它们进行迭代并使用

（）

：

这将返回函数返回值的列表。因此，我们现在需要的是获得一系列产品：

def J(*args):
  return [func(*args) for func in myFunctions]

---

函数可以接受任意多个参数，如下所示：

def J(*args):
    funcs = args[0]            
    args = args[1:]           
    temp = map(lambda x: x(*args), funcs)
    return reduce(lambda x,y: x*y, temp, 1)

def J(*args):

这将把所有

J

的参数存储在列表

args

中。然后可以将该列表转换回多个参数，以调用其他函数，如下所示：

def J(*args):
    funcs = args[0]            
    args = args[1:]           
    temp = map(lambda x: x(*args), funcs)
    return reduce(lambda x,y: x*y, temp, 1)

def J(*args):

这就解决了参数数量变化的问题。现在让我们来处理这个事实，可以有任意多个函数。首先，我们需要调用列表中的函数。我们可以通过对它们进行迭代并使用

（）

：

这将返回函数返回值的列表。因此，我们现在需要的是获得一系列产品：

def J(*args):
  return [func(*args) for func in myFunctions]

另一种选择：

from functools import reduce
from operator import mul

def product(numbers):
  return reduce(mul, list, 1)

def J(*args):
  return product(func(*args) for func in myFunctions)

具有一个很好的特性，即J采用与函数f、g和h相同数量的参数，而不是

*args

另一个选项：

from functools import reduce
from operator import mul

def product(numbers):
  return reduce(mul, list, 1)

def J(*args):
  return product(func(*args) for func in myFunctions)

---

具有一个很好的特性，即J采用与函数f、g和h相同数量的参数，而不是

*args

有没有理由不将

J

定义为

def J（*args，**kwargs）

？是否出于其他原因需要这些参数？是否创建函数列表？如果是这样，您可以使用

*args

向函数传递可选数量的位置参数。您可以使用

functools.reduce

、

operator.mul

、

functools.partial

和Python中的其他函数工具来实现这一点。正如其他注释所述，您可以轻松定义任意位置参数和关键字参数。@VincentSavard不是名称本身，否。您为什么不将

J

定义为

def J（*args，**kwargs）

？是否出于其他原因需要这些参数？是否创建函数列表？如果是这样，您可以使用

*args

向函数传递可选数量的位置参数。您可以使用

functools.reduce

、

operator.mul

、

functools.partial

和Python中的其他函数工具来实现这一点。正如其他注释所述，您可以轻松定义任意位置参数和关键字参数。@VincentSavard不是名称本身，否。问题标记为Python 3，因此您必须从itertools导入

reduce

。还可以导入operator.mul，而不是构建自己的

multiply

函数。问题被标记为Python 3，所以您必须从itertools导入

reduce

。也可以导入operator.mul，而不是构建自己的

乘法

函数。不过，这并不使用

myFunctions

——它只是硬编码

f

、

g

和

h

。同意，我改进了答案（受您的启发），感谢这不使用

myFunctions

，但它只是硬编码

f

、

g

和

h

。同意，我已经改进了答案（受您的启发），谢谢