递归&栈帧空间

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

1 def digui(n):
2    print(n)
3    if n > 0:
4       digui(n-1)
5    print(n)
6    
7 digui(5)

执行结果:

 1 5
 2 4
 3 3
 4 2
 5 1
 6 0
 7 0
 8 1
 9 2
10 3
11 4
12 5

执行过程:

 1 """
 2 
 3 代码从上到下执行:
 4 digui(5)
 5 print 5
 6    digui(4)
 7    print 4
 8       digui(3)
 9       print 3
10          digui(2)
11          print 2
12             digui(1)
13             print 1
14                digui(0)
15                print 0
16                n !> 0
17                print 0
18 
19                最内层的函数已经结束
20                开始向外面跳转
21                
22             print 1
23          print 2
24       print 3
25    print4 
26 prin 5
27 """

 1 """
 2 去的过程:
 3 n = 5  print 5    n > 0  digui(5-1)
 4 n = 4  print 4    n > 0  digui(4-1)
 5 n = 3  print 3       n > 0  digui(3-1)
 6 n = 2  print 2       n > 0  digui(2-1)
 7 n = 1  print 1       n > 0  digui(1-1)
 8 n = 0  print 0       n !=0  print 0
 9 
10 
11 digui (0)调用结束
12 开始返回
13 
14 
15 
16 回的过程:
17 n = 1  print 1    digui(1)   结束
18 n = 2  print 2       digui(2)   结束
19 n = 3  print 3       digui(3)   结束
20 n = 4  print 4       digui(4)   结束
21 n = 5  print 5       digui(5)   结束
22 整个函数执行完毕
23 """

阶乘的执行

 1 def jiecheng(n):
 2    if n <= 1:
 3       return 1
 4    return jiecheng(n-1) * n 
 5 
 6 
 7 print(jiecheng(5))
 8 
 9 """
10 先计算return后面的表达式, 计算完毕后再返回
11 
12 去的过程:
13 n = 5  jiechneg(5-1)*5
14 n = 4  jiecheng(4-1)*4
15 n = 3  jiecheng(3-1)*3
16 n = 2  jiecheng(2-1)*2
17 n = 1  if return 1
18 
19 # 此时最内层代码执行完毕, return返回1
20 
21 
22 # 开始执行返回过程
23 n = 2  jiecheng(2-1)*2       1*2
24 n = 3  jiecheng(3-1)*3       1*2*3
25 n = 4  jiecheng(4-1)*4       1*2*3*4
26 n = 5  jiecheng(5-1)*5       1*2*3*4*5

栈帧空间:

 1 """
 2 栈帧空间就是运行函数的, 
 3 调用函数就是开辟一个新的栈帧空间, 
 4 调用结束后会自动释放栈帧空间
 5 """
 6 
 7 
 8 
 9 """
10 去的过程:
11 没调用一个函数就开辟一块新的栈帧空间, 
12 每结束一个变量, 就释放一个栈帧空间
13 递归本质上就是开辟和释放栈帧空间的过程
14 
15 
16 回的过程: 需要触底反弹
17 1.当前这层栈帧空间的代码全部执行完毕,
18 会自动回到上一层函数的调用处
19 
20 2.当前函数遇到return会终止当前函数
21 回到上一层函数的调用处
22 
23 """