python 递归函数

递归函数 recursion

　　函数直接或间接的调用自身

　　【1】优点:

　　　　　　 递归把问题简单化，让思路更为清晰，代码更简洁

　　【2】缺点：

　　　　　　递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果

　　【3】注：

　　　　　　递归一定要控制递归的层数，当符合一定条件时要终止递归 几乎所有的递归都能用while循环来代替

　　【4】递归的两个阶段

　　　　　　递推阶段: 从原问题出发，按递归公式递推从末知到已经，最终达到递归的终止条件

　　　　　　回归阶段: 按递归终止条件求出结果,逆向逐步代入递归公式．回归到原问题求解

 

In [15]: def fx(n):
    ...:     print("fx进入第", n, '层')
    ...:     if n == 3:
    ...:         return
    ...:     fx(n + 1)
    ...:     print("fx退出第", n, '层')
    ...:
    ...:
    ...: fx(1)
    ...: print("程序结束")
fx进入第 1 层 #函数外部第一调用fx，执行第一个print，此时n为1，不等于3，
             #向下执行fx(n+1)，即fx(2)，再次调用函数fx，而1这个对象并未执行后续代码，缓存
fx进入第 2 层 #函数内第二次调用fx()自身,第二次执行第一个print,此时n为2，不等于3，
　　　　　　　　#向下执行fx(n+1)，即fx(3)，再次调用fx,而2这个对象并未执行后续代码，缓存
fx进入第 3 层 #【1】函数内第三次调用fx()自身，第三次执行第一个print，此时n为3,等于3，if条件成立。
　　　　　　　　#3这个对象终止了调用fx自身。然后原路返回，return返回到
             #上一次调用fx自身的地方，把调用fx自身后面的代码执行完毕，然后再到上上次调用fx自身的地方，
　　　　　　　　#把调用fx自身后面的代码执行完毕。以此类推，
 　　　　　　　# 直到变量n走到外部调用fx时传入的值时终止，即最外层终止。
　　　　　　　　#--------------
　　　　　　　　#*递归每次调用自身，都是新开辟一块内存（后一次是在前一次的内存里面再次开辟的），即每次调用都是创建一个新的对象*。
　　　　　　　　#递推：
　　　　　　　　 #   函数外部第一次调用fx，可以理解为开辟了一个内存空间A来处理函数fx，
　　　　　　　　 #   函数内部第二次调用fx，可以理解为在第一次已开辟的内存空间A里面再次开辟了一部分内存，来处理fx
　　　　　　　　 #   以此类推，每次调用自身，就是在前一次调用时创建的内存空间里面再次开辟一部分内存来处理，直到递推终止条件或者遇到return，此时递推结束。开始回归
　　　　　　　　#回归：
　　　　　　　　　#　遇到终止条件或return时返回，返回到上一次调用fx自身的位置，执行其后的代码，执行完毕后，再返回此次上次调用fx的位置，即上上次调用fx的位置，
　　　　　　　　　#　执行其后续代码。以此类推，直至第一次调用fx的位置终止
fx退出第 2 层
fx退出第 1 层
程序结束

In [16]: def fac(n):
    ...:     # 此函数用递归的方式实现阶乘
    ...:     if n == 1:  # 1! 直接返回1
    ...:         return 1 #return返回到函数调用的地方
    ...:     return n * fac(n - 1) #最后一次是调用fac(1)，走if里面的内容，fac(1)=1,将fac(1)=1返回给外部函数调用fac(1)的地方
　　　　　　　　　　　　　　　　　　　　　　#fac(1)遇到return，递推终止，开始回归
　　　　　　　　　　　　　　　　　　　　　　#递推：fac(5)=5*fac(4) 第一次返回值
　　　　　　　　　　　　　　　　　　　　　　#　　  fac(4)=4*fac(3) 第二次返回值
　　　　　　　　　　　　　　　　　　　　　　#　　　fac(3)=3*fac(2) 第三次返回值
　　　　　　　　　　　　　　　　　　　　　　#　　  fac(2)=2*fac(1) 第四次返回值
　　　　　　　　　　　　　　　　　　　　　　#　　　fac(1)=1        第五次返回值（终止条件的返回值，已知）
　　　　　　　　　　　　　　　　　　　　　　#回归：最后一次调用fac(1),符合if条件，fac(1)=1，返回前一次调用fac的地方
　　　　　　　　　　　　　　　　　　　　　　#　　　fac(1)的前一次调用fac(2),fac(2)=2*fac(1),即fac(2)=2*1
　　　　　　　　　　　　　　　　　　　　　　#　　　fac(2)的前一次调用为fac(3),fac(3)=3*fac(2),即fac(3)=3*2*1
　　　　　　　　　　　　　　　　　　　　　　#　　  fac(3)的前一次调用为fac(4),fac(4)=4*fac(3),即fac(4)=4*3*2*1
　　　　　　　　　　　　　　　　　　　　　　#　　　fac(4)的前一次调用（即第一次）为fac(5),fac(5)=5*fac(4),即fac(5)=5*4*3*2*1

    ...:
    ...:
    ...: print(fac(5))  # 120
120

In [17]: