递归函数

函数执行流程

def foo1(b, b1=3):
    print("foo1 called", b, b1)
def foo2(c):
    foo3(c) print("foo2 called", c)
def foo3(d):
    print("foo3 called", d)
def main():
    print("main called")
    foo1(100, 101)
    foo2(200)
    print("main ending")
main()

• 全局帧中生成foo1、foo2、foo3、main函数对象

• main函数调用

• main中查找内建函数print压栈，将常量字符串压栈，调用函 数，弹出栈顶

• main中全局查找函数foo1压栈，将常量100、101压栈，调用 函数foo1，创建栈帧。print函数压栈，字符串和变量b、b1 压栈，调用函数，弹出栈顶，返回值。

• main中全局查找foo2函数压栈，将常量200压栈，调用foo2， 创建栈帧。foo3函数压栈，变量c引用压栈，调用foo3，创建 栈帧。foo3完成print函数调用后返回。foo2恢复调用，执行 print后，返回值。main中foo2调用结束弹出栈顶。main继 续执行print函数调用，弹出栈顶。main函数返回
  

递归recursion

• 函数直接或者间接调用自身就是 递归
• 递归需要有边界条件、递归前进段、递归返回段
• 递归一定要有边界条件
• 当边界条件不满足的时候，递归前进
• 当边界条件满足的时候，递归返回

对于斐波那契数列可以使用递归函数去实现！
斐波那契数列Fibonacci number：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …
斐波那契数列的数学公式为：
如果设F(n）为该数列的第n项（n∈N*），那么这句话可以写成如下形式：:F(n)=F(n-1)+F(n-2)
所以说F(0)=0,F(1)=1,F(n)=F(n-1)+F(n-2)
a=0
b=1
n=10(想要多少次，就选择个值）
#之前学习的循环来实现：

for i in range(n-1):
     a,b=b,a+b
else:
    print(b)

#对于递归函数的使用：

F(0)=0，F(1)=1, F(n)=F(n-1)+F(n-2) 
def fib(n):
    return 1 if n < 3 else fib(n-1) + fib(n-2)

fib(5)解析：
fib(4) + fib(3)
fib(4)调用fib(3)、fib(2)
fib(3)调用fib(2)、fib(1)
fib(2)、fib(1)是边界return 1，所有函数调用逐层返回

函数这样写是非常好看，但是一点都不中用，其中有大量重复计算！如果数越来越大，耗时越久，栈内存也会越来越多！

斐波那契数列使用递归函数的情况可以理解为上面树杈图，递归逐层的增加，函数反复压栈，导致栈内存会很快溢出！

递归要求

• 递归一定要有退出条件，递归调用一定要执行到这个退出条件。没有退出条件的递归调用，就是无限 调用
• 递归调用的深度不宜过深
  Python对递归调用的深度做了限制，以保护解释器
  超过递归深度限制，抛出RecursionError： maxinum recursion depth exceeded 超出最大深 度
  sys.getrecursionlimit()

递归的性能

• 循环稍微复杂一些，但是只要不是死循环，可以多次迭代直至算出结果
• fib函数代码极简易懂，但是只能获取到最外层的函数调用，内部递归结果都是中间结果。而且给定一个n 都要进行近2n次递归，深度越深，效率越低。为了获取斐波那契数列需要外面再套一个n次的循环，效率 就更低了

递归的改进

def fib(n, a=0, b=1):
    a, b = b, a+b
    if n == 1:
       return a
    return fib(n-1, a, b)
print(fib(4))

改进
fib函数和循环的思想类似
参数n是边界条件，用n来计数
上一次的计算结果直接作为函数的实参
效率很高
和循环比较，性能相近。所以并不是说递归一定 效率低下。但是递归有深度限制

间接递归

间接递归：

def foo1():
    foo2()


def foo2():
    foo1()

间接递归，是通过别的函数调用了函数自身
但是，如果构成了循环递归调用是非常危险的，在生产环境中，代码会很复杂，因为函数都是封闭式的，所以，递归如果没有边界限制的话，就会有事故发生，要用代码的规范来避免这种递归调用的发生

递归总结

• 递归是一种很自然的表达，符合逻辑思维
• 递归相对运行效率低，每一次调用函数都要开辟栈帧
• 递归有深度限制，如果递归层次太深，函数反复压栈，栈内存很快就溢出了
• 如果是有限次数的递归，可以使用递归调用，或者使用循环代替，循环代码稍微复杂一些，但是只要不是 死循环，可以多次迭代直至算出结果
• 绝大多数递归，都可以使用循环实现
• 即使递归代码很简洁，但是能不用则不用递归