什么是 **kwargs 的用途和使用方法？

Question

**kwargs在Python中的用途是什么？

我知道你可以对表格进行objects.filter，并传入一个**kwargs参数。

我能否也用它来指定时间增量，比如timedelta(hours = time1)？

它到底是如何工作的？它被归类为“解包”吗？就像a,b=1,2一样？

- Federer

---

在这里，有一个非常简洁的解释链接："*将所有位置参数收集到元组中"，"**将所有关键字参数收集到字典中"。关键词是 收集。 - Sergey Orshanskiy

Answer 1

你可以使用**kwargs来让你的函数接受任意数量的关键字参数（"kwargs"代表"keyword arguments"）:

>>> 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()代替iteritems()。

- Pär Wieslander

---

def print_all(**kwargs): for key, value in kwargs.items(): print(key+":"+value)**kwargs成为字典中的键值对 - Golden Lion

Answer 2

解包字典

** 可以用来解包字典。

这个方法可以将字典中的键值对解包为关键字参数传入函数。

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：附加解包概述
• Real Python: Python args and kwargs: Demystified
• 在函数签名中，变量名前面的 * 和 ** 是什么意思？

- Georg Schölly

Answer 3

kwargs只是一个添加到参数中的字典。

一个字典可以包含键值对，而这些就是kwargs。这就是它的含义。

关于它的用途则不那么简单。

例如（非常假设性地），您有一个仅调用其他例程来完成工作的接口：

def myDo(what, where, why):
   if what == 'swim':
      doSwim(where, why)
   elif what == 'walk':
      doWalk(where, why)
   ...

现在您有了一个新的方法"drive":

elif what == 'drive':
   doDrive(where, why, vehicle)

但是请稍等，现在有一个新的参数"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非常有用。

- Juergen

Answer 4

基于“有时候一个好的样例胜过于冗长的论述”的原则，我将编写两个函数，使用所有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})

- kriss

Answer 5

主题：使用*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：two
arg2：3
arg3：5

---

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

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

结果：

参数1：5
参数2：two
参数3：3

简而言之：*args 没有智能，它只是按照从左到右的顺序插入传递的参数到函数参数中；而**kwargs会在必要的位置上放置相应的值。

- kmario23

Answer 6

• kwargs参数只是一个变量名，你也可以使用**任何变量名
• kwargs代表“关键字参数”。但我认为它们更应该被称为“命名参数”，因为它们只是带有名称的参数（我没有在“关键字参数”这个术语中找到“关键字”的意义。我猜“关键字”通常指编程语言保留的单词，因此程序员不能将其用作变量名。在这里使用kwargs时不存在这种情况）。因此，我们给两个参数值命名为param1和param2，并将其与函数一起传递，如下所示：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

• 函数参数序列：
  1. 位置参数
  2. 捕获任意数量参数的形式参数（以*为前缀）
  3. 命名形式参数
  4. 捕获任意数量命名参数的形式参数（以**为前缀）

• 示例

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

传递元组和字典变量作为自定义参数

最后提一下，我们可以将"捕获任意数量参数的形式参数"作为元组变量传递，也可以将"捕获任意数量命名参数的形式参数"作为字典变量传递。

• 因此，上述调用可以改为以下方式：

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') 被原样打印。

省略字典参数:

function2("arg1",
      *tupleCustomArgs,   
      param3="arg3",
      param2="arg2", 
      dictCustomNamedArgs   #omitting **
      )

提供

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

- Mahesha999

Answer 7

此外，在调用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 必须是最后一个参数。

- philipp

Answer 8

这里有一个简单的函数，用于解释使用方法：

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

- naught101

Answer 9

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

-

Answer 10

这是一个希望有帮助的示例：

Here is an example that I hope is helpful:

#! /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] )

当你运行程序时，你会得到：

When you run the program, you get:

$ 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

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

- Jeff Silverman