python学习之---函数进阶

一，递归函数：

　　做程序应该都知道，在一个函数的内部还可以调用其它函数，这叫函数的调用，但是有一种特殊的情况，在一个函数内部对自身函数的调用，我们成这为函数的递归调用。

在此，使用一个家喻户晓的例子来演示一下函数的递归调用------求阶乘：

 >>> func(1)
 1
 >>> func(10)
 3628800
 >>> func(100)
 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L
 >>> func(200)
 788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000L
 >>> 

该函数实现了对自己的反复调用，这就时递归！

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试func(1000)：这就是栈溢出的异常显示

   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func
   File "<console>", line 4, in func

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：

 def func(n):
     return func_iter(1, 1, n)

 def func_iter(product, count, max):
     if count > max:
         return product
     return func_iter(product * count, count + 1, max)

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

有一个针对尾递归优化的decorator，可以参考源码：

http://code.activestate.com/recipes/474088-tail-call-optimization-decorator/

我们后面会讲到如何编写decorator。现在，只需要使用这个@tail_call_optimized，就可以顺利计算出fact(1000)：

代码描述如下：

 #!/usr/bin/env python2.4
 # This program shows off a python decorator(
 # which implements tail call optimization. It
 # does this by throwing an exception if it is
 # it's own grandparent, and catching such
 # exceptions to recall the stack.

 import sys

 class TailRecurseException:
   def __init__(self, args, kwargs):
     self.args = args
     self.kwargs = kwargs

 def tail_call_optimized(g):
   """
   This function decorates a function with tail call
   optimization. It does this by throwing an exception
   if it is it's own grandparent, and catching such
   exceptions to fake the tail call optimization.

   This function fails if the decorated
   function recurses in a non-tail context.
   """
   def func(*args, **kwargs):
     f = sys._getframe()
     if f.f_back and f.f_back.f_back \
         and f.f_back.f_back.f_code == f.f_code:
       raise TailRecurseException(args, kwargs)
     else:
       while 1:
         try:
           return g(*args, **kwargs)
         except TailRecurseException, e:
           args = e.args
           kwargs = e.kwargs
   func.__doc__ = g.__doc__
   return func

 @tail_call_optimized
 def factorial(n, acc=1):
   "calculate a factorial"
   if n == 0:
     return acc
   return factorial(n-1, n*acc)

 print factorial(10000)
 # prints a big, big number,
 # but doesn't hit the recursion limit.

 @tail_call_optimized
 def fib(i, current = 0, next = 1):
   if i == 0:
     return current
   else:
     return fib(i - 1, next, current + next)

 print fib(10000)
 # also prints a big number,
 # but doesn't hit the recursion limit.