day14，匿名函数，排序，筛选，映射，递归，二分法

一：匿名函数。

　　匿名函数语法：

　　　　　函数名= lambda  形参：返回值

　　　　（1）例 ：

a=lambda n：n**n
 r=a（3）
 print（r）  结果为：27

　　　　（2）例：写一个lambda 给函数传递两个参数, a, b 计算a+b的结果。

　　　　　　　　　

a=lamabda  m，n：m+n

　　　　（3）例：写一个lambda 计算字符串长度并返回 # len()

　　　　　　　　　

a=lambda  s:len（s）

              匿名函数有名字，统一叫“lambda”

　　　　注意！：匿名函数一般不会用来做复杂的操作。

二：sorted（排序函数）

　　排序函数语法：

　　　　　　sorted（iterable，key=none，reverse=false）

　　　　　　lterable（可迭代对象）  key（排序规则） reverse（是否是倒叙，true：倒叙，false：正序）

　　　　　（1）例：

lst=[1,5,3,4,6]
lst2=sorted(lst)
print（lst）#原列表不会改变
print（lst2）#返回的新列表是经过排序的

dic={1：‘a’，3：‘c’，2：‘b’}
print（sorted（dic））  #如果是字典。则返回排序过后的key

　　　　　（2）例：函数和 lambda 组合使用

lst=[”饭岛振宇“，”火星情报局“，”神盾局特工3“，"樱井"]
#计算字符串长度
def func（s）
    return len（s）
print(sorted(lst,key=lambda s:len(s)))

　　　　　(3)l例：函数和 lambda 组合使用

lst = [{"id":1, "name":'alex', "age":18},      
 {"id":2, "name":'wusir', "age":16},       
{"id":3, "name":'taibai', "age":17}] 
#按照年龄对学生信息进行排序
print（sorted（lst，key=lambda e：e['age']））

三：filter（）筛选函数：

　　筛选函数语法：

　　　　filter（function.lterable）

　　　　function：用来筛选的函数，在filter中会自动的把iterable中的元素传递给function，然后根据function

               返回　的true或者 false来判断是否保留此项数据

　　　　lterable：可迭代对象

　　　　(1)例：

lst = [1,2,3,4,5,6,7]
le = filter(lambda x: %2==0,lst) #筛选所有的偶数
print（le）
print(list(le))

　　　　(2）例：

lst = [{"id":1, "name":'alex', "age":18},       
        {"id":2, "name":'wusir', "age":16},      
        {"id":3, "name":'taibai', "age":17}]
fl=filter(lambda e: e['age'] > 16,lst) #筛选年龄大于16的数据
print(list(fl))            

四：map（） 映射函数

　　映射函数的语法：

　　map（function，iterate）可以对可迭代对象中的每一个元素进行映射，分别取执行function

　　（1）例：

#计算列表中的每个元素的平方，但会新的列表
def func（s）
    return s*s

mp = map（func，[1,2,3,4,5,6,]）
print(mp)
print(list(mp))  
#改写成lambda
print（list（map（lamabda s：s*s，[1,2,3,4,5,6]）））

　　(2)例：

　　　

#计算两个列表中相同的数据的和
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中递归的深度最大可以到1000，但结果都不回达到1000.
def foo(n):
    print(n)
    n+=1
    foo(n)
foo(1)

　　递归的应用：

　　　　我们可以使用递归来遍历各种树形结构，比如我们的文件夹系统，可以使用递归来遍历该文件夹中的

               所有文件。

import os

def func(path,ceng):
    lst = os.listdir(path) #获取到当前文件夹中的所有文件
    for el in lst:  #遍历文件夹中的文件，这里获取的只是本层文件名
        rp = os.p    ath.join(path,el) #加入文件夹 获取到文件夹+文件    
        if os.path.lisdic(rp):     #如果该路径下的文件是文件夹
            print("	"*ceng,el,sep="")
            func(rp,ceng+1)      #继续进行相同的操作
        else:
            print("	"*ceng,el,sep=")  #递归出口，最终在这里隐含着return

func（”e：哈哈“，0）

六：二分查找

　　　二分查找，每次能够排除掉一半的数据，查找的效率非常高，但局限性比较大，必须是有序序列才可以

　　　使用二分查找。

　　　要求：查找的序列必须是有序序列   。总结：掐头去尾找中间

           例：

　　　# 判断n是否在lst中出现. 如果出现请返回n所在的位置

　　　# ⼆二分查找---⾮非递归算法 

　　　

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789] 
n = int(input("请输入一个数字"))
laft = 0  #左边界
right = len(lst) - 1  # 末尾的索引，右边界
while lsft <= right:  # 当左边界大于右边界结束循环

    mid = （laft+right）// 2   #地板除以2  ，求中间的索引坐标
    if n < lst[mid]:   #判断你的数字和中间数大小的比较
    right = mid - 1    #右边界就往左边界移动
    elif n > lst[mid]:
    laft = mid + 1    #左边界往右边界移动+1
    else：
        print("找到了")   #否则 就是找到目标  退出
        break
else：   #当左边比右边大，循环结束，没有找到目标数
    print（”没找到“）

       

# 递归函数写
lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
def binary_search(lst,n,left,right):
    if left > right:
        ruturn Flase
    mid = (left+right) // 2
    if n > lst[mid]:
        left = mid + 1   #当递归有返回值的时候，需要写ruturn，否则有可能接收不到返回值
        return binary_search(lst,n,lsft,right)
    elif n < lst[mid]:
        right = mid - 1
        return binary_search(lst,n,left,right)
     else:
        print("找到了")
        return
n = int(input("请输入一个数字"))
ret = binary_search(lst,n,0, len(lst)- 1)
print(ret)