**kwargsPython中有什么用途？
我知道你可以objects.filter在桌子上做一个并传递一个**kwargs论点。
我也可以这样做来指定时间增量timedelta(hours = time1)吗？
它究竟是如何工作的？它是“拆包”类吗？喜欢a,b=1,2？
问问题
641505 次
13 回答
912
您可以使用**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 教程包含了一个很好的解释它是如何工作的，以及一些很好的例子。
Python 3 更新
对于 Python 3，iteritems()使用items()
于 2009-11-20T09:58:18.500 回答
361
解包字典
**解包字典。
这
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)
函数的封装参数
- 使用
.items()而不是.iteritems()用于 python 3
def setstyle(**styles):
for key, value in styles.iteritems(): # styles is a regular dictionary
setattr(someobject, key, value)
这使您可以像这样使用函数：
setstyle(color="red", bold=False)
笔记
kwargs是用于关键字参数的变量名，可以使用另一个变量名。重要的部分是它是一个字典，它是用双星号运算符解包的**。- 其他可迭代对象使用单个星号运算符解包
* - 为防止混淆，最好分别使用已识别的变量名称
kwargs和args, 用于字典和其他可迭代对象。
资源
于 2009-11-20T09:59:16.390 回答
70
kwargs 只是一个添加到参数的字典。
字典可以包含键值对。这就是kwargs。好的，就是这样。
什么是不那么简单的。
例如（非常假设）您有一个接口，它只调用其他例程来完成这项工作：
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 ——您只需将 kwargs 添加到签名中：
def myDo(what, where, why, **kwargs):
if what == 'drive':
doDrive(where, why, **kwargs)
elif what == 'swim':
doSwim(where, why, **kwargs)
这样，您无需在每次调用的某些例程可能发生更改时更改接口函数的签名。
这只是一个很好的例子，你会发现 kwargs 很有帮助。
于 2009-11-20T09:51:25.340 回答
53
基于一个好的示例有时比长篇文章更好，我将使用所有 python 变量参数传递工具（位置参数和命名参数）编写两个函数。您应该能够轻松地自己看到它的作用：
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})
于 2014-01-24T16:56:02.530 回答
32
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用于调用相同的函数
#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通过在所需位置放置适当的值来智能地表现
于 2014-01-06T06:57:50.097 回答
24
kwargsin**kwargs只是变量名。你可以很好地拥有**anyVariableNamekwargs代表“关键字参数”。但我觉得最好将它们称为“命名参数”，因为这些只是与名称一起传递的参数（我认为“关键字参数”一词中的“关键字”一词没有任何意义。我猜“关键字”通常意味着由编程语言保留的单词，因此程序员不能将其用于变量名。在 kwargs 的情况下，这里不会发生这种情况。）。所以我们给传递给函数的两个参数值命名param1，param2如下所示：func(param1="val1",param2="val2")，而不是只传递值：func(val1,val2)。因此，我觉得它们应该被恰当地称为“任意数量的命名参数”，因为我们可以指定任意数量的这些参数（也就是说，funcfunc(**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
- 函数参数顺序：
- 位置参数
- 形式参数捕获任意数量的参数（以 * 为前缀）
- 命名形式参数
- 形式参数捕获任意数量的命名参数（以 ** 为前缀）
例子
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
为自定义参数传递元组和字典变量
为了完成它，我还要注意我们可以通过
- “形式参数捕获任意数量的参数”作为元组变量和
- “形式参数捕获任意数量的命名参数”作为dict变量
因此，可以按如下方式进行上述相同的调用：
tupleCustomArgs = ("custom param1", "custom param2", "custom param3")
dictCustomNamedArgs = {"customNamedParam1":"val1", "customNamedParam2":"val2"}
function2("arg1",
*tupleCustomArgs, #note *
param3="arg3",
param2="arg2",
**dictCustomNamedArgs #note **
)
最后注意*和**在上面的函数调用中。如果我们忽略它们，我们可能会得到不好的结果。
*在元组 args 中省略：
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
于 2016-09-20T07:19:29.250 回答
9
另外，在调用 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 必须是最后一个参数
于 2015-02-25T09:45:23.173 回答
6
这是一个用于解释用法的简单函数：
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
于 2015-11-27T06:15:50.050 回答
5
kwargs 是一种语法糖，可以将名称参数作为字典（用于 func）或字典作为命名参数（用于 func）传递
于 2009-11-20T10:39:06.287 回答
1
这是一个示例，希望对您有所帮助：
#! /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
这里的关键是调用中可变数量的命名参数转换为函数中的字典。
于 2016-05-26T21:37:28.957 回答
1
在 Python 中，关键字参数通常缩写为kwargs 。在计算机编程中，
关键字参数是指计算机语言对函数调用的支持，这些函数调用清楚地说明了函数调用中每个参数的名称。
参数名称前的两个星号**kwargs的用法是当人们不知道将有多少关键字参数传递给函数时。在这种情况下，它被称为任意/通配符关键字参数。
一个例子是Django 的接收器函数。
def my_callback(sender, **kwargs):
print("Request finished!")
请注意，该函数采用 sender 参数以及通配符关键字参数 (**kwargs)；所有信号处理程序都必须采用这些参数。所有信号都发送关键字参数，并且可以随时更改这些关键字参数。在request_finished的情况下，它被记录为不发送任何参数，这意味着我们可能很想将我们的信号处理编写为 my_callback(sender)。
这是错误的——事实上，如果你这样做，Django 会抛出一个错误。那是因为在任何时候参数都可以添加到信号中，并且您的接收器必须能够处理这些新参数。
请注意，它不必被称为kwargs，但它需要有 ** （名称kwargs是一个约定）。
于 2020-04-20T05:16:43.193 回答
0
这是了解python解包的简单示例，
>>> def f(*args, **kwargs):
... print 'args', args, 'kwargs', kwargs
例1：
>>>f(1, 2)
>>> args (1,2) kwargs {} #args return parameter without reference as a tuple
>>>f(a = 1, b = 2)
>>> args () kwargs {'a': 1, 'b': 2} #args is empty tuple and kwargs return parameter with reference as a dictionary
于 2019-04-23T14:09:05.680 回答
0
在 Java 中，您使用构造函数来重载类并允许多个输入参数。在 python 中，您可以使用 kwargs 来提供类似的行为。
java示例：https ://beginnersbook.com/2013/05/constructor-overloading/
蟒蛇示例：
class Robot():
# name is an arg and color is a kwarg
def __init__(self,name, color='red'):
self.name = name
self.color = color
red_robot = Robot('Bob')
blue_robot = Robot('Bob', color='blue')
print("I am a {color} robot named {name}.".format(color=red_robot.color, name=red_robot.name))
print("I am a {color} robot named {name}.".format(color=blue_robot.color, name=blue_robot.name))
>>> I am a red robot named Bob.
>>> I am a blue robot named Bob.
只是另一种思考方式。
于 2020-01-10T03:34:12.853 回答