您可以使用**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（）

关键字Arguments在Python中通常缩写为kwargs。在计算机编程中，

关键字参数是指计算机语言对函数的支持调用，明确说明函数调用。

在参数名**kwargs之前使用两个星号是因为不知道有多少关键字参数将传递到函数中。在这种情况下，它被称为任意/通配符关键字参数。

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

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

注意，该函数接受sender参数和通配符关键字参数（**kwargs）；所有信号处理程序都必须接受这些论据。所有信号都发送关键字参数，并可能更改这些参数关键字参数。在request_finished的情况下记录为不发送参数，这意味着我们可能会将我们的信号处理写成mycallback（sender）。这是错误的——事实上，如果你这样做，Django会抛出错误这是因为在任何时候，参数都可以添加到信号和接收器必须能够处理这些新参数。

注意，它不必被称为kwargs，但它需要有**（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函数时混合使用不同的用法：

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

基于一个好的示例有时比一个长的论述更好，我将使用所有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})