我想创建一个装饰器，它结合了两个函数，并结合了签名中的参数。
我想要的界面：
def f(a, b, c, d, e, f, g, h, i, j, k, l, m, n):
# I am using many parameters to explain the need of not
# needing to type the arguments again.
return a * b * c * d * e * f * g * h * i * j * k * l * m * n
@combines(f)
def g(o, p, *args, **kwargs):
return (o + p) * f(*args, **kwargs)
这应该基本上导致：
def g(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p):
return (o + p) * (a * b * c * d * e * f * g
* h * i * j * k * l * m * n)
我想要这个的原因是因为我不太了解函数f的论点（我知道它们，但我不想再次输入它们以使其成为一般。）
我不确定是否必须使用g和*args致电**kwargs，但我认为这是必要的。
这是我走了多远：
import functools
import inspect
def combines(old_func):
old_sig = inspect.signature(old_func)
old_parameters = old_sig.parameters
def insert_in_signature(new_func):
new_parameters = inspect.signature(new_func).parameters
for new_parameter in new_parameters:
if new_parameter in old_parameters.keys():
raise TypeError('`{}` argument already defined'.format(new_parameter))
@functools.wraps(new_func)
def wrapper(*args, **kwargs):
return old_func(*args, **kwargs) * new_func(*args, **kwargs)
parms = list(old_parameters.values())
for arg, par in new_parameters.items():
if par.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
parms.append(inspect.Parameter(arg, par.kind))
wrapper.__signature__ = old_sig.replace(parameters=parms)
return wrapper
return insert_in_signature
def f(a, b, c, d, e, f, g, h, i, j, k, l, m, n):
return a * b * c * d * e * f * g * h * i * j * k * l * m * n
@combines(f)
def g(o, p, *args, **kwargs):
return (o + p) * f(*args, **kwargs)
这会产生g所需的调用签名，但它不起作用。
编辑，因为询问了错误消息
例如：g(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-23-2775f64e1b3e> in <module>()
----> 1 g(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)
<ipython-input-18-3a843320e4e3> in wrapper(*args, **kwargs)
13 @functools.wraps(new_func)
14 def wrapper(*args, **kwargs):
---> 15 return old_func(*args, **kwargs) * new_func(*args, **kwargs)
16
17 parms = list(old_parameters.values())
TypeError: f() takes 14 positional arguments but 16 were given
如果我然后按照错误消息并使用g(1,1,1,1,1,1,1,1,1,1,1,1,1,1)提供14个参数：
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-24-052802b037a4> in <module>()
----> 1 g(1,1,1,1,1,1,1,1,1,1,1,1,1,1)
<ipython-input-18-3a843320e4e3> in wrapper(*args, **kwargs)
13 @functools.wraps(new_func)
14 def wrapper(*args, **kwargs):
---> 15 return old_func(*args, **kwargs) * new_func(*args, **kwargs)
16
17 parms = list(old_parameters.values())
<ipython-input-18-3a843320e4e3> in g(o, p, *args, **kwargs)
29 @combines(f)
30 def g(o, p, *args, **kwargs):
---> 31 return (o + p) * f(*args, **kwargs)
TypeError: f() missing 2 required positional arguments: 'm' and 'n'
很明显，我的实施并没有真正起作用。
答案 0 :(得分：2)
您的问题是，您使用不同的参数调用f函数两次，一次在原始g内，仅包含其预期参数，一次在包装器中包含所有参数。
您必须选择一个，我的建议是从原来的g
我稍微更改了您的代码，但至少我的版本适用于Python 3.5：
f和g 以下是代码：
def combine(ext):
ext_params = inspect.signature(ext).parameters
def wrapper(inn):
inn_params = inspect.signature(inn).parameters
for k in inn_params.keys():
if k in ext_params.keys():
raise TypeError('`{}` argument already defined'.format(
k))
all_params = list(ext_params.values()) + \
list(inn_params.values())
# computes the signature for the wrapped function
sig = inspect.signature(inn).replace(parameters = all_params)
def wrapped(*args, **kwargs):
# signature bind magically processes positional and keyword arguments
act_args = sig.bind(*args, **kwargs).args
ext_args = act_args[:len(ext_params.keys())] # for external function
inn_args = act_args[len(ext_params.keys()):] # for inner function
return ext(*ext_args) * inn(*inn_args)
w = functools.update_wrapper(wrapped, inn) # configure the wrapper function
w.__signature__ = sig # and set its signature
return w
return wrapper
我现在可以写：
>>> @combine(f)
def g(o,p):
return o+p
>>> help(g)
Help on function g in module __main__:
g(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
>>> g(1,1,1,1,1,1,1,1,1,1,1,1,1,p=1, o=1, n=1)
2
答案 1 :(得分：0)
我想我明白你想要什么。为此，首先，我建议使用OOP，以使事情更清晰。我认为您不需要所有代码来处理参数或inspect模块。我认为你应该保持简单：
我认为问题的一部分是你用相同的参数调用这两个函数，并且它们被认为是太多的参数，或者太少，在这种情况下你需要修改g。我想有没有办法弄清楚哪个参数属于哪个函数，所以这里有几个解决方案：
这是一个解决方案：
def combines(func):
class Decorator:
def __init__(self, f):
self.outer_func = func
self.inner_func = f
def __call__(self, *args, **kwargs):
res, a, p = self.inner_func(*args, **kwargs)
return res * self.outer_func(*a, **p)
return Decorator
def f(a, b, c, d, e, f, g, h, i, j, k, l, m, n):
return a * b * c * d * e * f * g * h * i * j * k * l * m * n
@combines(f)
def g(o, p, *args, **kwargs):
return o+p, args, kwargs
print g(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1) # output: 2
这是另一个使用第三个函数来组合两者的解决方案：
def combines(func1, func2):
class Decorator:
def __init__(self, f):
self.outer_func = func1
self.inner_func = func2
self.func = f
def __call__(self, *args, **kwargs):
res, a, p = self.inner_func(*args, **kwargs)
return self.func(res, self.outer_func(*a, **p))
return Decorator
def f(a, b, c, d, e, f, g, h, i, j, k, l, m, n):
return a * b * c * d * e * f * g * h * i * j * k * l * m * n
def g(o, p, *args, **kwargs):
return o+p, args, kwargs
@combines(f, g)
def h(a, b): # a is g's result
return a * b # b is f's result
print h(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) # output: 2
编写一个函数来确定哪些参数对哪个函数来说很难，如果不是不可能的话，但我认为这应该有效。