**kwargs中的kwargs只是变量名。你很可能有**anyVariableNamekwargs代表“关键字参数”。但我觉得最好将它们称为“命名参数”，因为这些参数只是与名称一起传递的参数（我认为“关键字参数”一词中的“关键字”没有任何意义。我猜“关键字”通常是指编程语言保留的词，因此程序员不应将其用于变量名称。在kwargs的情况下，不会发生这种情况。). 所以我们给出了名字param1和param2转换为传递给函数的两个参数值：func（param1=“val1”，param2=“val2”），而不是只传递值：fun（val1，val2）。因此，我觉得它们应该被恰当地称为“任意数量的命名参数”，因为如果func具有签名func（**kwargs），我们可以指定任意数量的这些参数（即参数）

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

命名参数

命名的参数应跟随位置参数命名参数的顺序不重要实例定义函数1（param1，param2=“arg2”，param3=“arg3”）：打印（“\n”+str（param1）+“”+str（param2）+““”+str（param3）+“\n”）函数1（1）#1 arg2 arg3#1位置参数函数1（param1=1）#1 arg2 arg3#1命名arg函数1（1，param2=2）#1 2 arg3#1位置arg，1命名arg函数1（param1=1，param2=2）#1 2 arg3#2命名参数函数1（param2=2，param1=1）#1 2 arg3#2命名的args无序函数1（1，param3=3，param2=2）#1 2 3##function1（）#无效：缺少必需的参数#function1（param2=2,1）#无效：语法错误：关键字arg之后的非关键字arg#function1（1，param1=11）#无效：TypeError:function1（）为参数“param1”获取了多个值#function1（param4=4）#无效：TypeError:function1（）获得了意外的关键字参数“param4”

任意数量的命名参数kwargs

功能参数顺序：位置参数捕获任意数量参数的形式参数（前缀为*）命名的形式参数捕获任意数量的命名参数的形式参数（前缀为**）实例def函数2（param1，*tupleParams，param2，param3，**dictionaryParams）：打印（“param1:”+param1）打印（“param2:”+param2）打印（“param3:”+param3）打印（“自定义元组参数”，“-”*10）对于tupleParams中的p：打印（str（p）+“，”）打印（“自定义命名参数”，“-”*10）对于dictionaryParams.items（）中的k，v：打印（str（k）+“：”+str（v））功能2（“arg1”，“自定义参数1”，“自定义参数2”，“自定义参数3”，param3=“arg3”，param2=“arg2”，customNamedParam1=“val1”，customNamedParam2=“val2”)#输出##参数1：arg1#参数2：arg2#参数3：arg3#自定义元组参数----------#自定义参数1，#自定义参数2，#自定义参数3，#自定义命名参数----------#自定义名称参数2:val2#自定义名称参数1: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

上面的元组（“自定义参数1”、“自定义参数2”、“定制参数3”）按原样打印。

省略dict args：

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

给予

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

您可以使用**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更新

对于Python 3，使用items（）代替itertimes（）

下面是一个简单的函数，用于解释用法：

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

基于一个好的示例有时比一个长的论述更好，我将使用所有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中的kwargs只是变量名。你很可能有**anyVariableNamekwargs代表“关键字参数”。但我觉得最好将它们称为“命名参数”，因为这些参数只是与名称一起传递的参数（我认为“关键字参数”一词中的“关键字”没有任何意义。我猜“关键字”通常是指编程语言保留的词，因此程序员不应将其用于变量名称。在kwargs的情况下，不会发生这种情况。). 所以我们给出了名字param1和param2转换为传递给函数的两个参数值：func（param1=“val1”，param2=“val2”），而不是只传递值：fun（val1，val2）。因此，我觉得它们应该被恰当地称为“任意数量的命名参数”，因为如果func具有签名func（**kwargs），我们可以指定任意数量的这些参数（即参数）

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

命名参数

命名的参数应跟随位置参数命名参数的顺序不重要实例定义函数1（param1，param2=“arg2”，param3=“arg3”）：打印（“\n”+str（param1）+“”+str（param2）+““”+str（param3）+“\n”）函数1（1）#1 arg2 arg3#1位置参数函数1（param1=1）#1 arg2 arg3#1命名arg函数1（1，param2=2）#1 2 arg3#1位置arg，1命名arg函数1（param1=1，param2=2）#1 2 arg3#2命名参数函数1（param2=2，param1=1）#1 2 arg3#2命名的args无序函数1（1，param3=3，param2=2）#1 2 3##function1（）#无效：缺少必需的参数#function1（param2=2,1）#无效：语法错误：关键字arg之后的非关键字arg#function1（1，param1=11）#无效：TypeError:function1（）为参数“param1”获取了多个值#function1（param4=4）#无效：TypeError:function1（）获得了意外的关键字参数“param4”

任意数量的命名参数kwargs

功能参数顺序：位置参数捕获任意数量参数的形式参数（前缀为*）命名的形式参数捕获任意数量的命名参数的形式参数（前缀为**）实例def函数2（param1，*tupleParams，param2，param3，**dictionaryParams）：打印（“param1:”+param1）打印（“param2:”+param2）打印（“param3:”+param3）打印（“自定义元组参数”，“-”*10）对于tupleParams中的p：打印（str（p）+“，”）打印（“自定义命名参数”，“-”*10）对于dictionaryParams.items（）中的k，v：打印（str（k）+“：”+str（v））功能2（“arg1”，“自定义参数1”，“自定义参数2”，“自定义参数3”，param3=“arg3”，param2=“arg2”，customNamedParam1=“val1”，customNamedParam2=“val2”)#输出##参数1：arg1#参数2：arg2#参数3：arg3#自定义元组参数----------#自定义参数1，#自定义参数2，#自定义参数3，#自定义命名参数----------#自定义名称参数2:val2#自定义名称参数1: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

上面的元组（“自定义参数1”、“自定义参数2”、“定制参数3”）按原样打印。

省略dict args：

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

给予

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

下面是一个我希望有帮助的例子：

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

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