在python中fg是什么意思 python中的fg

转载

网络安全守护先锋 2024-01-16 06:11:02

文章标签 在python中fg是什么意思 python的mag模块递归压栈递归调用 文章分类 Python 后端开发

第十章 - Python 递归函数

函数执行流程

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压栈，将常量字符串压栈，调用函数(指调用print函数)，弹出栈顶(调用完将字符串弹出)

main中全局查找函数foo1压栈，将常量100、101压栈，调用函数foo1，创建栈帧。print函数压栈，字符串和变量b、b1压栈，调用函数，弹出栈顶，返回值。

main中全局查找foo2函数压栈，将常量200压栈，调用foo2，创建栈帧。foo3函数压栈，变量c引用压栈，调用foo3，创建栈帧。foo3完成print函数调用后返回。foo2恢复调用，执行print后，返回值。main中foo2调用结束弹出栈顶，继续执行print函数调用，弹出栈顶。main函数返回。

调用函数，把调用函数压栈，参数压栈，创建栈帧，执行内部的东西，执行完弹出。恢复到前一个函数。

调用一个函数要保护当前的内容，把当前的执行到哪的环境信息要压入栈中，然后才是把要调用的函数压栈，参数压栈，创建栈帧，在里面执行它的语句。

函数执行流程

递归 Recursion

函数直接或者间接调用自身就是递归

递归需要有边界条件、递归前进段、递归返回段

递归一定要有边界条件

当边界条件不满足的时候，递归前进

当边界条件满足的时候，递归返回

递归 Recursion

斐波那契数列 Fibonacci number：1，1，2，3，5，8，13，21，34，55，89，144，。。。

如果有F(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)
pre = 0
cur = 1 # F(1)为1
print(pre, cur, end='')
n = 4
# loop
for i in range(n-1):
pre, cur = cur, pre+cur
print(cur, end='')

递归 Recursion

F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)
def fib(n):
return 1 if n < 2 else fib(n-1) + fib(n-2)
for i in range(5):
print(fib(i), end=' ')

解析：

fib(3) + fib(2)

fib(3) 调用 fib(3)、fib(2)、fib(1)

fib(2) 调用 fib(2)、fib(1)

fib(1) 是边界

递归 Recursion

递归要求

递归一定要有退出条件，递归调用一定要执行到这个退出条件。没有退出条件的递归调用，就是无限调用

递归调用的深度不宜过深

Python 对递归调用的深度做了限制，以保护解释器

超过递归深度限制，抛出 RecursionError：maxinum recursion depth exceeded 超出最大深度

sys.getrecursionlimit() # 1000

递归的性能

for 循环

import datetime
start = datetime.datetime.now()
pre = 0
cur = 1
print(pre, cur, end=' ')
n = 35
for i in range(n-1):
pre, cur = cur, pre + cur
print(cur, end=' ')
delta = (datetime.datetime.now() - start).total_seconds()
print(delta)

递归

import datetime
n = 35
start = datetime.datetime.now()
def fib(n):
return 1 if n < 2 else fib(n-1) + fib(n-2)
for i in range(n):
print(fib(i), end=' ')
delta = (datetime.datetime.now() - start).total_seconds()
print(delta)

递归的性能

循环稍微复杂一些，但是只要不是死循环，可以多次迭代直至算出结果

fib函数代码极简易懂，但是只能获取到最外层的函数调用，内部递归结果都是中间结果。而且给定一个n都要进行近2n次递归，深度越深，效率越低。为了获取斐波那契数列需要外面在套一个n次的循环，效率就更低了

递归还有深度限制，如果递归复杂，函数反复压栈，栈内存很快就溢出了

思考：这个极简的递归代码能否提高性能呢？

递归的性能

斐波那契数列的改进

pre = 0
cur = 1 # No1
print(pre, cur, end=' ')
def fib(n, pre=0, cur=1): # recursion
pre, cur = cur, pre + cur
print(cur, end=' ')
if n == 2:
return
fib(n-1, pre, cur)
fib(n)

改进

上边的fib函数和循环的思想类似

参数n是边界条件，用n来计数

上一次的计算结果直接作为函数的实参

效率很高

和循环比较，性能相近。所以并不是说递归一定效率低下。但是递归有深度限制。

对比一下三个fib函数的性能

递归

间接递归

def foo1():

foo2()

def foo2():