**kwargs 的目的和用途是啥？ [复制]

Posted 2023-02-16

技术标签:

【中文标题】**kwargs 的目的和用途是啥？ [复制]【英文标题】：What is the purpose and use of **kwargs? [duplicate]**kwargs 的目的和用途是什么？ [复制] 【发布时间】：2010-12-18 16:06:03 【问题描述】：

**kwargs 在 Python 中有什么用途？

我知道您可以在桌子上执行 objects.filter 并传入 **kwargs 参数。

我是否也可以这样做来指定时间增量，即timedelta(hours = time1)？

它究竟是如何工作的？它是“拆包”类吗？喜欢a,b=1,2？

【问题讨论】：

一个非常简洁的解释here：“* 将所有位置参数收集在一个元组中”，“** 将所有关键字参数收集在一个字典中”。关键字是collects。 【参考方案1】：

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

字典可以包含键值对。这就是kwargs。好的，就是这样。

what for 没那么简单。

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

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

【讨论】：

【参考方案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 Tutorial 很好地解释了它的工作原理，并附有一些很好的例子。

Python 3 更新

对于 Python 3，使用 items() 代替 iteritems()

【讨论】：

def print_all(**kwargs): for key, value in kwargs.items(): print(key+\":\"+value) **kwargs 成为字典中的键/值对【参考方案3】：

解压字典

** 解包字典。

这个

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: Additional Unpacking Generalizations Real Python: Python args and kwargs: Demystified What do * and ** before a variable name mean in a function signature?

【讨论】：

【参考方案4】：

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

【讨论】：

【参考方案5】：

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 没有智能，它只是将传递的 args 插入到参数中（按从左到右的顺序），而 **kwargs 通过在所需位置放置适当的值来智能地表现

【讨论】：

【参考方案6】：

在一个好的示例有时比长篇文章更好的基础上，我将使用所有 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)

【讨论】：

【参考方案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 必须是最后一个参数

【讨论】：

【参考方案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

【讨论】：

【参考方案9】：

下面是一个例子，希望对你有帮助：

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

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

【讨论】：

【参考方案10】： **kwargs 中的 kwargs 只是变量名。你可以拥有**anyVariableName 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

函数参数的顺序：

位置参数形式参数捕获任意数量的参数（以 * 为前缀）命名形式参数形式参数捕获任意数量的命名参数（以**为前缀）

例子

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 args：

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

给予

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

【讨论】：

【参考方案11】：

这是理解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

【讨论】：

【参考方案12】：

在 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.

只是另一种思考方式。

【讨论】：

【参考方案13】：

关键字参数在 Python 中通常缩写为 kwargs。在computer programming，

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

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

Django's receiver functions 就是一个例子。

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

请注意，该函数接受一个 sender 参数以及通配符关键字参数（**kwargs）；所有信号处理程序都必须采用这些论据。所有信号都发送关键字参数，并可能改变那些随时关键字参数。对于request_finished，它是记录为不发送任何参数，这意味着我们可能很想将我们的信号处理写成 my_callback(sender)。

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

请注意，它不一定非要称为 kwargs，但必须有 **（名称 kwargs 是一种约定）。

【讨论】：

以上是关于**kwargs 的目的和用途是啥？ [复制]的主要内容，如果未能解决你的问题，请参考以下文章

JavaScript 中 eval 的预期目的是啥？ [复制]

Java内部类的用途是啥？嵌套类和内部类是一样的吗？ [复制]

python--*args与**kw

DROP、TRUNCATE 和 DELETE 之间的区别和最佳用途是啥？它们可以回滚吗？ [复制]

C#中'in'关键字的用途是啥？ [复制]

ActivityManager.isUserAMonkey() 方法的用途是啥？ [复制]