python 递归和匿名函数

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))]