1、理解函数执行流程
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
- 全局帧中生成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函数返回
2、递归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)
for循环写法：
per = 0 cut = 1 print(cut) for a in range(5): per,cut = cut,cut + per print(cut)
递归写法：
def fib(n): return 1 if n < 2 else fib(n-1) + fib(n-2) for a in range(5): print(fib(a),end=" ")
解析：
fib(3) + fib(2)
fib(3) 调用 fib(3) 、fib(2) 、 fib(1)
fib(2) 调用 fib(2)、fib(1)
fib(1) 边界
递归要求：
- 递归一定要有退出条件，递归调用一定要执行到这个退出条件，没有退出条件的递归调用，就是无限调用
- 递归调用的深度不宜过深
- python对递归调用的深度做了限制，以保护解释器
- 超过递归深度限制，抛出RecursionError: maxinum recursion depth exceeded 超过最大深度
- sys.getrecursionlimit()
递归性能
#循环写法 import datetime start = datetime.datetime.now() per = 0 cut = 1 print(cut,end=" ") n = 35 for a in range(n-1): per,cut = cut,cut + per print(cut,end=" ") delta = (datetime.datetime.now() - start).total_seconds() print(delta) #执行结果 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 0.000796 #递归写法 import datetime n = 35 start = datetime.datetime.now() def fib(n): return 1 if n < 2 else fib(n-1)+fib(n-2) for a in range(n): print(fib(a),end=" ") delta = (datetime.datetime.now() - start).total_seconds() print(delta) #执行结果 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 7.415541
- 循环稍微复杂一些，但是只要不是死循环，可以多次迭代直至算出结果
- fib函数代码极简易懂，但是只能获取到最外层的函数调用，内部递归结果都是中间结果，而且给定一个n都要进行近2n次递归，深度越深，效率越低。为了获取斐波那切数列需要外面在套一个n次循环，效率更低了。
- 递归还有深度限制，如果递归复杂，函数反复压栈，栈内存很快就溢出了
递归写法改进
def fib(n,pre=0,cut=1): pre, cut = cut, cut + pre if n == 0 : return pre return fib(n-1,pre,cut) print(fib(5))
- fib函数和循环的思想类似
- 参数n是边界条件，用n来计算
- 上一次的计算结果直接作为函数的实参
- 效率高
- 和循环比较，性能相近，所以并不是说递归一定效率低下，但是递归有深度限制
间接递归
def foo1(): foo2() def foo2(): foo1() foo1()
间接递归，是通过别的函数调用了函数自身
但是，如果构成了循环递归调用是非常危险的，但是往往这种情况在代码复杂的情况下，还是可能发生这种调用的，要用代码的规范来规避这种递归调用的发生
递归总结
- 递归是一种很自然的表达，符合逻辑思维
- 递归相对运行效率低，每一次调用函数都要开辟栈帧
- 递归有深度限制，如果递归层次太深，函数反复压栈，栈内存很快就溢出了
- 如果是有限制次数的递归，可以使用递归调用，或者使用循环代替，循环代码稍微复杂一些，但是只要不是死循环，可以多次迭代算出结果
- 绝大多数递归，都可以使用循环实现
- 即使递归代码很简洁，但是能不用则不用递归
3、匿名函数
- 匿名，既没有名字
- 匿名函数，既没有名字的函数
- 没有名字如何定义
- 没有名字如何调用
- 如果能调用，如果使用
python借助lambda表达式构建匿名函数
格式：
- lambda参数列表：表达式
- lambda x : x **2
- (lambda x : x **2)(4) #调用
- foo = lamdba x,y :(x+y)**2 #不推荐这样用 建议使用普通函数
说明：
- 使用lambda 关键字来定义匿名函数
- 参数列表不需要小括号
- 冒号是用来分割蚕食列表和表达式的
- 不需要使用return，表达式的值，就是匿名函数返回值
- lambda表达式(匿名函数) 只能写在一行上，被称为单行函数
print((lambda :0)()) print((lambda x,y=3: x + y )(5)) print((lambda x,y=3: x + y )(5,5)) print((lambda x, *, y=30: x + y)(5)) print((lambda x, *, y=30: x + y)(5, y=10)) print((lambda *args: (x for x in args))(*range(5))) print((lambda *args: [x+1 for x in args])(*range(5))) print((lambda *args: {x+2 for x in args})(*range(5))) [x for x in (lambda *args: map(lambda x: x+1, args))(*range(5))] [x for x in (lambda *args: map(lambda x: (x+1,args), args))(*range(5))]