day13 内置函数二 递归,匿名函数,二分法

1.匿名函数(名字统一叫lambda)
   1.语法 lambda 参数:返回值
   2.参数可以有多个,用逗号隔开
   3.只能写一行,执行结束后直接返回值
   4返回值和正常函数一样,可以是任意值
   5.列:
   f=lambda n:n**n   #传入一个数n,返回她的n次方
   print(f(10))   

2.sorted 排序函数
   1.语法:
     sorted(iteble,key=NONE,reverse=FALSE)
     1.iteble 可迭代对象
     2.key 排序函数 sorted内部把可迭代对象的每一个元素传给函数,
       根据函数的运算规则(返回值)进行排序
     3.是否倒叙 TRUE:倒叙 FALSE :正序
     4.排序后是一个列表
   2.列:
     1.对字典进行排序,返回的是key
      dic = {1:'A', 3:'C', 2:'B'}
      print(sorted(dic)) 
      [1, 2, 3]

     2.列表
      lst = [1,5,3,4,6]
      lst2 = sorted(lst)
      print(lst)    原列表不会改变
      print(lst2)   新列表是经过排序的
     3.和函数联用
      lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
      print(sorted(lst,lambda s:len(s)) 根据字符串长度进行排序
     4.
     lst = [{"id":1, "name":'alex', "age":18},
     {"id":2, "name":'wusir', "age":16},
     {"id":3, "name":'taibai', "age":17}]
     print(sorted(lst,lambda s:s["age"])   根据年龄排序字典

3.filter 筛选函数
     1.语法
     filter(function,iterble)
     用来筛选的函数,filter会自动把可迭代对象的元素传给
     function,然后根据function返回的TRUE 或者FALSE来
     判断是否保留此项数据
     2.列
     lst = [1,2,3,4,5,6,7]
     ll=print(lambda i:i%2==0,lst)#筛选出所有偶数
     print(ll)                    #迭代器
     print(list(ll))              #取值[2, 4, 6]
     3.
     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))

4.map 映射函数
    1.语法
    map(function,iteable)
    2.求平方
    print(list(map(lambda x:x*x*x,[1,2,3,4,5])))
    3.映射
    lis1=[1,3,5,7,9]    
    lis2=[2,4,6,8,10]
    map(lambda x,y:x+y,lis1,lis2)
    注: 1. 如果lis不等长,就是按短的截取
        2.如果函数不存在,就一一对应打包成元组
 注:map和filter返回的都是迭代器,所以要看里面的内容需要用for循环查询出来,或者将返回值直接转换成列表

5.递归
    1.定义:在函数中调用函数本身就是递归
    2.语法
     def func()
         print("递归")
         func()
     func()
    3.应用  遍历文件夹的所有文件
    import os
    def read(filepath,n)
        list=os.listdir(filepath)         #打开一个文件,获取里面所有的内容,返回列表
        for fi in list:                          #遍历获得的名字(包含文件名和文件夹名)
            file_real_path=os.path.join(path,fi) #获得的名字加上路径等于绝对路径
            if os.path.isdir(file_real_path)     #判断在绝对路径下是否文件夹
                #递归的入口
                print("\t"*n,fi)                        #打印
                read(file_real_path,n+1)             #是文件夹继续调用函数
            else:
                print("\t"*n,fi)                        #不是文件夹就直接输出
    read("../py",0)

6.二分法
    1.优点:查找快,效率高
    2.缺点:局限性大,必须是有序序列
    3.列
    lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
    num=int(input("请输入要查找的数字"))
    left=0                    #确定左边界,其实是索引的起始
    right=len(lst)-1          #确定右边界,其实是索引的结束
    count=1                   #用来确定共查找了几次
    while left<=right:
        mid=(left+right)//2   #整除2 ,取整
        if num>lst[mid]:
            left=mid+1
        elif num<lst[mid]:
            right=mid-1
        else:
            print("找到了")
            break
        count+=1

    else:
       print("没找到")

 

7.普通版的二分法(函数的方法)
    lst=[...........]
    def binary_search(n,left,right)   #查找的数以及左右边界()
        if left<right:
            mid=(left+right)//2       #对2整除,取整
            if n<lst[mid]:
                right=mid-1
            elif n>lst[mid]:
                left=mid+1
            else:
                return mid
            return binary_search(n,left,right)  #这个return一定要加,要不然返回的一定是NONE
        else:
            return -1
    print(binary_search(567, 0, len(lst)-1))

8.另类二分法,比较难计算位置
    lst=[.......]
    def binary_search(ls,target):
        left=0
        right=len(lst)-1
        if left>right:
            print("不存在")
        mid=(left+right)//2  
        if target<lst[mid]
            return binary_search(lst[:mid],target)
        elif target>lst[mid]
            return binary_search(lst[mid+1:],target)
        else:
            print("在这里")
    binary_search(lst.,567)