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

**kwargsPython 的用途是什么？

我知道您可以objects.filter在表上进行传递**kwargs参数。  

我还可以指定时间增量timedelta(hours = time1)吗？

它是如何工作的？它被归类为“拆包”吗？喜欢a,b=1,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指南，包含了如何工作的，有一些很好的例子沿着一个很好的解释。

<-更新->

对于使用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.address
func(**args)  # either expanded to func(name=person.name) or
              #                    func(name=person.name, address=person.address)

函数的打包参数

def setstyle(**styles):
    for key, value in styles.iteritems():      # styles is a regular dictionary
        setattr(someobject, key, value)

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

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

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

基于好的样本有时比冗长的论述更好，我将使用所有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})

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通过将适当的值放在所需的位置@来智能地运行

• kwargs在**kwargs只是变量名。你可以很好地拥有**anyVariableName
• kwargs代表“关键字参数”。但是我觉得最好将它们称为“命名参数”，因为它们只是随名称一起传递的参数（我对“关键字参数”一词中的“关键字”一词没有任何意义。我猜“关键字”通常是指编程语言保留的单词，因此程序员不要将其用于变量名。因此，我们给名称 param1和param2两个传递给函数的参数值如下：func(param1="val1",param2="val2")，而不是仅传递值：func(val1,val2)。因此，我认为应将它们适当地称为“命名参数的任意数量”，因为我们可以指定任意数量的这些参数（即，funcfunc(**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 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

为自定义参数传递元组和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

元组上方('custom param1', 'custom param2', 'custom param3')按原样打印。

省略dict参数：

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

给

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

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

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

这是一个用于解释用法的简单函数：

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

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

这是了解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.

只是另一种思考方式。

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

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

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

Django的接收器函数就是一个例子。

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

请注意，该函数带有一个sender参数以及通配符关键字参数（** kwargs）；所有信号处理程序都必须采用这些参数。所有信号都发送关键字参数，并且可以随时更改这些关键字参数。在request_finished的情况下，它被记录为不发送任何参数，这意味着我们可能很想将信号处理编写为my_callback（sender）。

这将是错误的-实际上，如果您这样做，Django将抛出错误。这是因为在任何时候都可以将参数添加到信号中，并且您的接收器必须能够处理这些新参数。

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