python内置函数filter，map，lambda,递归

lambda匿名函数

# 计算n的n次⽅
def func(n):   
	return n**n
print(func(10))


f = lambda n: n**n
print(f(10))

lambda表⽰的是匿名函数. 不需要⽤def来声明, ⼀句话就可以声明出⼀个函数

语法 = lambda 参数：返回值

注意：

1. 函数的参数可以是多个，逗号隔开
2. 匿名函数不管多复杂，只能写一行，逻辑运行后直接返回数据。
3. 返回值和正常函数一样。

sorted()排序函数

语法：sorted(Iterable, key=None,reverse=False)

​ Iterable：可迭代对象

​ key：排序规则（排序函数）sorted内部会将可迭代对象中每一个元素传递给一个参数，根据函数结果进行排序

​ reverse ：是否是倒叙，reverse=True 倒叙 ，reverse=False 正序

#自带的排序功能
lst = [1,4,6,7,78,91,14,5,6]
lst.sort() # lst自带的排序功能
li = sorted(lst)
print(li)
lst = ["馒头","包子","欧阳大锤","小笼包","赵四","刘能","头"]
li = sorted(lst)

#结合函数进行排序
def func(name):
   return len(name) # 返回一个数字

li = sorted(lst,key=func)
print(li)
#结合lambda
lst = ["馒头","包子","欧阳大锤","小笼包","赵四","刘能","头"]

li = sorted(lst,key=lambda name:len(name)%3)
print(li)



lst = [{"id": 1, "name": 'alex', "age": 18},
      {"id": 2, "name": 'wusir', "age": 16},
      {"id": 3, "name": 'taibai', "age": 17}]
按照年龄对学⽣信息进⾏排序
print(lst[0]["age"])
def age2(lst):
   for i in range(len(lst)):
      return lst[i]["age"]想
li = sorted(lst,key=age2)

print(li)## 

#流程:把迭代对象的每一项传递给函数,函数返回一个数字,根据这个数字完成排序

#通过lambda

li = sorted(lst,key=lambda dic:dic['age'])

li = sorted(lst,key=lambda age2:age2['age'])




 按照年龄对学⽣信息进⾏排序
# def func(dic):
#     return dic['age']
# l2 = sorted(lst, key=func) # 流程: 把可迭代对象的每一项传递给函数. 函数返回一个数字. 根据这个数字完成排序
# print(l2)
# l3 = sorted(lst, key=lambda dic: dic['age'])
# l4 = sorted(lst, key=lambda dic: len(dic['name']))
# l4 = sorted(lst, key=lambda dic: ascii(dic['name'][0]))  # ord()
# print(l4)

filter()筛选函数

语法：filter(funciton， Iterable)

​ function:用来筛选的函数，filter会自动把iterable（可迭代对象）的元素传递给function，然后function返回True或False判断是否保留此项数据

​ Iterabel：可迭代对象

lst = [23,28,15,27,25,23]
#通过函数

def func(age):
   return age > 18
fu = filter(func,lst )
print(lsit(fu))
#匿名函数
f = filter(lambda age:age>18,lst)

print(f)#<filter object at 0x1099c5710>

print("__iter__" in dir(f))
print(f.__next__())
print(f.__next__())
print(f.__next__())
for el in f:
   print(el)


def func(age):
    return age > 18 and age %2 ==0


f1 = filter(lambda age:age>18 and age %2 ==0,lst)
print(sorted(f))
for i in f1:
   print(i)




#筛选年龄大于等于17岁
lst = [{"id": 1, "name": 'alex', "age": 18},
       {"id": 2, "name": 'wusir', "age": 16},
       {"id": 3, "name": 'taibai', "age": 17}]


f2= filter(lambda dic:dic["age"] >=17 ,lst)
f2= filter(lambda dic:dic["age"] >=17 ,lst)

#for i in f2:
#       print(i)

# # 筛选出年龄大于等于17岁的人
print(list(sorted(filter(lambda dic: dic['age'] >= 17, lst), key=lambda dic: dic['age']))

map()映射函数

​ 语法:map(funtction,iterable) 可以对每一个元素依次只想function（item)，执行结果组成一个list返回

lst = [3,5,6,9,10,2,3,5,6,9]
ll = [i*i for i in lst]
print(ll)
m = map(lambda x:x**2,lst) #m = map(lambda x:x*x,lst)
print(list(m))

lst = [3,5,6,9,10,2,3,5,6,9]
ll = [i*i for i in lst]
print(ll)

ll2 = map(lambda x:x*x,lst)
print(list(ll2))

#另外map也支持多个sequence，这就要求function也支持相应数量的参数输入：
>>> def add(x, y): return x+y
>>> map(add, range(8), range(8))
[0, 2, 4, 6, 8, 10, 12, 14]

# 计算两个列表相同位置的数据的和
lst1 = [1,2,3,4,5]
lst2 = [2,4,6,8,10]
print(list(map(lambda x,y:x+y,lst1,lst2)))

递归

在函数中调⽤函数本⾝. 就是递归

def func():     
	print("我是谁")     
	func() 
func()    

在python中递归的深度最⼤到998

def foo(n):     
	print(n)     
	n += 1     
	foo(n) 
foo(1) 

递归的应⽤:
我们可以使⽤递归来遍历各种树形结构, 比如我们的⽂件夹系统. 可以使⽤递归来遍历该⽂件夹中的所有⽂件

import os
def func(file_path,ceng):
    lst = os.listdir(file_path) #获取到当前⽂件夹中的所有⽂件
    for file in lst: #获取到当前⽂件夹中的所有⽂件
        full_path = os.path.join(file_path,file) # 加⼊⽂件夹 获取到⽂件夹+⽂件
        if os.path.isdir(full_path): # 如果该路径下的⽂件是⽂件
            print("\t"*ceng,file)
            func(full_path,ceng +1) # 继续进⾏相同的操作
        else:
            print("\t"*ceng,file) # 递归出⼝. 最终在这⾥隐含着return
#递归遍历⽬录下所有⽂件read('../oldboy/', 0)
func("./",0)

二分查找

···