学习Python（2）——函数

先写一个例子——生成n以内的Fibonacci数：

def fib(n):
    a,b=0,1
    while b<n:
        print b,
        a,b=b,a+b

def指出了接下来的部分是一个函数。Python和C语言类似，并不区分过程（无返回值）和函数（有返回值）。像上面那样严格的说就是一个过程（Procedure）。
对于一个项目而言，在不同的模块的代码中插入一段简洁明了的说明文字是很有必要的。Python支持类似Java-Doc的语法。例如：

def fib(n):
    """Print a Fibonacci series up to n."""
    a,b=0,1
    while b<n:
        print b,
        a,b=b,a+b

将说明文字放在一对“”“（三个又引号）之间，一些文档生成工具就会将这些文字提取出来，生成HTML或是LaTeX等文档。写这些文字费不了多少时间，养成这种习惯绝对是大有好处的。
函数的调用也非常简单，对于上面的而言，只需直接用fib(100)，就会产生相应的输出：

1 1 2 3 5 8 13 21 34 55 89

函数本身也可以被引用。对于已经定义好的fib来说，如果有一句：f=fib，就意味着f引用了fib这个函数。现在这两个名字所指的就是同一个东西。于是就可以这样使用：

>>>f(100)

输出结果和上面的是一样的。可以比照着C语言中的”函数指针“来理解一下。
虽然Python的函数可以不显式地写出return语句，实际上这种函数也会返回一个特殊的值None。例如有一个什么都不干的函数：

def fun():
    pass

可以通过在解释器中用print来显示一下它的值：

>>>print fun()
None

现在可以将上面的fib函数改造一下，让它不再直接产生输出，而是产生一个Fibonacci数列的List：

def fib2(n):
    """Print a Finonacci series up to n."""
    a,b=0,1
    result=[]
    while b<n:
        result.append(b)
        a,b=b,a+b
    return result

append是List类的一个方法，即向一个List后添加元素。这个函数的效果如下：

>>>print fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

默认参数
Python函数支持默认参数。你可以定义一个两个参数的函数，但在调用的时候可以只告诉其中一个参数或是一个都不告诉——只要你在定义的时候指定了参数的默认值。这很像是从C++中学来的。

def ask_ok(prompt,retries=4,complaint='Yes or no, please!'):
    while True:
        ok=raw_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 want to quit?')
>>>ask_ok('Do you really want to quit?',2)
>>>ask_ok('Do you really want to quilt?',3,'What do you want to do?')

参数的默认值是在定义的时在函数的入口处确定下来的。这可以通过一个实验来说明：

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

发现输出的是5而不是6，因为后来的i改变根本不会对函数里的arg造成影响。
要注意的是，函数的默认参数部分只会被计算一次。这样如果默认参数是某种复合类型（List，String，Class），可能会产生一种”积累效应“：

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

如果调用三次：

>>> print f(1)
[1]
>>> print f(2)
[1, 2]
>>> print f(3)
[1, 2, 3]

要避免这种情况，就需要在定义的参数列表中显式地将L的默认值指定为None：

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

带关键字的参数
关键字可以理解为函数头部参数的名字。通过在调用函数的时候指定关键字，可以不按照参数定义的顺序来传递参数的值。

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "-- This parrot wouldn't", action,
    print "if you put", voltage, "volts through it."
    print "-- Lovely plumage, the", type
    print "-- It's", state, "!"

带关键字调用：

parrot(1000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')

下面的几种调用方式是错的：

parrot() # 缺少指定参数
parrot(voltage=5.0, 'dead') # 没有指出关键字
parrot(110, voltage=220) # 传递重复参数
parrot(actor='John Cleese') # 不存在的关键字

更为灵活的是，可以通过在函数定义时用*name或**name的方式代表不确定的参数或带有关键字的参数（Dictionary）。这个用例子说明会容易理解一下：

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
    keys = keywords.keys()
    keys.sort()
    for kw in keys: print kw, ':', keywords[kw]

可以这样调用：

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

结果是：

-- 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.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

传递多个参数时还可以通过List来进行。List中的元素会被分离开，称为Unpack，这是Python解释器在幕后完成的。例如range函数可以指定两个参数，可以把这两个参数构成一个List，再将这个List传入：

>>> args = [3, 6]
>>> range(*args) # call with arguments unpacked from a list

[3, 4, 5]
类似地，可以使用**操作符来传递一个字典，对应于带关键字传递参数的方式。

>>> def parrot(voltage, state='a stiff', action='voom'):
...         print "-- This parrot wouldn't", action,
...         print "if you put", voltage, "volts through it.",
...         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 !

用心领悟一下。

Lambda函数
Python从函数语言中学来了这一功能。Lambda函数是一种匿名函数，功能有些像函数的模板，通过它可能方便地生成其他函数。感觉Lambda函数更加需要领悟，只里仅仅记几个例子：

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