python匿名函数和递归函数

匿名函数和递归函数

1.1 匿名函数 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

1.2 高阶函数

1.2.1 简介

高阶函数其实就是把函数作为参数传入

就是把一个函数作为另一个函数的参数传入

abs（）==》完成对数字绝对值计算

print(abs(-5))

sum（）==》求和

sum(可迭代对象，指定一个相加的参数如果没有默认为0)
print(sum([1,2,3,4,5]))
print(sum((1,2,3,4,5),1))

round（）==》四舍五入

print(round(4.3))
print(round(4.8))

print(round(4.5))  # 4 坑

https://www.cnblogs.com/bigc008/p/9682105.html

任意两个数字，对两个数字求绝对值后进行求和

def ab_sum(a,b,f):
    return f(a)+f(b)
res = ab_sum(-1,-4,abs) #把abs作为参数传入到函数里面，传的是函数本身不是传函数调用
print(res)

def xfs(x):
    return -x

def ab_sum(a,b,f): # f是一个函数参数
    return f(a)+f(b)
res = ab_sum(-1,-4,xfs)  # 求的是相反数的和
print(res)

函数作为参数的函数

函数三剑客：map , reduce filter

1.2.2 map()

map（func，seq）第一个参数是给一个函数，第二个是给一个序列类型

将列表序列中各个元素加一

# 普通写法
list1 = [1,2,3,4,5]
list2 = []
for i in list1:
    list2.append(i+1)
print(list2)

#map用法
list1 = [1,2,3,4,5]
print(list(map(abs,list1)))

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

[2, 3, 4, 5, 6]

list1 = [1,2,3,4,5]
print(list(map(lambda x:x+1,list1)))

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

1.2.3 reduce

reduce（func，seq）将每次函数计算的结果继续和序列的下一个元素做累积计算，最终结果只有一个值

注意：reduce传入的参数func必须接受两个参数

计算列表中各个数字的和

list1 = [1,2,3,4,5]
sum = 0
for i in list1:
    sum += i
print(sum)

list1 = [1,2,3,4,5]
def f(a,b):
    #print('进入f')
    #print('a=',a)
    #print('b=',b)
    return a+b
res = reduce(f,list1)
print(res)

1.2.4 filter()==》过滤

filter（func,seq）结果可以通过list转换

保留一个序列中所有偶数

list1 = [1,2,3,4,5,6,7,8,9,10]
for i in list1:
     if i %2 != 0:
         list1.remove(i)
print(list1)

list1 = [1,2,3,4,5,6,7,8,9,10]
def os(x):
    return x%2 == 0
print(list(filter(os,list1)))

print(list(filter(lambda x:x%2==0,list1)))

1.2.5 sorted

list1 = [2,4,1,3,5,6,9,7]
print(sorted(list1))  # 升序
print(sorted(list1,reverse=True))  # reverse=True 是反转的意思

list1 = ['天天:69','二则:78','涛婆:89','广广:100','初雪:95']
print(sorted(list1))
def f(x):
    arr = x.split(':')
    return int(arr[1])
print(sorted(list1,key=f))


print(sorted(list1,key=lambda x:int(x.split(':')[1])))

1.3 递归函数

有可能搞得我们内存崩溃

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

内存溢出

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

2.不断的向出口接近

打印1到500

x = 1
def func():
    global x
    if x == 500:
        print(x)
    else:
        print(x)
        x += 1
        return func()
func()

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

9！ =  9*8*7*6*5*4*3*2*1
9！ =  9*8！
9！ =  9*8*7！

def f(n):
    if n == 1:
        return True
    return n*f(n-1)
a = f(9)
print(a)