关于python:args和kwargs的使用

Use of *args and **kwargs

本问题已经有最佳答案，请猛点这里访问。

所以我很难理解*args和**kwargs的概念。

到目前为止，我了解到：

*args=参数列表-作为位置参数
**kwargs=dictionary-其键成为单独的关键字参数，值成为这些参数的值。

我不明白这对什么编程任务有帮助。

也许吧：

我想输入列表和字典作为函数的参数，同时作为通配符，这样我就可以传递任何参数了？

有没有一个简单的例子来解释如何使用*args和**kwargs？

另外，我发现的教程只使用了"*"和变量名。

*args和**kwargs是仅仅是占位符还是在代码中使用*args和**kwargs？

相关讨论

语法是*和**。名称*args和**kwargs只是按照惯例，但没有硬性要求使用它们。

当您不确定有多少参数可以传递给函数时，可以使用*args，也就是说，它允许您向函数传递任意数量的参数。例如：

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

同样，**kwargs允许您处理尚未预先定义的命名参数：

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

您也可以将这些参数与命名参数一起使用。显式参数首先获取值，然后将其他所有值传递给*args和**kwargs。命名参数在列表中位于第一位。例如：

1	def table_things(titlestring, **kwargs)

您也可以在同一个函数定义中使用这两种方法，但*args必须出现在**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

正如您在本例中看到的，它获取项目列表(或元组)并将其解包。通过这个方法，它将它们与函数中的参数相匹配。当然，在函数定义和函数调用中都可以有一个*。

相关讨论

其中一个使用*args和**kwargs非常有用的地方是子类化。

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类。

相关讨论

只有当你已经理解*和**时，这个答案才有意义。
我不明白。如果您的API发生了变化，您仍然需要更改实例化子类的所有位置。如果你要改变所有这些地方，那么你最好让孩子们的签名被修正，而不是无缘无故地与args和kwargs一起被黑客攻击。您不需要了解foo的理由是毫无意义的，因为一旦foo构造函数的集合签名更改，所有myfoo实例化调用也将更改。这需要知道foo及其构造函数需要的参数。
@ZoranPavlovic一个可以使用此功能的示例是，您正在为现有产品提供一个附加组件，并希望覆盖/扩展某些功能。通过使用*args和**kwargs，如果基础产品发生变化，此附加组件将保持功能正常。但是，实例化myfoo发生在外接程序之外。这有道理吗？(已经说过了：一个装饰师是一个更好的例子，说明何时可以使用*args和**kwargs。)
如何扩展子类的特定参数？
@例如，hananshtingart:def uuu init_uuuuuuuu(self，foo，*args，**kwargs)
对于这个特定的例子，不能保证value1和value2会通过。此外，如果传递的参数超过2个，则会引发异常。综上所述，这不是一个很好的论证转发的例子。
…然后可以创建像f = MyFoo((1,2,3),{'third':4,'fifth':5})这样的对象。这里，第一个元组(1，2，3)将作为参数转到"args"，字典稍后将转到"kwargs"。需要注意的是，像f = MyFoo(1,2,3,4,5)这样的调用是错误的，因为python解释器无法确定哪些参数应该是tuple的一部分，哪些应该属于kwargs(字典)。因此，当使用*args和**kwargs时，您几乎必须首先形成要传递的论点。如果没有**kwargs，第二个电话就可以了。
这是一个非常有限的用例，大多数人不会在您描述的场景中使用这个模式。他们会把它当作一个黑客-我见过它，它会引起很多悲伤。实际上，您甚至绕过了Python解释器提供的有限检查。

下面是一个使用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}

这里是我最喜欢使用**语法的地方之一，正如DaveWebb的最后一个示例所示：

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

名称*args和**kwargs或**kw纯粹是按惯例命名的。它使我们更容易阅读对方的代码

一个方便的地方是在使用结构模块时

struct.unpack()返回一个元组，而struct.pack()使用的参数数目可变。在操作数据时，可以方便地将元组传递到struck.pack()例如。

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,
print

相关讨论

这些参数通常用于代理函数，因此代理可以将任何输入参数传递给目标函数。

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)

相关讨论