4.8.2. 关键字参数

【原文】

4.8.2. Keyword Arguments

Functions can also be called using keyword arguments of the form kwarg=value. For instance, the following function:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):

    print("-- This parrot wouldn't", action, end=' ')

    print("if you put", voltage, "volts through it.")

    print("-- Lovely plumage, the", type)

    print("-- It's", state, "!")

accepts one required argument (voltage) and three optional arguments (state, action, and type). This function can be called in any of the following ways:

parrot(1000)                                          # 1 positional argument

parrot(voltage=1000)                                  # 1 keyword argument

parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments

parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments

parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments

parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

but all the following calls would be invalid:

parrot()                     # required argument missing

parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument

parrot(110, voltage=220)     # duplicate value for the same argument

parrot(actor='John Cleese')  # unknown keyword argument

In a function call, keyword arguments must follow positional arguments. All the keyword arguments passed must match one of the arguments accepted by the function (e.g. actor is not a valid argument for the parrot function), and their order is not important. This also includes non-optional arguments (e.g. parrot(voltage=1000) is valid too). No argument may receive a value more than once. Here’s an example that fails due to this restriction:

>>>

>>> def function(a):

...     pass

...

>>> function(0, a=0)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: function() got multiple values for argument 'a'

When a final formal parameter of the form **name is present, it receives a dictionary (see Mapping Types — dict) containing all  parameter. This may be combined with a formal parameter of the form *name (described in the next subsection) which receives a tuple containing the positional arguments beyond the formal parameter list. (*name must occur before **name.) For example, if we define a function like this:

def cheeseshop(kind, *arguments, **keywords):

    print("-- Do you have any", kind, "?")

    print("-- I'm sorry, we're all out of", kind)

    for arg in arguments:

        print(arg)

    print("-" * 40)

    for kw in keywords:

        print(kw, ":", keywords[kw])

It could be called like this:

cheeseshop("Limburger", "It's very runny, sir.",

           "It's really very, VERY runny, sir.",

           shopkeeper="Michael Palin",

           client="John Cleese",

           sketch="Cheese Shop Sketch")

and of course it would print:

-- Do you have any Limburger ?

-- I'm sorry, we're all out of Limburger

It's very runny, sir.

It's really very, VERY runny, sir.

----------------------------------------

shopkeeper : Michael Palin

client : John Cleese

sketch : Cheese Shop Sketch

Note that the order in which the keyword arguments are printed is guaranteed to match the order in which they were provided in the function call.

【译】

4.8.2. 关键字参数

可以使用关键字参数kwarg=value的形式调用函数。

例如，应用一个必需参数voltage和三个可选参数state, action, type，函数parrot的调用可以有多种方式。

以下的调用都是无效的。

 

调用函数时，引用的位置参数必须在关键字参数的前面。同时，关键字参数必须是已经被定义的参数（例如，在parrot()函数，actor不是一个有效的参数）。当必需参数是以关键字方式引用的，必需参数和可选参数的顺序不重要。另外，激活函数时，可以没有可选参数（例如，parrot(voltage = 1000)也是有效的）。并且，同一个参数一次不能接受多个值，以下是一个关于此约定的错误实例。

当定义函数是，表单最后一个正式参数是“**name”的形式参数，它会接收一个包含了所有关键字参数的字典。它可以与正式参数表单的“*name”形式的参数结合使用，“*name”接收一个元组，这个元组包含了形式参数列表之后的位置参数（*name必须在**name之前）。举个例子，如果我们定义这样一个函数，

注意，关键字参数的输出顺序与函数调用时提供的顺序相匹配。