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

Python中的

**kwargs

有什么用途

我知道您可以对表执行

对象。筛选
，并传入
**kwargs
参数

我也可以这样做来指定时间增量，即
timedelta（hours=time1）

它到底是如何工作的？它是“解包”类吗？与
a一样，b=1,2
？
kwargs只是一个添加到参数中的字典

字典可以包含键、值对。那是夸尔格家。好的，就是这样

原因并不是那么简单

例如（非常假设），您有一个接口，该接口仅调用其他例程来执行此任务：

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

现在您得到了一个新方法“drive”：

但是等一下，有一个新的参数“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”表示“关键字参数”）：

通过构造关键字参数字典并将其传递给函数，调用函数时也可以使用
**kwargs
语法：

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

包含了一个很好的解释，以及一些很好的例子

Python3更新
对于Python3，使用解包字典代替
iteritems（）
**
解压字典

这个

与

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.iteritems（）中的值：#styles是一个常规字典
setattr（someobject、key、value）

这使您可以使用如下功能：

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


笔记

kwargs
是用于关键字参数的变量名，可以使用另一个变量名。重要的一点是它是一本字典，并用双星号运算符
**
解包
其他iterables使用单个星号运算符展开
*
为了避免混淆，对于字典和其他iterables，最好分别使用公认的变量名
kwargs
和
args


资源




kwargs是一种语法糖，可以将名称参数作为字典（用于func）传递，或将字典作为命名参数（用于func）
Motif:
*args
和
**kwargs
用作需要传递给函数调用的参数的占位符

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

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

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

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

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

#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
通过在所需位置放置适当的值来智能地执行操作，但基于一个好的示例有时比一篇长的论述要好，我将使用所有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
只是变量名。您完全可以使用
**anyVariableName
kwargs
代表“关键字参数”。但是我觉得它们最好被称为“命名参数”，因为它们只是随名称一起传递的参数（我觉得“关键字参数”一词中的“关键字”没有任何意义。我猜是“关键字”通常指编程语言保留的单词，因此程序员不会将其用于变量名。在kwargs的情况下，不会发生这种情况。）。所以我们给出名字
param1
和
param2
传递给函数的两个参数值如下：
func（param1=“val1”，param2=“val2”）
，而不是只传递值：
func（val1，val2）
。因此，我觉得应该适当地将它们称为“任意数量的命名参数”，因为如果
func
具有签名
func（**kwargs）

因此，让我先解释“命名参数”，然后解释“任意数量的命名参数”
kwargs

命名参数


命名的参数应该跟在位置参数后面
命名参数的顺序并不重要
<
$ 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

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'

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

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

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

>>> def f(*args, **kwargs):
...    print 'args', args, 'kwargs', kwargs

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

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.

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