python 匿名函数与递归函数

二 匿名函数和递归函数

2.1 高级用法

1.函数可以被引用(可以赋值)

def fn():
    print('我是fn')
f = fn
print(f,fn)
f()

<function fn at 0x00000168E1781EA0> <function fn at 0x00000168E1781EA0>
我是fn

2.函数可以作为参数传入到另一个函数

def fn():
    print('我是fn')
f = fn
print(f,fn)
f()

def fn2(x):
    x()  # 调用x相当于调用fn
fn2(fn)

3.可以将函数作为返回值

def fn():
    print('我是fn')

def fn2(x):
    return x
x=fn2(fn)  # fn2(fn)相当于fn
x()  # 相当于在调用fn

4.函数可以作为容器的元素

def fn():
    print('我是fn')
    
li = [1,2,3,fn]
f = li[3]   # li[3] 就是fn
# li[3]()
f()

2.2 匿名函数(lambda)

语法：
lambda 参数列表:运算表达式
# 普通写法求平方
def fn(x):
    return x*x


print(fn(5))
# 匿名函数写法求平方
f=lambda x:x*x
print(f(5))

总结：
1.lambda并不会带来程序运行效率的提高，只会使代码更简洁
2.如果使用lambda，lambda内不要有循环，因为可读性不好，有的话请使用标准函数来完成，目的是为了代码有可重用性和可读性
3.lambda只是为了减少单行函数的定义而存在，如果一个函数，只有一个返回值，只有一句代码，就可以使用lambda

2.3 高阶函数

2.3.1 高阶内置函数简介

把函数作为参数传入

abs()  求绝对值
sum(可迭代对象，指定相加的参数如果没有就默认为0)
print(sum([1,2,3,4,5]))  # 15
print(sum((2,3,4),1))  # 10  元组计算总和后再加1
print(sum((2,3,4),2))  # 11 元组计算总和后再加2
round()  求四舍五入  有精度问题
python涉及的浮点类型基本上会有精度问题

任意两个数字，求2个数字的绝对值后进行求和
def ab_sum(a,b,f):
    return f(a)+f(b)
res = ab_sum(-1,-4,abs)
print(res)

# 求相反数的和
def xfs(x):
    return -x

def ab_sum(a,b,f):
    return f(a)+f(b)
res = ab_sum(-1,-4,xfs)
print(res)

2.3.2 map()

map(func,seq)第一个参数是函数，第二个参数是序列类型
map就是改变序列中所有的元素，改变规则由我们传入的函数决定
map的返回结果其实是一个迭代器，
# 将列中中各个元素加1
li = [1,2,3,4,5]
li1 = []
for i in li:
    li1.append(i+1)
print(li1)

li = [1,2,3,4,5]
def add1(x):
    return x+1
print(list(map(add1,li)))

# 匿名函数写法、
print(list(map(lambda x:x+1,li))) #lambda x:x+1 匿名函数  li ：列表

总结：
1.map内置函数的作用是操作序列中所有的元素，并返回一个迭代器，迭代器要转列表
2.咱们的lambda表达式可以专门配合我们的高阶内置函数来做简单的实现

2.3.3 filter

filter(func,seq)  用于过滤序列，过滤掉不符合条件的元素，结果可以通过list转换
# 保留一个序列中所有的偶数
li1 = [1,2,3,4,5,6,7,8,10]
for i in li1:
    if i % 2 !=0:
        li1.remove(i)
print(li1)

# 匿名函数做法
print(list(filter(lambda x:x%2==0,li1)))

2.3.4 sorted

li1 = [2,4,1,3,5,6,7,9]
print(sorted(li1))  # 升序
print(sorted(li1,reverse=True))  # 降序

li1 = ['阿猫:69','阿狗:79','明明:89','张三:100','李四:59']
def f(x):
    arr = x.split(":")       
    return int(arr[1])
print(sorted(li1,key=f))
# ['李四:59', '阿猫:69', '阿狗:79', '明明:89', '张三:100']
print(sorted(li1,key=lambda x:int(x.split(":")[1])))
# ['李四:59', '阿猫:69', '阿狗:79', '明明:89', '张三:100def show_time(func):  # 函数的功能就是展示时间的
    def inner(a,b):
        start = time.time()
        func(a,b)
        end = time.time()
        print(f'运行了{end-start}秒')
    return inner
@ show_time
def add(a,b):
    print(a+b)
    time.sleep(1)
add(1,2)

max(可迭代对象,key=函数)：根据函数获取可迭代对象的最大值
min(可迭代对象,key=函数)：根据函数获取可迭代对象的最小值

li1 =['阿猫:69','阿狗:79','明明:89','张三:100','李四:59']
def f(x):
    arr = x.split(":")
    return int(arr[1])
print(max(li1,key=f))  # 张三:100
print(min(li1,key=f))  # 李四:59

总结：有了这些内置的高阶函数，我们就可以更加灵魂的去操作序列类型，比原始的for循环 if选择要简单那么一点点，但是其实也就简单一点点，更多的变灵活了

2.3.5 内置函数

python提供的，可以直接拿来用的函数

max、min、sorted既属于普通的内置函数也属于高阶内置函数，可以不传函数也能直接求值，map和filter就必须要传函数才可以进行求值

• sum，求和
• divmod，求商和余数
• round，小数点后n位（四舍五入）
• min，最小值
• max，最大值
• all，是否全部为True
• any，是否存在True
• bin，十进制转二进制
• oct，十进制转八进制
• hex，十进制转十六进制
• ord，获取字符对应的unicode码点（十进制）
• chr，根据码点（十进制）获取对应字符
• enumerate, 可以将索引与元素组合为一个元组。
• len，长度
• print，打印
• input，输入
• type，查看类型
• range，可创建一个整数列表，一般用在 for 循环中
• id，查看内存地址

2.4 递归函数

如果说一个函数的内部调用了自己，那么这个就叫递归

def func():
    print("你好")
    func()
func()  # 死循环递归

递归的原则：
1.如果要定义递归函数，不想让他报错的话，必须要有出口

2.不断地向出口接近

def func(x):
    if x ==501:
        return
    print(x)
    return func(x+1)

func(1)

求1*2*3*4*5*6*7*8*9  9的阶乘
9! = 9*8*7*6*5*4*3*2*1
n! = n*(n-1)*(n-2)...*1
9! = 9*8!
9! = 9*8*7!
def f(n):
    if n ==1:
        return True
    return n*f(n-1)

print(f(5))

函数的递归：是函数嵌套调用的一种特殊形式，函数嵌套调用再条用一个函数的过程当中调用了另外的函数
函数的递归再调用一个函数的过程又调用到本身