在Python中理解kwargs
Python中的**kwargs什么用途？
我知道你可以在表上做一个objects.filter ，并传入一个**kwargs参数。
我也可以这样做，指定时间delta，即timedelta(hours = time1) ？
它究竟是如何工作的？ 它是类作为“拆包”？ 像a,b=1,2一样a,b=1,2 ？
您可以使用**kwargs让您的函数获取任意数量的关键字参数（“kwargs”意思是“关键字参数”）：
>>> def print_keyword_args(**kwargs): ... # kwargs is a dict of the keyword args passed to the function ... for key, value in kwargs.iteritems(): ... print "%s = %s" % (key, value) ... >>> print_keyword_args(first_name="John", last_name="Doe") first_name = John last_name = Doe
您也可以在调用函数时使用**kwargs语法，方法是构造关键字参数字典并将其传递给函数：
>>> kwargs = {'first_name': 'Bobby', 'last_name': 'Smith'} >>> print_keyword_args(**kwargs) first_name = Bobby last_name = Smith
Python教程包含了一个很好的解释，以及一些很好的例子。
开箱字典
**解压词典。
这个
func(a=1, b=2, c=3)
是相同的
args = {'a': 1, 'b': 2, 'c':3} func(**args)
如果你必须构造参数，这是很有用的：
args = {'name': person.name} if hasattr(person, "address"): args["address"] = person.address func(**args) # either expanded to func(name=person.name) or # func(name=person.name, address=person.address)
打包一个函数的参数
def setstyle(**styles): for key, value in styles.iteritems(): # styles is a regular dictionary setattr(someobject, key, value)
这可以让你使用这样的function：
setstyle(color="red", bold=False)
kwargs只是一个被添加到参数中的字典。
字典可以包含键值对。 那就是kwargs。 好的，这是如何。
whatfor不是那么简单。
例如（非常假设）你有一个接口，只是调用其他例程来完成这项工作：
def myDo(what, where, why): if what == 'swim': doSwim(where, why) elif what == 'walk': doWalk(where, why) ...
现在你得到一个新的方法“驱动器”：
elif what == 'drive': doDrive(where, why, vehicle)
但等一下，有一个新的参数“车辆” – 你以前不知道。 现在您必须将其添加到myDo函数的签名中。
在这里，你可以投入克瓦格斯 – 你只需要添加kwargs到签名：
def myDo(what, where, why, **kwargs): if what == 'drive': doDrive(where, why, **kwargs) elif what == 'swim': doSwim(where, why, **kwargs)
这样你就不必每次调用一些被调用的函数就改变接口函数的签名。
这只是一个很好的例子，你可以findkwargs有帮助。
基于一个好的样本有时比一个长篇大论更好，我将使用所有的pythonvariablesparameter passing工具（包括位置参数和命名参数）来编写两个函数。 你应该很容易就能看到自己做了什么：
def f(a = 0, *args, **kwargs): print("Received by f(a, *args, **kwargs)") print("=> f(a=%s, args=%s, kwargs=%s" % (a, args, kwargs)) print("Calling g(10, 11, 12, *args, d = 13, e = 14, **kwargs)") g(10, 11, 12, *args, d = 13, e = 14, **kwargs) def g(f, g = 0, *args, **kwargs): print("Received by g(f, g = 0, *args, **kwargs)") print("=> g(f=%s, g=%s, args=%s, kwargs=%s)" % (f, g, args, kwargs)) print("Calling f(1, 2, 3, 4, b = 5, c = 6)") f(1, 2, 3, 4, b = 5, c = 6)
这里是输出：
Calling f(1, 2, 3, 4, b = 5, c = 6) Received by f(a, *args, **kwargs) => f(a=1, args=(2, 3, 4), kwargs={'c': 6, 'b': 5} Calling g(10, 11, 12, *args, d = 13, e = 14, **kwargs) Received by g(f, g = 0, *args, **kwargs) => g(f=10, g=11, args=(12, 2, 3, 4), kwargs={'c': 6, 'b': 5, 'e': 14, 'd': 13})
Motif： *args和**kwargs作为需要传递给函数调用的参数的占位符
使用*args和**kwargs来调用一个函数
def args_kwargs_test(arg1, arg2, arg3): print "arg1:", arg1 print "arg2:", arg2 print "arg3:", arg3
现在我们将使用*args来调用上面定义的函数
#args can either be a "list" or "tuple" >>> args = ("two", 3, 5) >>> args_kwargs_test(*args)
结果：
arg1：两个
arg2：3
arg3：5
现在，使用**kwargs来调用相同的function
#keyword argument "kwargs" has to be a dictionary >>> kwargs = {"arg3":3, "arg2":'two', "arg1":5} >>> args_kwargs_test(**kwargs)
结果：
arg1：5
arg2：二
arg3：3
底线： *args没有智能，它只是将传递的参数插入到参数中（按照从左到右的顺序），而**kwargs通过在需要的地方放置适当的值来智能地行为
-
**kwargs只是variables名称。 你可以拥有**anyVariableName -
kwargs代表“关键字参数”。 但是我觉得他们应该被称为“命名参数”，因为这些参数只是与名称一起传递的（在“关键字参数”一词中，我没有发现“关键字”这个词的任何意义。这些字是由编程语言保留的，因此不能被程序员用于variables名。在kwargs的情况下，这里没有这样的事情发生）。func(param1="val1",param2="val2")而不是func(val1,val2)。 我觉得他们应该适当地称为“任意数量的命名参数”，因为我们可以指定任何数量的这些如果func具有签名func(**kwargs)
所以说，让我先解释“命名的争论”，然后“任意数量的命名的争论” kwargs 。
命名的参数
- 命名参数应遵循位置参数
- 命名参数的顺序并不重要
-
例
def function1(param1,param2="arg2",param3="arg3"): print("\n"+str(param1)+" "+str(param2)+" "+str(param3)+"\n") function1(1) #1 arg2 arg3 #1 positional arg function1(param1=1) #1 arg2 arg3 #1 named arg function1(1,param2=2) #1 2 arg3 #1 positional arg, 1 named arg function1(param1=1,param2=2) #1 2 arg3 #2 named args function1(param2=2, param1=1) #1 2 arg3 #2 named args out of order function1(1, param3=3, param2=2) #1 2 3 # #function1() #invalid: required argument missing #function1(param2=2,1) #invalid: SyntaxError: non-keyword arg after keyword arg #function1(1,param1=11) #invalid: TypeError: function1() got multiple values for argument 'param1' #function1(param4=4) #invalid: TypeError: function1() got an unexpected keyword argument 'param4'
任意数量的命名参数kwargs
- function参数序列：
- 位置参数
- 捕获任意数量参数的forms参数（以*为前缀）
- 命名forms参数
- 捕获任意数量的命名参数的forms参数（以**为前缀）
-
例
def function2(param1, *tupleParams, param2, param3, **dictionaryParams): print("param1: "+ param1) print("param2: "+ param2) print("param3: "+ param3) print("custom tuple params","-"*10) for p in tupleParams: print(str(p) + ",") print("custom named params","-"*10) for k,v in dictionaryParams.items(): print(str(k)+":"+str(v)) function2("arg1", "custom param1", "custom param2", "custom param3", param3="arg3", param2="arg2", customNamedParam1 = "val1", customNamedParam2 = "val2" ) # Output # #param1: arg1 #param2: arg2 #param3: arg3 #custom tuple params ---------- #custom param1, #custom param2, #custom param3, #custom named params ---------- #customNamedParam2:val2 #customNamedParam1:val1
传递元组和字典variables的自定义参数
为了完成它，让我也注意到，我们可以通过
- 捕获任意数量参数的forms参数“作为元组variables和
- “forms参数捕获任意数量的命名参数”作为字典variables
因此，上述呼叫可以如下进行：
tupleCustomArgs = ("custom param1", "custom param2", "custom param3") dictCustomNamedArgs = {"customNamedParam1":"val1", "customNamedParam2":"val2"} function2("arg1", *tupleCustomArgs, #note * param3="arg3", param2="arg2", **dictCustomNamedArgs #note ** )
最后在上面的函数调用中注意*和** 。 如果我们忽略它们，我们可能会得到不好的结果。
省略*元组参数：
function2("arg1", tupleCustomArgs, #omitting * param3="arg3", param2="arg2", **dictCustomNamedArgs )
版画
param1: arg1 param2: arg2 param3: arg3 custom tuple params ---------- ('custom param1', 'custom param2', 'custom param3'), custom named params ---------- customNamedParam2:val2 customNamedParam1:val1
上面的元组('custom param1', 'custom param2', 'custom param3')按原样打印。
省略dict参数：
function2("arg1", *tupleCustomArgs, param3="arg3", param2="arg2", dictCustomNamedArgs #omitting ** )
给
dictCustomNamedArgs ^ SyntaxError: non-keyword arg after keyword arg
另外，在调用kwargs函数时，还可以混合不同的使用方式：
def test(**kwargs): print kwargs['a'] print kwargs['b'] print kwargs['c'] args = { 'b': 2, 'c': 3} test( a=1, **args )
给出这个输出：
1 2 3
请注意** kwargs必须是最后一个参数
kwargs是将名称参数作为字典（for func）传递的语法糖，或者是作为命名参数（to func）的字典。
这里有一个简单的函数来解释用法：
def print_wrap(arg1, *args, **kwargs): print(arg1) print(args) print(kwargs) print(arg1, *args, **kwargs)
任何未在函数定义中指定的参数将被放入args列表或kwargs列表中，具体取决于它们是否是关键字参数：
>>> print_wrap('one', 'two', 'three', end='blah', sep='--') one ('two', 'three') {'end': 'blah', 'sep': '--'} one--two--threeblah
如果添加一个永远不会传递给函数的关键字参数，将会引发错误：
>>> print_wrap('blah', dead_arg='anything') TypeError: 'dead_arg' is an invalid keyword argument for this function
这是一个我希望有用的例子：
#! /usr/bin/env python # def g( **kwargs) : print ( "In g ready to print kwargs" ) print kwargs print ( "in g, calling f") f ( **kwargs ) print ( "In g, after returning from f") def f( **kwargs ) : print ( "in f, printing kwargs") print ( kwargs ) print ( "In f, after printing kwargs") g( a="red", b=5, c="Nassau") g( q="purple", w="W", c="Charlie", d=[4, 3, 6] )
当你运行程序时，你会得到：
$ python kwargs_demo.py In g ready to print kwargs {'a': 'red', 'c': 'Nassau', 'b': 5} in g, calling f in f, printing kwargs {'a': 'red', 'c': 'Nassau', 'b': 5} In f, after printing kwargs In g, after returning from f In g ready to print kwargs {'q': 'purple', 'c': 'Charlie', 'd': [4, 3, 6], 'w': 'W'} in g, calling f in f, printing kwargs {'q': 'purple', 'c': 'Charlie', 'd': [4, 3, 6], 'w': 'W'} In f, after printing kwargs In g, after returning from f
这里的关键是在调用中可变数目的命名参数转换成函数中的字典。
