Python递归函数

最新推荐文章于 2021-05-24 22:16:26 发布

原创最新推荐文章于 2021-05-24 22:16:26 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

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()

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

递归总结

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