Python递归函数

python递归函数

#####此篇文章来源于我的老师Wayne,仅作记录以备复习

函数执行流程

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, …
• 如果设 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  # 55
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.gettercursionlimit()

递归的性能

• 循环稍微复杂一些，但是只要不是死循环，可以多次迭代直至算出结果
• 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()
    
foo1() 

简介递归，是通过别的函数调用了函数自身
但是，如果构成了循环递归调用时非常危险的，但是往往这种情况在代码复杂的情况下，还是可能发生这种调用的。要用代码的规范来避免这种递归调用的发生

---

递归总结

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