python基础-------匿名函数 & 递归函数

(一)匿名函数

匿名:隐藏名字,即没有名称
匿名函数:没有名字的函数.
函数没有名字该如何定义?函数没有名字如何调用?

(二)Lambda表达式

Pthon中,使用Lambda表达式构建匿名函数

lambda x:x ** 2 #定义
(lambda x:x ** 2 )(4)# 调用

foo = lambda x,y:(x+y) ** 2 #定义函数,不推荐.不如直接定义函数
foo(1,2)
# 等价于
def foo(x,y):
    return (x+y) ** 2

• 使用lambda关键字定义函数,格式为lambda[参数列表]:表达式
• 参数列表不需要小括号.无参就不写参数
• 冒号用来分割参数列表和表达式部分
• 不需要使用return.表达式的值,就是匿名函数的返回值.表达式中不能出现等号
• lambda表达式(匿名函数)只能写在一行,也称为单行函数
  匿名函数往往用在为高阶函数传参时,使用lambda表达式,往往能简化代码

# 返回常量函数
print((lambda : 0)())

# 加法匿名函数,带缺省值
print((lambda x, y=3 : x + y)(5))
print((lambda x, y=3 : x + y)(5,6))

#keyword-only参数
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)))
pritn((lambda *args: [x+1 for x in args])(*range(5)))
print((lambda *args: {x%2 for x in args}){*range(5)})

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

(三)递归函数

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压栈,将常量字符串压栈,调用函数,弹出栈顶
• main中全局查找函数foo1压栈,将常量100,101压栈,调用函数f001,创建栈帧.print函数压栈,字符串和变量b,b1压栈,调用函数,弹出栈顶,返回值.
• main中全局查找f002函数压栈,将长脸200压栈,调用f002,创建栈帧.f003函数压栈,变量c引用压栈,调用foo3,创建栈帧.foo3完成print函数调用后返回.foo2恢复调用,自行print后,返回值.main中oo2调用结束弹出栈顶,main继续执行print函数调用,弹出栈顶.main函数返回

(四)递归

• 函数直接或间接调用自身就是递归
• 递归需要有边界条件,递归前进段,递归返回段
• 递归一定要有边界条件
• 当边界条件不满足的时候,递归前进
• 当边界条件满足的时候,递归返回

(五)递归Recursion

• 斐波那契数列Fibonacci number: 1,1,2,3,4,5,13,21,34,55,89,144
• 如果设F(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)

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对递归调用的深度做了限制,以保护解释器
  超过递归深度限制,抛出:超出最大深度错误
  cpython的最大深度为1000
  递归的性能
• 循环稍微复杂一些,但是只要不是死循环,可以多次迭代直至算出结果
• fib函数代码极简易懂,但是只能获取到最外层的函数调用,内部递归结果都是中间结果.而且给定一个n,都要进行2n次递归,深度越深,效率越低.为了获取斐波那契数列需要外面再套一个n次的循环,效果就更低了
• 递归还有深度限制,如果递归复杂,函数反复压栈,栈内存很快就溢出了
  斐波那契数列的改进

def fib(n,a=0,b=1):
    a, b = b, a + b
    if n == 1:
        return a
    return fib(n-1,a,b)
print(fib(4))

• 改进
  上边的fib函数的循环的思想类似
  参数n是边界条件,用n来计数
  上一次的计算结果直接作为函数的实参
  效率很高
  和循环相比,性能相近.所以并不是说递归一定效率低下.但是递归有深度限制

(六)简洁递归

def foo1():
    foo2()

def foo2():
    foo1()

foo1()

简洁递归,是通过别额度函数调用了函数本身
但是,如果后成了循环递归调用是非常危险的,但是往往这种情况再复杂代码情况下,还是可能发生这种调用.要用代码的规范来避免这种递归调用的发生

(七)递归总结

• 递归是一种很自然的表达,符合逻辑思维
• 递归相对运行效率,么一次调用函数都要开辟栈帧
• 递归有深度限制,如果递归层次太深,函数反复压栈,栈内存很快就溢出了
• 如果是有限次数的递归,可以使用递归调用,或者使用循环代替,循环代码稍微复杂一些,但是只要不是死循环,可以多次迭代直至算出结果
• 绝大多数递归,都可以使用循环实现
• 即使递归代码很简洁,但是能不用则不用递归

(八)递归练习

• 求n的介乘

def fn(n):
    if n == 0:
        return 1
    return n * fn(n-1)

print(fn(10))

• 将一个数逆序放入列表,例如1234 => [4,3,2,1]

def fn(n):
    num = [n[-i - 1] for i in range(len(n))]
    print(num)

fn('123456')

• 解决猴子吃桃问题
  猴子第一天摘下若干个桃子,当即吃了一半,还不过瘾,又多吃了一个.第二天早上又将剩下的桃子吃掉一般,有多吃了一个.以后每天早上都吃了前一天剩下的一半零一个.到了第十天早上想吃时,只剩下一个桃子了.求第一天一空吃摘了多少个桃子.

def fn(d):
    n = 1
    if d == 1:
        return 1
    return (fn(d-1)+1)*2
print(fn(10))