递归函数
函数执行流程
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()
运行结果:
main called
foo1 called 100 101
foo3 called 200
foo2 called 200
main ending
Process finished with exit code 0
可以通过debug观察函数运行中压栈过程
C语言中,每个栈帧对应着一个未运行完的函数。栈帧中保存了该函数的返回地址和局部变量
栈帧也叫过程活动记录,是编译器用来实现过程/函数调用的一种数据结构
- 全局帧中生成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函数返回
def foo1(b, b1=3):
print("foo1 called", b, b1)
foo2(2)
def foo2(a):
pass
foo1函数的字节码
4 0 LOAD_GLOBAL 0 (print)
3 LOAD_CONST 1 ('foo1 called')
6 LOAD_FAST 0 (b)
9 LOAD_FAST 1 (b1)
12 CALL_FUNCTION 3 (3 positional, 0 keyword pair)
# CALL_FUNCTION是函数调用,调用完成后,弹出所有函数参数,函数本身关闭堆栈,并推送返回值15 POP_TOP # 删除顶部(TOS)项目
5 16 LOAD_GLOBAL 1 (foo2)
19 LOAD_CONST 2 (2)
22 CALL_FUNCTION 1 (1 positional, 0 keyword pair)
25 POP_TOP
26 LOAD_CONST 0 (None)
29 RETURN_VALUE
递归Recursion
概念
- 函数直接或者间接调用自身就是 递归
- 递归需要有边界条件、递归前进段、递归返回段
- 递归一定要有边界条件
- 当边界条件不满足的时候,递归前进
- 当边界条件满足的时候,递归返回
举例说明
- 斐波那契数列Fibonacci number:1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …
- 如果设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)
运行结果:
55
Process finished with exit code 0
- 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.getrecursionlimit()
递归的性能 fib35项比较
for循环and递归
import datetime
import time
start = datetime.datetime.now()
a = 0
b = 1
n = 35
# 循环实现
for i in range(n - 1):
a, b = b, a + b
else:
print(b)
time.sleep(1)
delta = (datetime.datetime.now() - start).total_seconds()
print(delta)
运行结果:
9227465
1.015385
Process finished with exit code 0
import datetime
import time
n = 35
def fib(n):
return 1 if n < 3 else fib(n-1) + fib(n-2)
start = datetime.datetime.now()
fib(35)
time.sleep(1)
delta = (datetime.datetime.now() -start).total_seconds()
print(delta)
运行结果:
2.562029
Process finished with exit code 0
递归的性能
-
循环稍微复杂一些,但是只要不是死循环,可以多次迭代直至算出结果
-
fib函数代码极简易懂,但是只能获取到最外层的函数调用,内部递归结果都是中间结果。而且给定一个n都要进行近2n次递归,深度越深,效率越低。为了获取斐波那契数列需要外面再套一个n次的循环,效率就更低了
-
递归还有深度限制,如果递归复杂,函数反复压栈,栈内存很快就溢出了
-
思考:这个极简的递归代码能否提高性能呢?
-
斐波那契数列的改进
import datetime
import time
def fib(n, a=0, b=1):
a, b = b, a+b
if n == 1:
return a
return fib(n-1, a, b)
start = datetime.datetime.now()
print(fib(35))
time.sleep(1)
delta = (datetime.datetime.now() - start).total_seconds()
print(delta)
运行结果:
9227465
1.015354
Process finished with exit code 0
- 改进
- 左边的fib函数和循环的思想类似
- 参数n是边界条件,用n来计数
- 上一次的计算结果直接作为函数的实参
- 效率很高
- 和循环比较,性能相近。所以并不是说递归一定效率低下。但是递归有深度限制
- 对比一下三个fib函数的性能
间接递归
def foo1():
foo2()
def foo2():
foo1()
foo1()
间接递归,是通过别的函数调用了函数自身
但是,如果构成了循环递归调用是非常危险的,但是往往这种情况在代码复杂的情况下,还是可能发生这种调用。要用代码的规范来避免这种递归调用的发生
总结
- 递归是一种很自然的表达,符合逻辑思维
- 递归相对运行效率低,每一次调用函数都要开辟栈帧
- 递归有深度限制,如果递归层次太深,函数反复压栈,栈内存很快就溢出了
- 如果是有限次数的递归,可以使用递归调用,或者使用循环代替,循环代码稍微复杂一些,但是只要不是死循环,可以多次迭代直至算出结果
- 绝大多数递归,都可以使用循环实现
- 即使递归代码很简洁,但是能不用则不用递归