递归&栈帧空间

递归函数: 自己调用自己的函数

 def digui(n):
    print(n)
    if n > 0:
       digui(n-1)
    print(n)

 digui(5)

执行结果:

 5
 4
 3
 2
 1
 0
 0
 1
 2
 3
 4
 5

执行过程:

 """

 代码从上到下执行:
 digui(5)
 print 5
    digui(4)
    print 4
       digui(3)
       print 3
          digui(2)
          print 2
             digui(1)
             print 1
                digui(0)
                print 0
                n !> 0
                print 0

                最内层的函数已经结束
                开始向外面跳转

             print 1
          print 2
       print 3
    print4
 prin 5
 """

 """
 去的过程:
 n = 5  print 5    n > 0  digui(5-1)
 n = 4  print 4    n > 0  digui(4-1)
 n = 3  print 3       n > 0  digui(3-1)
 n = 2  print 2       n > 0  digui(2-1)
 n = 1  print 1       n > 0  digui(1-1)
 n = 0  print 0       n !=0  print 0

 digui (0)调用结束
 开始返回

 回的过程:
 n = 1  print 1    digui(1)   结束
 n = 2  print 2       digui(2)   结束
 n = 3  print 3       digui(3)   结束
 n = 4  print 4       digui(4)   结束
 n = 5  print 5       digui(5)   结束
 整个函数执行完毕
 """

阶乘的执行

 def jiecheng(n):
    if n <= 1:
       return 1
    return jiecheng(n-1) * n 

 print(jiecheng(5))

 """
 先计算return后面的表达式, 计算完毕后再返回

 去的过程:
 n = 5  jiechneg(5-1)*5
 n = 4  jiecheng(4-1)*4
 n = 3  jiecheng(3-1)*3
 n = 2  jiecheng(2-1)*2
 n = 1  if return 1

 # 此时最内层代码执行完毕, return返回1

 # 开始执行返回过程
 n = 2  jiecheng(2-1)*2       1*2
 n = 3  jiecheng(3-1)*3       1*2*3
 n = 4  jiecheng(4-1)*4       1*2*3*4
 n = 5  jiecheng(5-1)*5       1*2*3*4*5

栈帧空间:

 """
 栈帧空间就是运行函数的,
 调用函数就是开辟一个新的栈帧空间,
 调用结束后会自动释放栈帧空间
 """

 """
 去的过程:
 没调用一个函数就开辟一块新的栈帧空间,
 每结束一个变量, 就释放一个栈帧空间
 递归本质上就是开辟和释放栈帧空间的过程

 回的过程: 需要触底反弹
 1.当前这层栈帧空间的代码全部执行完毕,
 会自动回到上一层函数的调用处

 2.当前函数遇到return会终止当前函数
 回到上一层函数的调用处

 """