【问题标题】:Convert **kwargs arguments to positional将 **kwargs 参数转换为位置参数
【发布时间】:2015-10-31 07:02:36
【问题描述】:

我想为知道位置参数的函数编写一个包装器。不幸的是,我还希望允许使用命名的位置参数调用包装函数(为了便于阅读)。由于被包装的函数实际上是一个新函数,它不会有旧函数的位置参数名称。

示例:这是一个包装器。

def double_second_argument(f):

    def g(*args):
        newargs = list(args)
        newargs[1] *= 2
        return f(*newargs)

    return g

这是一个函数。

def add(x, y):
    return x + y

我包装了函数。

add_twice = double_second_argument(add)

我调用函数时不带和带命名参数。

>>> add_twice(3, 5)
13
>>> add_twice(x=3, y=5) # = 13
TypeError: g() got an unexpected keyword argument 'x'

我收到一个错误,因为g 没有**kwargs,添加它只会将错误变成IndexError,因为newargs[1] 会索引一个空列表。

更糟糕的是,如果原始函数本身被包装(可能由同一个包装器)。我们必须以保留参数列表的方式定义这两个包装器。

【问题讨论】:

    标签: python


    【解决方案1】:

    inspect.Signature.bind 可用于此目的。

    from functools import wraps
    from inspect import signature, BoundArguments, Parameter
    
    
    def positional_argument_wrapper(func):
    
        func_signature = signature(func)
        if any(v.kind == Parameter.VAR_KEYWORD
               for v in func_signature.parameters.values()):
            raise TypeError('Keyword-only arguments are not supported by '
                            'positional_argument_wrapper')
    
        @wraps(func)
        def wrapped_func(*args, **kwargs):
            bound_arguments: BoundArguments = func_signature.bind(*args, **kwargs)
            bound_arguments.apply_defaults()
            assert len(bound_arguments.kwargs) == 0
            print(f'The positional arguments are {bound_arguments.args}')
            return func(*args, **kwargs)
        return wrapped_func
    
    
    @positional_argument_wrapper
    def myfunc1(x=None, y=7):
        print(f'myfunc called with x={x} and y={y}')
    
    
    # prints: The positional arguments are (3,)
    #         myfunc called with x=3 and y=7
    myfunc1(x=3)
    # prints: The positional arguments are (None, 3)
    #         myfunc called with x=None and y=3
    myfunc1(y=3)
    
    # raises: TypeError: Keyword-only arguments are not supported by positional_argument_wrapper
    @positional_argument_wrapper
    def myfunc1(x=None, y=7, **kwargs):
        pass
    

    【讨论】:

    • 谢谢!!这对我帮助很大!
    【解决方案2】:

    inspect.signature 用于获取函数的签名,即使该函数已(正确)包装。 (参见PEP-3062/Implementation。)这可用于获取参数名称,然后将包装函数包装在另一个包装器中,该包装器将提取kwargs 放入args。

    from inspect import signature
    from functools import wraps
    
    def expands_positional_args(f):
    
        # Save the parameter list.
        params = list(signature(f).parameters.keys())
    
        def wrap(g):
    
            @wraps(g)
            def kw_to_positional(*args, **kwargs):
    
                if len(args) < len(params): # not enough args
    
                    kwargs = kwargs.copy()
                    args = list(args)
    
                    # Extract and remove the args from kwargs
                    args.extend(kwargs.pop(p) for p in params[len(args):])
    
                return g(*args)
    
            return kw_to_positional
    
        return wrap
    

    (注意:这不处理默认参数,假设 f 没有关键字参数,并针对缺少的参数引发 KeyError。我修复了这些问题 in this version。)

    现在,我们有:

    >>> def double_second_argument(f):
    ...     @expands_positional_args(f)
    ...     def g(*args):
    ...         newargs = list(args)
    ...         newargs[1] *= 2
    ...         return f(*newargs)
    ...     return g
    ...
    >>> def add(x, y):
    ...     return x + y
    ...
    >>>
    >>> add_twice = double_second_argument(add)
    >>>
    >>> add_twice(3, 5) # = 13
    13
    >>> add_twice(x=3, y=5) # = 13
    13
    

    【讨论】:

      猜你喜欢
      • 2021-08-01
      • 2013-07-19
      • 2016-04-28
      • 2015-11-16
      • 1970-01-01
      • 2017-05-02
      • 2016-01-04
      • 2012-12-29
      • 1970-01-01
      相关资源
      最近更新 更多