Use of *args and **kwargs
所以我很难理解
到目前为止，我了解到：
*args =参数列表-作为位置参数**kwargs =dictionary-其键成为单独的关键字参数，值成为这些参数的值。
我不明白这对什么编程任务有帮助。
也许吧：
我想输入列表和字典作为函数的参数，同时作为通配符，这样我就可以传递任何参数了？
有没有一个简单的例子来解释如何使用
另外，我发现的教程只使用了"*"和变量名。
语法是
当您不确定有多少参数可以传递给函数时，可以使用
1 2 3 4 5 6 7 8 | >>> def print_everything(*args): for count, thing in enumerate(args): ... print( '{0}. {1}'.format(count, thing)) ... >>> print_everything('apple', 'banana', 'cabbage') 0. apple 1. banana 2. cabbage |
同样，
1 2 3 4 5 6 7 | >>> def table_things(**kwargs): ... for name, value in kwargs.items(): ... print( '{0} = {1}'.format(name, value)) ... >>> table_things(apple = 'fruit', cabbage = 'vegetable') cabbage = vegetable apple = fruit |
您也可以将这些参数与命名参数一起使用。显式参数首先获取值，然后将其他所有值传递给
1 | def table_things(titlestring, **kwargs) |
您也可以在同一个函数定义中使用这两种方法，但
调用函数时还可以使用
1 2 3 4 5 6 | >>> def print_three_things(a, b, c): ... print( 'a = {0}, b = {1}, c = {2}'.format(a,b,c)) ... >>> mylist = ['aardvark', 'baboon', 'cat'] >>> print_three_things(*mylist) a = aardvark, b = baboon, c = cat |
正如您在本例中看到的，它获取项目列表(或元组)并将其解包。通过这个方法，它将它们与函数中的参数相匹配。当然，在函数定义和函数调用中都可以有一个
其中一个使用
1 2 3 4 5 6 7 8 9 10 | class Foo(object): def __init__(self, value1, value2): # do something with the values print value1, value2 class MyFoo(Foo): def __init__(self, *args, **kwargs): # do something else, don't care about the args print 'myfoo' super(MyFoo, self).__init__(*args, **kwargs) |
这样就可以扩展foo类的行为，而不必太了解foo。如果您正在编程一个可能会改变的API，这将非常方便。myfoo只是将所有参数传递给foo类。
下面是一个使用3种不同类型参数的示例。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | def func(required_arg, *args, **kwargs): # required_arg is a positional-only parameter. print required_arg # args is a tuple of positional arguments, # because the parameter name has * prepended. if args: # If args is not empty. print args # kwargs is a dictionary of keyword arguments, # because the parameter name has ** prepended. if kwargs: # If kwargs is not empty. print kwargs >>> func() Traceback (most recent call last): File"<stdin>", line 1, in <module> TypeError: func() takes at least 1 argument (0 given) >>> func("required argument") required argument >>> func("required argument", 1, 2, '3') required argument (1, 2, '3') >>> func("required argument", 1, 2, '3', keyword1=4, keyword2="foo") required argument (1, 2, '3') {'keyword2': 'foo', 'keyword1': 4} |
这里是我最喜欢使用
1 2 3 | mynum = 1000 mystr = 'Hello World!' print"{mystr} New-style formatting is {mynum}x more fun!".format(**locals()) |
我不确定它是否比仅仅使用名字本身快得多，但是打字容易得多！
在编写包装器函数(如decorators)时，*args和**kwargs很有用，这两个函数需要能够接受任意参数才能传递给被包装的函数。例如，一个简单的装饰器，它打印被包装的函数的参数和返回值：
1 2 3 4 5 6 7 8 | def mydecorator( f ): @functools.wraps( f ) def wrapper( *args, **kwargs ): print"Calling f", args, kwargs v = f( *args, **kwargs ) print"f returned", v return v return wrapper |
*args和**kwargs是python的特殊魔法特性。想想一个可能有未知参数数目的函数。例如，无论出于什么原因，您都希望函数对未知数量的数字求和(并且您不希望使用内置的求和函数)。所以你写这个函数：
1 2 3 4 5 | def sumFunction(*args): result = 0 for x in args: result += x return result |
它的用法类似于：sumfunction(3,4,6,3,6,8,9)。
**Kwargs具有不同的功能。使用**Kwargs，您可以为函数提供任意关键字参数，并且可以以听写方式访问它们。
1 2 3 | def someFunction(**kwargs): if 'text' in kwargs: print kwargs['text'] |
调用someFunction(text="foo")将打印foo。
假设你有一个函数，但是你不想限制它所需要的参数的数量。例子：
1 2 3 | >>> import operator >>> def multiply(*args): ... return reduce(operator.mul, args) |
然后使用如下函数：
1 2 3 4 5 6 7 8 | >>> multiply(1,2,3) 6 or >>> numbers = [1,2,3] >>> multiply(*numbers) 6 |
名称
一个方便的地方是在使用结构模块时
1 2 3 | tuple_of_data = struct.unpack(format_str, data) ... manipulate the data new_data = struct.pack(format_str, *tuple_of_data) |
如果没有这个能力，你将不得不写
1 | new_data = struct.pack(format_str, tuple_of_data[0], tuple_of_data[1], tuple_of_data[2],...) |
这也意味着，如果格式改变，元组的大小改变，我将不得不回去编辑那条真正的长线。
注意，*args/**kwargs是函数调用语法的一部分，而不是真正的运算符。这有一个我遇到的特别的副作用，即不能在print语句中使用*args扩展，因为print不是一个函数。
这似乎是合理的：
1 2 | def myprint(*args): print *args |
不幸的是，它没有编译(语法错误)。
编译：
1 2 | def myprint(*args): print args |
但是把参数打印成一个元组，这不是我们想要的。
这就是我确定的解决方案：
1 2 3 4 | def myprint(*args): for arg in args: print arg, |
这些参数通常用于代理函数，因此代理可以将任何输入参数传递给目标函数。
1 2 3 4 5 6 7 8 9 10 | def foo(bar=2, baz=5): print bar, baz def proxy(x, *args, **kwargs): # reqire parameter x and accept any number of additional arguments print x foo(*args, **kwargs) # applies the"non-x" parameter to foo proxy(23, 5, baz='foo') # calls foo with bar=5 and baz=foo proxy(6)# calls foo with its default arguments proxy(7, bar='asdas') # calls foo with bar='asdas' and leave baz default argument |
但由于这些参数隐藏了实际的参数名，所以最好避免使用它们。
您可以查看python docs(常见问题解答中的docs.python.org)，但更具体地说，为了更好地解释这个神秘的args小姐和kwargs先生(由archive.org提供)(原始的死链接就在这里)。
简而言之，当使用函数或方法的可选参数时，两者都会被使用。正如Dave所说，当您不知道可以传递多少参数时，使用*args；当您想处理由名称和值指定的参数时，使用**kwargs，如中所示：
1 | myfunction(myarg=1) |