学习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