**kwargs的目的和用途是什么？

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很有帮助。

您可以使用**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 = Johnlast_name = Doe

您还可以在调用函数时使用**kwargs语法，方法是构建关键字参数字典并将其传递给您的函数：

>>> kwargs = {'first_name': 'Bobby', 'last_name': 'Smith'}>>> print_keyword_args(**kwargs)first_name = Bobbylast_name = Smith

python教程包含了对它如何工作的很好的解释，以及一些很好的例子。

python3更新

对于Python 3，使用items()而不是iteritems()

解压缩字典

**解包字典。

这个

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.addressfunc(**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 dictionarysetattr(someobject, key, value)

这允许您像这样使用函数：

setstyle(color="red", bold=False)

备注

• kwargs是用于关键字参数的变量名，可以使用另一个变量名。重要的是它是一个字典，并且使用双星号运算符**解压缩。
• 其他可迭代对象使用单个星号运算符*解压缩
• 为了防止混淆，最好分别为字典和其他可迭代对象使用已识别的变量名kwargs和args。

资源

• PEP 448：额外的解包概括
• 真正的Python：Python args和kwargs：揭秘
• 变量名前的*和**在函数签名中是什么意思？

kwargs是一种语法糖，用于将名称参数作为字典传递（对于func），或将字典作为命名参数传递（对于func）

Motif：*args和**kwargs作为需要传递给函数调用的参数的占位符

使用*args和**kwargs调用函数

def args_kwargs_test(arg1, arg2, arg3):print "arg1:", arg1print "arg2:", arg2print "arg3:", arg3

现在我们将使用*args调用上面定义的函数

#args can either be a "list" or "tuple">>> args = ("two", 3, 5)>>> args_kwargs_test(*args)

结果：

art1:2
Arg2:3
Arg3:5

现在，使用**kwargs调用相同的函数

#keyword argument "kwargs" has to be a dictionary>>> kwargs = {"arg3":3, "arg2":'two', "arg1":5}>>> args_kwargs_test(**kwargs)

结果：

art1:5
arg2:2
Arg3:3

底线：*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 )

给出这个输出：

123

注意**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 kwargsprint ( "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.pyIn g ready to print kwargs{'a': 'red', 'c': 'Nassau', 'b': 5}in g, calling fin f, printing kwargs{'a': 'red', 'c': 'Nassau', 'b': 5}In f, after printing kwargsIn g, after returning from fIn g ready to print kwargs{'q': 'purple', 'c': 'Charlie', 'd': [4, 3, 6], 'w': 'W'}in g, calling fin f, printing kwargs{'q': 'purple', 'c': 'Charlie', 'd': [4, 3, 6], 'w': 'W'}In f, after printing kwargsIn g, after returning from f

这里的关键是调用中命名参数的可变数量转换为函数中的字典。

• **kwargs中的kwargs只是变量名。你很可能有**anyVariableName
• kwargs代表“关键字参数”。但我觉得它们最好被称为“命名参数”，因为这些只是与名称一起传递的参数（我没有发现术语“关键字参数”中的“关键字”有任何意义。我想“关键字”通常意味着编程语言保留的单词，因此程序员不会用于变量名。在kwargs的情况下没有这样的事情发生。）。所以我们给名字param1和param2传递给函数的两个参数值如下：func(param1="val1",param2="val2")，而不是只传递值：func(val1,val2)。因此，我觉得它们应该被适当地称为"任意数量的命名参数"，因为如果func有签名func(**kwargs)，我们可以指定任意数量的这些参数（即参数）

所以说，让我先解释“命名参数”，然后解释“任意数量的命名参数”kwargs。

命名参数

• 命名args应该跟随位置args
• 命名args的顺序不重要

• 示例

  def function1(param1,param2="arg2",param3="arg3"):print("\n"+str(param1)+" "+str(param2)+" "+str(param3)+"\n")
  function1(1)                      #1 arg2 arg3   #1 positional argfunction1(param1=1)               #1 arg2 arg3   #1 named argfunction1(1,param2=2)             #1 2 arg3      #1 positional arg, 1 named argfunction1(param1=1,param2=2)      #1 2 arg3      #2 named argsfunction1(param2=2, param1=1)     #1 2 arg3      #2 named args out of orderfunction1(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'

Arbitrary number of named arguments kwargs

• Sequence of function parameters:
  1. positional parameters
  2. formal parameter capturing arbitrary number of arguments (prefixed with *)
  3. named formal parameters
  4. formal parameter capturing arbitrary number of named parameters (prefixed with **)

• Example

  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

Passing tuple and dict variables for custom args

To finish it up, let me also note that we can pass

• "formal parameter capturing arbitrary number of arguments" as tuple variable and
• "formal parameter capturing arbitrary number of named parameters" as dict variable

Thus the same above call can be made as follows:

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: arg1param2: arg2param3: arg3custom tuple params ----------('custom param1', 'custom param2', 'custom param3'),custom named params ----------customNamedParam2:val2customNamedParam1: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

这是理解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 kwargdef __init__(self,name, color='red'):self.name = nameself.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.

只是另一种思考它的方式。

关键字参数在Python中通常缩写为kwargs。在计算机编程中，

关键字参数指的是计算机语言对函数的支持调用，清楚地说明每个参数的名称函数调用。

在参数名**kwargs之前使用两个星号是当不知道将有多少关键字参数传递给函数时。在这种情况下，它被称为任意/通配符关键字参数。

一个例子是Django的接收器功能。

def my_callback(sender, **kwargs):print("Request finished!")

请注意，该函数接受一个sender参数，以及通配符关键字参数（**kwargs）；所有信号处理程序都必须采用这些参数论点。所有信号都发送关键字参数，并可能更改这些参数关键字参数。在request_finished的情况下，它是记录为不发送参数，这意味着我们可能会受到诱惑将我们的信号处理写为my_callback（发送者）。

这是错误的-事实上，如果你这样做，Django会抛出错误所以。那是因为在任何时候，参数都可能被添加到您的接收器必须能够处理这些新参数。

请注意，它不必被称为kwargs，但它需要有**（名称kwargs是一个约定）。