Python中的**kwargs有什么用途?
我知道你可以在表上执行objects.filter并传递一个**kwargs参数。
我也可以这样做来指定时间增量,即时间增量(小时=时间1)吗?
它到底是如何工作的?是否归类为“开箱”?比如a,b=1,2?
Python中的**kwargs有什么用途?
我知道你可以在表上执行objects.filter并传递一个**kwargs参数。
我也可以这样做来指定时间增量,即时间增量(小时=时间1)吗?
它到底是如何工作的?是否归类为“开箱”?比如a,b=1,2?
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函数的签名中。
在这里,您可以将夸rgs放入游戏中——只需将夸rg斯添加到签名中即可:
def myDo(what, where, why, **kwargs):
if what == 'drive':
doDrive(where, why, **kwargs)
elif what == 'swim':
doSwim(where, why, **kwargs)
这样,您就不需要在每次调用的某些例程发生更改时更改接口函数的签名。
这只是一个很好的例子,你会发现夸尔格很有用。
您可以使用**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,使用items()代替itertimes()
正在解压缩词典
**拆开词典。
This
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)
函数的包装参数
对python 3使用.items()而不是.iteritems()
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。
资源
PEP 448:其他解包概括真实Python:Python args和kwargs:解密在函数签名中,变量名前的*和**意味着什么?
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:两个参数2:3参数3:5
现在,使用**kwargs调用相同的函数
#keyword argument "kwargs" has to be a dictionary
>>> kwargs = {"arg3":3, "arg2":'two', "arg1":5}
>>> args_kwargs_test(**kwargs)
结果:
arg1:5arg2:两个参数3:3
底线:*args没有智能,它只是将传递的args插入到参数中(按从左到右的顺序),而**kwargs通过在所需位置放置适当的值来智能地执行操作
基于一个好的示例有时比一个长的论述更好,我将使用所有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})
此外,您还可以在调用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必须是最后一个参数
下面是一个简单的函数,用于解释用法:
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
这里的关键是调用中命名参数的可变数量转换为函数中的字典。
**kwargs中的kwargs只是变量名。你很可能有**anyVariableNamekwargs代表“关键字参数”。但我觉得最好将它们称为“命名参数”,因为这些参数只是与名称一起传递的参数(我认为“关键字参数”一词中的“关键字”没有任何意义。我猜“关键字”通常是指编程语言保留的词,因此程序员不应将其用于变量名称。在kwargs的情况下,不会发生这种情况。). 所以我们给出了名字param1和param2转换为传递给函数的两个参数值:func(param1=“val1”,param2=“val2”),而不是只传递值:fun(val1,val2)。因此,我觉得它们应该被恰当地称为“任意数量的命名参数”,因为如果func具有签名func(**kwargs),我们可以指定任意数量的这些参数(即参数)
因此,让我先解释“命名参数”,然后解释“任意数量的命名参数”。
命名参数
命名的参数应跟随位置参数命名参数的顺序不重要实例定义函数1(param1,param2=“arg2”,param3=“arg3”):打印(“\n”+str(param1)+“”+str(param2)+““”+str(param3)+“\n”)函数1(1)#1 arg2 arg3#1位置参数函数1(param1=1)#1 arg2 arg3#1命名arg函数1(1,param2=2)#1 2 arg3#1位置arg,1命名arg函数1(param1=1,param2=2)#1 2 arg3#2命名参数函数1(param2=2,param1=1)#1 2 arg3#2命名的args无序函数1(1,param3=3,param2=2)#1 2 3##function1()#无效:缺少必需的参数#function1(param2=2,1)#无效:语法错误:关键字arg之后的非关键字arg#function1(1,param1=11)#无效:TypeError:function1()为参数“param1”获取了多个值#function1(param4=4)#无效:TypeError:function1()获得了意外的关键字参数“param4”
任意数量的命名参数kwargs
功能参数顺序:位置参数捕获任意数量参数的形式参数(前缀为*)命名的形式参数捕获任意数量的命名参数的形式参数(前缀为**)实例def函数2(param1,*tupleParams,param2,param3,**dictionaryParams):打印(“param1:”+param1)打印(“param2:”+param2)打印(“param3:”+param3)打印(“自定义元组参数”,“-”*10)对于tupleParams中的p:打印(str(p)+“,”)打印(“自定义命名参数”,“-”*10)对于dictionaryParams.items()中的k,v:打印(str(k)+“:”+str(v))功能2(“arg1”,“自定义参数1”,“自定义参数2”,“自定义参数3”,param3=“arg3”,param2=“arg2”,customNamedParam1=“val1”,customNamedParam2=“val2”)#输出##参数1:arg1#参数2:arg2#参数3:arg3#自定义元组参数----------#自定义参数1,#自定义参数2,#自定义参数3,#自定义命名参数----------#自定义名称参数2:val2#自定义名称参数1:val1
为自定义参数传递元组和dict变量
最后,我还要指出,我们可以通过
“捕获任意数量参数的形式参数”作为元组变量“捕获任意数量的命名参数的形式参数”作为dict变量
因此,可以如下进行上述相同的调用:
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
上面的元组(“自定义参数1”、“自定义参数2”、“定制参数3”)按原样打印。
省略dict args:
function2("arg1",
*tupleCustomArgs,
param3="arg3",
param2="arg2",
dictCustomNamedArgs #omitting **
)
给予
dictCustomNamedArgs
^
SyntaxError: non-keyword arg after keyword arg
这是了解python解包的简单示例,
>>> def f(*args, **kwargs):
... print 'args', args, 'kwargs', kwargs
eg1:
>>>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
在Java中,使用构造函数重载类并允许多个输入参数。在python中,可以使用kwargs来提供类似的行为。
java示例:https://beginnersbook.com/2013/05/constructor-overloading/
python示例:
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.
只是另一种思考方式。
关键字Arguments在Python中通常缩写为kwargs。在计算机编程中,
关键字参数是指计算机语言对函数的支持调用,明确说明函数调用。
在参数名**kwargs之前使用两个星号是因为不知道有多少关键字参数将传递到函数中。在这种情况下,它被称为任意/通配符关键字参数。
Django的接收器函数就是一个例子。
def my_callback(sender, **kwargs):
print("Request finished!")
注意,该函数接受sender参数和通配符关键字参数(**kwargs);所有信号处理程序都必须接受这些论据。所有信号都发送关键字参数,并可能更改这些参数关键字参数。在request_finished的情况下记录为不发送参数,这意味着我们可能会将我们的信号处理写成mycallback(sender)。这是错误的——事实上,如果你这样做,Django会抛出错误这是因为在任何时候,参数都可以添加到信号和接收器必须能够处理这些新参数。
注意,它不必被称为kwargs,但它需要有**(kwargs这个名称是一个惯例)。