Question

python decorator成为＆＃34;多态＆＃34 ;?的方式是什么？我的意思是它寻找一个精确的装饰函数参数，对它做一些事情，然后将修改后的参数传递给函数。但是，具有通用名称的此参数在任何修饰函数中都具有任意位置。

def decorator(func):
    def wrapper(exactly_this_param, *args):
        new = do_smth(exactly_this_param)
        return func(exactly_this_param=new, *args)
    return wrapper

@decorator
def func1(a, b, exactly_this_param, c):
    # does something

@decorator
def func2(exactly_this_param):
    # does something

@decorator
def func3(a, b, c, d, e, exactly_this_param, *args, **kwargs):
    # does something

Answer 1

使用关键字参数（kwargs）这很容易，因为* kwargs会在装饰器中为您提供关键字参数的名称和值。所以你会得到这样的东西：

func3(1,2,3,4,5,6,7,test="hallo")

会给你：

kwargs{'test': 'hallo'}

所以你可以搜索＆＃34; exact_this_param＆＃34;并改变它..

但是你选择使用普通的args。这是一步，但也是可能的。

所以这是一个可能的解决方案：（我使用的是python 3）

使用＆＃34;非关键字参数＆＃34; （args）你可以使用以下组合：

args - ＆gt;给你一个这个函数调用的实际值的元组
func。代码 .co_varnames - ＆gt;为函数定义提供参数名称

我将它们分配给可变的 func_params

func_params = func.__code__.co_varnames

因此，您可以在 func。代码 .co_varnames 中查找＆＃34; exact_this_param＆＃34; 的索引并更改值在args中也正是这个指数。这是这个块：

new_args[func_params.index("exactly_this_param")]=999

你还必须将 args 转换为列表（ new_args ）并返回元组，因为元组在python中是不可变的。

这导致类似这样的事情（示例代码 - 但正在运行）：

def decorator(func):
def wrapped(*args, **kwargs):
    # a tuple of the names of the parameters that func accepts
    print("    ... decorator magic ....")
    print("    .... args" + str(args))
    print("    .... kwargs" + str(kwargs))
    func_params = func.__code__.co_varnames
    print("    .... param_names:" + str(func_params))
    # grab all of the kwargs that are not accepted by func
    new_args=list(args)
    new_args[func_params.index("exactly_this_param")]=999
    args=tuple(new_args)
    print("    .... new_args" + str(args))
    return func(*args, **kwargs)
return wrapped

@decorator
def func1(a, b, exactly_this_param, c):
    # does something
    print("func1 => exactly_this_slightly_different_param: " + str(exactly_this_param))

@decorator
def func2(exactly_this_param):
    # does something
    print("func2 =>  exactly_this_slightly_different_param: " + str(exactly_this_param))

@decorator
def func3(a, b, c, d, e, exactly_this_param, *args, **kwargs):
    # does something
    print("func3 =>  exactly_this_slightly_different_param: " + str(exactly_this_param))

if __name__ == "__main__":
    func1(1,2,3,4)
    func2(12)
    func3(1,2,3,4,5,6,7,test="hallo")

结果输出显示始终找到参数并更改为999。

c:\khz\devel>python test_dec.py
    ... decorator magic ....
    .... args(1, 2, 3, 4)
    .... kwargs{}
    .... param_names:('a', 'b', 'exactly_this_param', 'c')
    .... new_args(1, 2, 999, 4)
func1 => exactly_this_slightly_different_param: 999
    ... decorator magic ....
    .... args(12,)
    .... kwargs{}
    .... param_names:('exactly_this_param',)
    .... new_args(999,)
func2 =>  exactly_this_slightly_different_param: 999
    ... decorator magic ....
    .... args(1, 2, 3, 4, 5, 6, 7)
    .... kwargs{'test': 'hallo'}
    .... param_names:('a', 'b', 'c', 'd', 'e', 'exactly_this_param', 'args', 'kwargs')
    .... new_args(1, 2, 3, 4, 5, 999, 7)
func3 =>  exactly_this_slightly_different_param: 999

根据this SO question答案。

Python装饰器，带有任意定位的装饰函数

1 个答案: