Question

让我说我有两个功能：

def foo1(bar, a, b, c):
  result = bar(a, b)
  return result

def foo2(bar, a, b, c):
  result = bar(a, b, c)
  return result

两种情况下的参数都相同，但是取决于函数“ bar”可能只需要2个，而另一个可能需要全部3个（以相同的顺序）

是否有可能使它成为一个函数而无需知道引用函数需要多少个参数？

Answer 1

您可以使用函数对象的__code__.co_argcount属性来获取其期望的参数数量，并可以使用这些参数分割参数列表：

def bar1(a, b):
    return b, a

def bar2(a, b, c):
    return c, b, a

def foo(bar, *args):
    return bar(*args[:bar.__code__.co_argcount])

print(foo(bar1, 1, 2, 3))
print(foo(bar2, 1, 2, 3))

这将输出：

(2, 1)
(3, 2, 1)

Answer 2

我认为您可能正在寻找*扩展运算符

def foo(bar, *args):
  result = bar(*args)
  return result

例如：

In [1]: def foo(bar,*args): 
   ...:     return bar(*args) 
   ...:                                                                                                                                      

In [2]: def f1(a): 
   ...:     return a 
   ...:                                                                                                                                      

In [3]: def f2(a,b): 
   ...:     return a+b 
   ...:                                                                                                                                      

In [4]: foo(f1,5)                                                                                                                            
Out[4]: 5

In [5]: foo(f2,5,6)                                                                                                                          
Out[5]: 11

In [6]: foo(f1,5,6)                                                                                                                          
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-5ca26cac7f4d> in <module>
----> 1 foo(f1,5,6)

<ipython-input-1-fe8d4699f744> in foo(bar, *args)
      1 def foo(bar,*args):
----> 2     return bar(*args)
      3 

TypeError: f1() takes 1 positional argument but 2 were given

Answer 3

是的。如果我对您的理解正确，那么您想将未指定数量的参数传递给函数吗？

如果是这样，您可以接受一个元组；这样该函数可以接受（a，b，c）或更多其他参数。元组类似于列表，但不可变。当然，要确保输入正确数量的参数。

下面，参数是一个元组。您可以执行len（arguments）来查找输入了多少个参数。

arguments=(bar, a, b)
foo(arguments)

def foo(my_tuple):
  result = arguments[0](arguments[1], arguments[2])
  return result

Answer 4

尝试一下。

from inspect import signature

def foo(bar, *args):
    arg_count = len(signature(bar).parameters)
    return bar(*args[:arg_count])

这将传递函数期望的许多参数，而忽略其余参数。如果您以后想使用所有参数，它们将在args列表中。

如何知道要传递给引用函数的参数个数

4 个答案: