Python——递归函数

一. 递归函数

递归函数就是函数在内部调用自身。

必须有一个明确的递归结束条件，称为递归出口。

注意： 切勿忘记递归出口，避免函数无限调用。

 

函数调用自身的实现：

其实函数每次被调用时都会创建一个新命名空间，也就是当函数调用“自身”时，实际上运行的是两个不同的函数（也可以说一个函数具有两个不同的命名空间）。

 

【例】定义阶乘函数

递归实现：

>>> def fact(n):
...     if n == 1:
...             return 1
...     else:
...             return  n * fact( n-1 )
...
>>>
>>> fact(1)
1
>>> fact(2)
2
>>> fact(4)
24
>>> fact(5)
120

fact(5) 计算过程：

factorial(5)                        # 第 1 次调用使用 5
5 * factorial(4)                    # 第 2 次调用使用 4
5 * (4 * factorial(3))              # 第 3 次调用使用 3
5 * (4 * (3 * factorial(2)))        # 第 4 次调用使用 2
5 * (4 * (3 * (2 * factorial(1))))  # 第 5 次调用使用 1 
5 * (4 * (3 * (2 * 1)))             # 从第 5 次调用返回
5 * (4 * (3 * 2))                   # 从第 4 次调用返回
5 * (4 * 6)                         # 从第 3次调用返回
5 * 24                              # 从第 2 次调用返回
120                                 # 从第 1 次调用返回

 

迭代实现：

>>> def fact(n):
...     result = 1
...     for i in range(2,n+1):
...             result *= i
...     return result
...
>>>
>>> fact(1)
1
>>> fact(2)
2
>>> fact(5)
120

递归的优缺点:

优点：

• 递归使代码看起来更加整洁、优雅
• 可以用递归将复杂任务分解成更简单的子问题
• 使用递归比使用一些嵌套迭代更容易

缺点:

• 递归的逻辑很难调试、跟进
• 递归调用的代价高昂（效率低），因为占用了大量的内存和时间。

 

二.  尾递归

使用递归函数需要注意防止栈溢出。在计算机中函数调用是通过栈这种数据结构实现的。每当进入一个函数调用，栈就会加一层栈帧；每当函数返回就会减一层栈帧。由于栈的大小不是无限的，因此递归调用次数过多会导致栈溢出。

解决递归调用栈溢出的方法是通过尾递归优化。

尾递归是指函数返回时调用函数本身，并且 return 语句不能包含表达式。这样，编译器和解释器就可以对尾递归进行优化。使递归本身无论调用多少次都只占用一个栈帧，从而避免栈溢出的情况。

>>> def fact(n):
...     return fact_iter(n,1)
...
>>>
>>> def fact_iter(num , result):
...     if num == 1:
...             return result
...     return fact_iter(num-1 , num * result)
...
>>>
>>>
>>> fact(1)
1
>>> fact(2)
2
>>> fact(5)
120