8wDlpd.png
8wDFp9.png
8wDEOx.png
8wDMfH.png
8wDKte.png

**(双星号)和 *(星号)对参数有何作用?

Andriy 1月前

189 0

这些函数定义中的 *args 和 **kwargs 是什么意思?def foo(x, y, *args): passdef bar(x, y, **kwargs): pass 请参阅 ** (双星号) 和 * (星号) 在

这些函数定义中 *args **kwargs 什么

def foo(x, y, *args):
    pass

def bar(x, y, **kwargs):
    pass

See 函数调用中的 **(双星号/星号)和 *(星号/星号)是什么意思? for the complementary question about arguments.

帖子版权声明 1、本帖标题:**(双星号)和 *(星号)对参数有何作用?
    本站网址:http://xjnalaquan.com/
2、本网站的资源部分来源于网络,如有侵权,请联系站长进行删除处理。
3、会员发帖仅代表会员个人观点,并不代表本站赞同其观点和对其真实性负责。
4、本站一律禁止以任何方式发布或转载任何违法的相关信息,访客发现请向站长举报
5、站长邮箱:yeweds@126.com 除非注明,本帖由Andriy在本站《list》版块原创发布, 转载请注明出处!
最新回复 (0)
  • (双星)和 ** (星号)对参数 * 有什么作用

    它们允许 定义函数来接受 并允许 用户传递 任意数量的参数、位置( * )和关键字( ** )。

    定义函数

    *args 允许任意数量的可选位置参数(参数),这些参数将被分配给名为 args .

    **kwargs 允许任意数量的可选关键字参数(参数),这些参数将位于名为 kwargs .

    您可以(并且应该)选择任何合适的名称,但如果目的是使参数具有非特定的语义, args 并且 kwargs 是标准名称。

    扩展,传递任意数量的参数

    您还可以使用 *args **kwargs 分别传递来自列表(或任何可迭代对象)和字典(或任何映射)的参数。

    接收参数的函数不必知道它们正在被扩展。

    例如,Python 2 的 xrange 没有明确期望 *args ,但由于它接受 3 个整数作为参数:

    >>> x = xrange(3) # create our *args - an iterable of 3 integers
    >>> xrange(*x)    # expand here
    xrange(0, 2, 2)
    

    再举一个例子,我们可以使用字典扩展 str.format

    >>> foo = 'FOO'
    >>> bar = 'BAR'
    >>> 'this is foo, {foo} and bar, {bar}'.format(**locals())
    'this is foo, FOO and bar, BAR'
    

    Python 3 中的新功能:仅使用关键字参数定义函数

    您可以 在后面 仅关键字参数 *args - 例如,这里 kwarg2 必须作为关键字参数给出 - 而不是位置参数:

    def foo(arg, kwarg=None, *args, kwarg2=None, **kwargs): 
        return arg, kwarg, args, kwarg2, kwargs
    

    用法:

    >>> foo(1,2,3,4,5,kwarg2='kwarg2', bar='bar', baz='baz')
    (1, 2, (3, 4, 5), 'kwarg2', {'bar': 'bar', 'baz': 'baz'})
    

    此外, * 可以单独使用来指示仅跟随关键字参数,而不允许无限制的位置参数。

    def foo(arg, kwarg=None, *, kwarg2=None, **kwargs): 
        return arg, kwarg, kwarg2, kwargs
    

    这里, kwarg2 再次必须有一个明确命名的关键字参数:

    >>> foo(1,2,kwarg2='kwarg2', foo='foo', bar='bar')
    (1, 2, 'kwarg2', {'foo': 'foo', 'bar': 'bar'})
    

    我们不能再接受无限的位置参数,因为我们没有 *args*

    >>> foo(1,2,3,4,5, kwarg2='kwarg2', foo='foo', bar='bar')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: foo() takes from 1 to 2 positional arguments 
        but 5 positional arguments (and 1 keyword-only argument) were given
    

    再次,更简单地说,这里我们要求 kwarg 按名称给出,而不是按位置给出:

    def bar(*, kwarg=None): 
        return kwarg
    

    在这个例子中,我们看到如果我们尝试 kwarg 按位置传递,我们会收到错误:

    >>> bar('kwarg')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: bar() takes 0 positional arguments but 1 was given
    

    我们必须明确地将 kwarg 参数作为关键字参数传递。

    >>> bar(kwarg='kwarg')
    'kwarg'
    

    Python 2 兼容演示

    *args (通常表示为 \'star-args\')和 **kwargs (星号可以通过表示为 \'kwargs\' 来暗示,但要使用 \'double-star kwargs\' 来明确)是 Python 使用 * and ** 符号的常见习惯用法。这些特定的变量名不是必需的(例如,您可以使用 *foos and **bars ),但背离惯例可能会激怒您的 Python 程序员同事。

    我们通常在不知道我们的函数将接收什么或传递多少个参数时使用这些,有时甚至单独命名每个变量也会变得非常混乱和冗余(但在这种情况下通常显式比隐式更好)。

    示例 1

    以下函数描述了如何使用它们,并演示了它们的行为。请注意,命名 b 参数将被之前的第二个位置参数使用:

    def foo(a, b=10, *args, **kwargs):
        '''
        this function takes required argument a, not required keyword argument b
        and any number of unknown positional arguments and keyword arguments after
        '''
        print('a is a required argument, and its value is {0}'.format(a))
        print('b not required, its default value is 10, actual value: {0}'.format(b))
        # we can inspect the unknown arguments we were passed:
        #  - args:
        print('args is of type {0} and length {1}'.format(type(args), len(args)))
        for arg in args:
            print('unknown arg: {0}'.format(arg))
        #  - kwargs:
        print('kwargs is of type {0} and length {1}'.format(type(kwargs),
                                                            len(kwargs)))
        for kw, arg in kwargs.items():
            print('unknown kwarg - kw: {0}, arg: {1}'.format(kw, arg))
        # But we don't have to know anything about them 
        # to pass them to other functions.
        print('Args or kwargs can be passed without knowing what they are.')
        # max can take two or more positional args: max(a, b, c...)
        print('e.g. max(a, b, *args) \n{0}'.format(
          max(a, b, *args))) 
        kweg = 'dict({0})'.format( # named args same as unknown kwargs
          ', '.join('{k}={v}'.format(k=k, v=v) 
                                 for k, v in sorted(kwargs.items())))
        print('e.g. dict(**kwargs) (same as {kweg}) returns: \n{0}'.format(
          dict(**kwargs), kweg=kweg))
    

    我们可以通过在线帮助查看该函数的签名, help(foo) 它告诉我们

    foo(a, b=10, *args, **kwargs)
    

    让我们用以下代码调用这个函数 foo(1, 2, 3, 4, e=5, f=6, g=7)

    打印结果为:

    a is a required argument, and its value is 1
    b not required, its default value is 10, actual value: 2
    args is of type <type 'tuple'> and length 2
    unknown arg: 3
    unknown arg: 4
    kwargs is of type <type 'dict'> and length 3
    unknown kwarg - kw: e, arg: 5
    unknown kwarg - kw: g, arg: 7
    unknown kwarg - kw: f, arg: 6
    Args or kwargs can be passed without knowing what they are.
    e.g. max(a, b, *args) 
    4
    e.g. dict(**kwargs) (same as dict(e=5, f=6, g=7)) returns: 
    {'e': 5, 'g': 7, 'f': 6}
    

    示例 2

    我们还可以使用另一个函数来调用它,我们只需提供 a

    def bar(a):
        b, c, d, e, f = 2, 3, 4, 5, 6
        # dumping every local variable into foo as a keyword argument 
        # by expanding the locals dict:
        foo(**locals()) 
    

    bar(100) 印刷:

    a is a required argument, and its value is 100
    b not required, its default value is 10, actual value: 2
    args is of type <type 'tuple'> and length 0
    kwargs is of type <type 'dict'> and length 4
    unknown kwarg - kw: c, arg: 3
    unknown kwarg - kw: e, arg: 5
    unknown kwarg - kw: d, arg: 4
    unknown kwarg - kw: f, arg: 6
    Args or kwargs can be passed without knowing what they are.
    e.g. max(a, b, *args) 
    100
    e.g. dict(**kwargs) (same as dict(c=3, d=4, e=5, f=6)) returns: 
    {'c': 3, 'e': 5, 'd': 4, 'f': 6}
    

    示例 3:装饰器中的实际用法

    好吧,也许我们还没有看到它的实用性。想象一下,您有几个函数在区分代码之前和/或之后有冗余代码。以下命名函数只是为了说明目的而编写的伪代码。

    def foo(a, b, c, d=0, e=100):
        # imagine this is much more code than a simple function call
        preprocess() 
        differentiating_process_foo(a,b,c,d,e)
        # imagine this is much more code than a simple function call
        postprocess()
    
    def bar(a, b, c=None, d=0, e=100, f=None):
        preprocess()
        differentiating_process_bar(a,b,c,d,e,f)
        postprocess()
    
    def baz(a, b, c, d, e, f):
        ... and so on
    

    我们也许能够以不同的方式处理这个问题,但我们当然可以用装饰器提取冗余,因此下面的例子演示了如何 *args 并且 **kwargs 可能非常有用:

    def decorator(function):
        '''function to wrap other functions with a pre- and postprocess'''
        @functools.wraps(function) # applies module, name, and docstring to wrapper
        def wrapper(*args, **kwargs):
            # again, imagine this is complicated, but we only write it once!
            preprocess()
            function(*args, **kwargs)
            postprocess()
        return wrapper
    

    现在每个包装函数都可以写得更简洁,因为我们已经排除了冗余:

    @decorator
    def foo(a, b, c, d=0, e=100):
        differentiating_process_foo(a,b,c,d,e)
    
    @decorator
    def bar(a, b, c=None, d=0, e=100, f=None):
        differentiating_process_bar(a,b,c,d,e,f)
    
    @decorator
    def baz(a, b, c=None, d=0, e=100, f=None, g=None):
        differentiating_process_baz(a,b,c,d,e,f, g)
    
    @decorator
    def quux(a, b, c=None, d=0, e=100, f=None, g=None, h=None):
        differentiating_process_quux(a,b,c,d,e,f,g,h)
    

    通过分解代码( *args **kwargs 允许我们这样做),我们可以减少代码行数,提高可读性和可维护性,并为程序中的逻辑提供唯一的规范位置。如果我们需要更改此结构的任何部分,我们只需在一个位置进行每次更改。

返回
作者最近主题: