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

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

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

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

.filter 筛选函数
     .语法
     filter(function,iterble)
     用来筛选的函数,filter会自动把可迭代对象的元素传给
     function,然后根据function返回的TRUE 或者FALSE来
     判断是否保留此项数据
     .列
     lst = [,,,,,,]
     ll=print(lambda i:i%==,lst)#筛选出所有偶数
     print(ll)                    #迭代器
     print(list(ll))              #取值[, , ]
     .
     lst = [{"id":, "name":'alex', "age":},
     {"id":, "name":'wusir', "age":},
     {"id":, "name":'taibai', "age":}]
     fl = filter(lambda e: e['age'] > , lst) # 筛选年龄⼤于16的数据
     print(list(fl))

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

.递归
    .定义:在函数中调用函数本身就是递归
    .语法
     def func()
         print("递归")
         func()
     func()
    .应用  遍历文件夹的所有文件
    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",)

.二分法
    .优点:查找快,效率高
    .缺点:局限性大,必须是有序序列
    .列
    lst = [, , , , , , , , , , , , , , ]
    num=int(input("请输入要查找的数字"))
    left=                    #确定左边界,其实是索引的起始
    right=len(lst)-          #确定右边界,其实是索引的结束
    count=1                   #用来确定共查找了几次
    while left<=right:
        mid=(left+right)//2   #整除2 ,取整
        if num>lst[mid]:
            left=mid+
        elif num<lst[mid]:
            right=mid-
        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)