关于python：将函数及其参数传递给另一个函数


passing functions and its arguments to another function

我有树型的子函数：

  • 一个没有任何参数(参数)，
  • 第二个有一个参数
  • 第三个有多个参数(元组)

我试图将该函数及其参数传递给另一个函数，该函数对所有子函数的结果求和并返回和值。该函数中的参数应该是：每个子函数的名称作为位置参数(*args)，每个子函数的参数作为键值参数(*kvargs)。

例子：

1
2
3
4
5
6
7
8
9
 def no_arg()
 def one_arg(a)
 def multiple_args(a, b, c, e, f)

 # execution of function_results_sum:
 function_results_sum(
     no_arg, one_arg, multiple_args,
     one_arg=23,
     multiple_args=(1, 2, 3, 4, 5))

到目前为止我所做的：

1
2
3
4
5
6
7
8
9
10
11
def no_arg():
    return 5

def ident(x):
    return x

def mult(x, y):
    return x * y    

def function_results_sum(*args, **kwargs):
        return no_arg() + ident(kwargs[ident.__name__]) + mult(*kwargs[mult.__name__])

上面的代码正在向每个子函数传递参数，但是子函数名是硬编码的。我想修改当前代码，以便能够从*参数中获取函数名。在下面，我写了一个伪代码，它表达了我正在努力实现的目标：

1
2
3
4
def function_results_sum(*args, **kwargs):
    for functionName in args:
        result = sum(funcionName(kwargs))
    return result

我已经花了一整天的时间来解决这个问题，所以请不要给我写信说"使用谷歌不会有伤害"；)

相关讨论

类似这样的事情会奏效：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def no_arg():
    return 5

def one_arg(x):
    return x

def multiple_args(x, y):
    return x * y

def function_results_sum(*args, **kwargs):
    result = 0
    for func in args:
            result += func(*kwargs[func.__name__])
    return result

输出：

1
2
3
4
5
6
7
function_results_sum(
    no_arg, one_arg, multiple_args,
    no_arg=(),
    one_arg=(23, ),
    multiple_args=(1,5))

33

您所要求的唯一区别是，您必须将参数放入元组中，然后作为参数解包，以便稍后传递。

如果您不想为无参数函数提供任何内容，可以再次检查func名称是否在kwargs中：

1
2
3
4
5
6
7
8
def function_results_sum(*args, **kwargs):
    result = 0
    for func in args:
        if func.__name__ i kwargs:
            result += func(*kwargs[func.__name__])
        else:
            result += func()
    return result
相关讨论

R NAR的职位正是我想要达到的目标。我添加了额外的if语句来验证kwarg是整数还是元组。感谢您不必将所有**Kwarg放在一个元组中。谢谢你们的帮助！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def function_results_sum(*args, **kwargs):
    result = 0
    for func in args:
        if func.__name__ in kwargs:
            if type(kwargs[func.__name__]) == int:
                result += func(kwargs[func.__name__])
            elif type(kwargs[func.__name__]) == tuple:
                result += func(*kwargs[func.__name__])
        else:
            result += func()
    return result

result = function_results_sum(no_arg, ident, mult, ident=2, mult=(3, 4))
print(result)

通过googing"python确定传递函数的参数个数"，我找到了如何找到python函数的参数个数？

我敢肯定您不需要**kwars键，值语法，所以我使用了func_list正则arg和*args。

1
2
3
4
5
6
7
8
9
10
11
12
13
from inspect import signature


def function_results_sum(func_list, *args):

    arg_gen = (e for e in args)

    return sum([func(*(next(arg_gen)
                       for _ in range(len(signature(func).parameters))))
               for func in func_list])

function_results_sum([no_arg, ident, mult], 7,8,9)
84

通过为Functions和(假定的)参数(任何不是Function类型的参数)解析*参数，可以使输入变得更平坦。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from inspect import signature
import types


def function_results_sum(*args):

    func_gen = (e for e in args if isinstance(e, types.FunctionType))

    arg_gen = (e for e in args if not isinstance(e, types.FunctionType))

    return sum(func(*(next(arg_gen)
                       for _ in range(len(signature(func).parameters))))
               for func in func_gen)

function_results_sum(no_arg, ident, mult, 10,6,90)
555

函数顺序和参数顺序很重要，但可以单独交错：

1
2
function_results_sum(no_arg, 10, ident, 6, 90, mult)
Out[399]: 555