深入Python函数定义

在Python中，你也可以定义包含若干参数的函数。这里有三种可用的形式，也可以混合使用。

1. 默认参数值

最常用的一种形式是为一个或多个参数指定默认值。这会创建一个可以使用比定义时允许的参数更少的参数调用的函数，例如：

def ask_ok(prompt, retries = 4, complaint = "Yes or no, please!"):
	while True:
		ok = input(prompt)
		if ok in ('y', 'ye', 'yes'):
			return True
		if ok in ('n' ,'no', 'nop', 'nope'):
			return False
		retries = retries - 1
		if retries < 0:
			raise IOError('refusenik user')
		print(complaint)

这个函数可以通过几种不同的方式调用：

• 只给出必要的参数：ask_ok('Do you really wnat to quit?')
  
• 只给出一个可选的参数：ask_ok('Ok to overwrite the file',2)
  
• 或者给出所有的参数：ask_ok('OK to overwrite the file?',2,'Come on, only yes or no!'),

这个例子还介绍了in关键字。它测定序列中是否包含某个确定的值：ok in ('y', 'ye', 'yes')

默认值在函数定义作用被解析，如下所示：

i = 5
def f(arg = i):
    print(arg)
i = 6
f()

将会输出5

重要警告：默认值只被赋值一次。这使得当默认值是可变对象时会有所不同，比如列表、字典或者大多数类的实例。例如，下面的函数在后续调用过程中会累积（前面）付给它的参数：

def f(a, L = []):
    L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3))

这将输出：

[1]
[1, 2]
[1, 2, 3]

如果你不想让默认值在后续调用中累积，你可以像下面一样定义函数：

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

2. 关键字参数

函数可以通过关键字参数的形式来调用，形如keyword = value。例如：以下的函数：

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

接受一个必选的参数（voltage）以及三个可选参数（state,action和type）。可以用以下的任一方法调用：

parrot(1000)
parrot(voltage = 1000)
parrot(voltage = 10000, action = 'VOOOM')
parrot(action = 'VOOOOM', voltage = 1000) # action 写在前面也是OK的！
parrot('a million', 'bereft of life', 'jump') # voltage = 'a milion'
parrot('a thousand', state = 'pushing up the daisies') # voltage = 'a thousand'

不过以下几种调用是无效的：

parrot() # voltage必须有值
parrot(voltage = 5.0, 'dead') # 一旦有一个参数是通过关键字指定的，后面的也必须都是
parrot(110, voltage = 220) # 两个voltage的值
parrot(acotr = 'Jonh Cleese') # 没有voltage的值

通常，参数列表必须（先书写）位置参数然后才是关键字参数，这里关键字必须来自于形参名字。形参是否有一个默认值并不重要。任何参数都不能被多次赋值——在同一个调用中，与位置参数相同的形参名字不能用作关键字。

引入一个形如**name的参数时，它接收一个字典，该字典包含了所有未出现的形式参数中关键字参数。这里可能还会组合使用一个形如*name的形式参数，它接收一个元组，包含了所有没有出现在形式参数列表中的参数值（*name必须出现在**name之前）。例如，我们这样定义一个函数：

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) # 打印40个’-‘
    keys = sorted(keywords.keys()) # 按键值排序
    for kw in keys:
        print(kw, ":", keywords[kw])

它可以像这样调用：

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

3. 可变参数列表

最后，一个最不常用的选择是可以让函数调用可变个数的参数。这些参数被包装进一个元组。在这些可变个数的参数之前，可以有零到多个普通的参数：

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args)) # 用separator符号将arg里的内容连在一起

通常这些可变参数是参数列表的最后一个，因为它们将所有剩余的输入参数传递给函数。任何出现在args后的参数是关键字参数，这意味着，他们只能被用作关键字，而不是位置参数：

>>> def concat(*args, sep="/"):
...    return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

4. 参数列表的分拆

另有一种相反的情况：当你要传递的参数已经是一个列表，但是要调用的函数却接受分开一个个的参数值，这时候你要把已有的列表拆开来，例如内建函数range()需要两个独立的参数range(start, end)。你可以在调用函数时加一个*把已有的列表拆开：

>>>list(range(3, 6))
[3, 4 ,5]
>>> args = [3, 6]
>>> list(range(*args))
[3, 4, 5]

以同样的方式，可以使用**操作符分拆关键字参数为字典：

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

5. Lambda形式

出于实际需要，有几种通常在函数式编程语言例如 Lisp 中出现的功能加入到了 Python。通过 lambda关键字，可以创建短小的匿名函数。这里有一个函数返回它的两个参数的和：lambda a, b: a+b。 Lambda 形式可以用于任何需要的函数对象。出于语法限制，它们只能有一个单独的表达式。语义上讲，它们只是普通函数定义中的一个语法技巧。类似于嵌套函数定义，lambda 形式可以从外部作用域引用变量:

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43