python---day14（ 内置函数二）

                                        内置函数二
一：匿名函数 lambda函数

　　lambda 表示匿名函数，不需要用def 来申明。
    语法：  函数名=lambda 参数:返回值  ----〉 案例：f=lambda n:n*n

   例子01：

　　　　计算n*n 的值：
        f=lambda n:n*n
            print(f(10))  打印：100

   例子02：

　　　　 计算n的n次方
        def func(n):
            return n*n
        print(func(2))   #打印：4

    匿名函数的注意事项：

    1：函数参数能-是多行，多个参数用逗号隔开
    2：匿名函数不管多复杂，只能写一行，且逻辑结束后直接返回数据
    3：返回值和正常的函数一样，可以是任意数据类型

二：sorted 函数：
    排序函数：
    001：sorted

    sorted(Iterable,key=None,reverse=False)
    Iterable: 可迭代对象
    key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每⼀个元素传递给这个函
         数的参数. 根据函数运算的结果进⾏排序
    reverse: 是否是倒叙. True: 倒叙, False: 正序

　　根据大小排序

    lst=[1,5,3,4,6]
    lst2=sorted(lst)
    print(lst)  #[1, 5, 3, 4, 6]
    print(lst2)  #[1, 3, 4, 5, 6]   进过sorted函数后，返回了从小到大排序好的数

　　例子：

    根据字符串长度进行排序,和函数组合使用  #revserse  Ture 则降序，反则升序
    lst=["马虎疼","qwer","哎呦喂啊啊","旺财"]
    def func(s):
        return len(s)
    print(sorted(lst,key=func))  #['旺财', '马虎疼', 'qwer', '哎呦喂啊啊']

　　#计算字符串长度

 　　def func(s):
        return len(s)
    　　print(sorted(lst,key=lambda s:len(s))) #['旺财', '马虎疼', 'qwer', '哎呦喂啊啊']
    　　lst1=[{"id":1,"name":"xuxiansheg","age":18},
         　　{"id":2,"name":"haha","age":12},
         　　{"id":3,"name":"enen","age":15}

 按照年龄排序：

　　print(sorted(lst1,key=lambda n:n["age"]))
   打印：[{'id': 2, 'name': 'haha', 'age': 12}, {'id': 3, 'name': 'enen', 'age': 15}, {'id': 1, 'name': 'xuxiansheg', 'age': 18}]

三： filter() 筛选函数：

语法：filter()    #filter只保留，返回为真的数据，过滤list的作用

filter() ：用来筛选函数，在filter 中会自动把iterable中的元素
    　　传递给function 然后根据function返回的True 或则False 来判断是否保留此项数据

例子01：
    lst=[1,2,3,4,5,6,7]
    ll=filter(lambda x:x%2==0,lst) #筛选所有的偶数
    print(ll)   #<filter object at 0x00000063DE87DB38>
    print(list(ll))   #[2, 4, 6]

 例子02：
    lst1=[{"id":1,"name":"xuxiansheg","age":18},
         {"id":2,"name":"haha","age":12},
         {"id":3,"name":"enen","age":15}
    ]
    fl=filter(lambda e:e["age"]>12,lst1)  #筛选
    print(list(fl))
    a=list(fl)
    print(a)
    # 打印：[{'id': 1, 'name': 'xuxiansheg', 'age': 18},
    # {'id': 3, 'name': 'enen', 'age': 15}]

四： map()映射函数  #map是帮你循环调用函数，这个函数返回就保存什么。

　　map语法：map(function,iterable) 可以对迭代对象中的每一个元素
    映射分别取执行function

　　

例子01：
    # map 对每个元素进行映射（#############）
    def func(e):
    return e*e
    mp=map(func,[1,2,3,4,5]) #对每个元素平方，返回新的列表
    print(mp)  #打印：<map object at 0x000000DFDD76D2B0>
    print(list(mp)) #[1, 4, 9, 16, 25]
    例子02：
    改写成lambda:  lambda 必须一行写出来，直接返回值
    print(list(map(lambda x:x*x,[1,2,3,4,5])))
    #打印：[1, 4, 9, 16, 25]
    例子03：
    #计算两个列表中相同位置的数据和
    lst1=[1,2,3,4,5]
    lst2=[2,4,6,8,10]
    print(list(map(lambda x,y:x+y,lst1,lst2))) #[3, 6, 9, 12, 15]
    例子04：
    #map案例：
    lst=["1_123", "alex_456", "wusir_123", "wusir_456", "alex_789"]
    m=map(lambda s:s=="1_456",lst)
    print(list(m))
    def fun(s):
    if s=="1_456":
        return "登陆成功"

五：在函数中调用函数本身，就是递归：################

def func():
        print("我是谁！")
        func()
    func()  #循环打印：  我是谁

    #python中递归的深度最⼤到1000  但是永远到不了一千
    def foo(n):
        print(n)
        n+=1
        foo(n)
    foo(1)

六：递归的应用（############重点）

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

　　

例子：01

    import os
    def func(path):
        lst=os.listdir(path) #打开一个文件夹
        print(lst)
        for el in lst: #当前文件夹内的所有文件名。包括文件夹的名字
            #拼接文件的真实路径
            # file_real_path=os.path.join(path,el)  #文件路径的固定写法  os.path.join(path,el)
            q = os.path.join(path, el)  # 文件路径的固定写法
            #判断这个路径是文件夹还是文件
            if os.path.isdir(q):
                #递归的入口
                print(el)
                func(q)  #重新执行刚才的操作，如果是文件则继续打开
            else:#不是文件夹，是文件则返回文件名
                print(el)
    func("F:/1")

#####################习题！

#计算1-3+5-7+9......99的结果
        sum=0
        fu=1
        for i in range(1,100,2):
            sum+=i*fu
            fu=-fu
        print(sum)

七：二分法（掐头去尾取中间）###最主要的是：二分法需要的是已经排序好的列表才行！

    二分法：第一种

lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
    left=0
    right=len(lst)-1
    num=int(input("请输入您需要判读的数字："))

    while 1:
        if left<=right:   #左右索引可以相等
            mid=(left+right)//2  ##每次的都是以中间值为分界的
            if lst[mid]>num:      ###说明我们要找的数字在中间值得左边
                right=mid-1
            elif lst[mid]<num:    ### 说明我们呢要找的值在中间值得右边
                left=left+1
            else:
                print("找到了！")
                break

        else:
            print("没找到！")

二分法：第二种

          0   1   2    3    4   5      6    7      8
    lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

    def binary_search(lst, n, left, right):
        if left > right:
            return False
        mid = (left + right) // 2
        if n > lst[mid]:
            left = mid + 1
        #重点# 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值##############################
            return binary_search(lst, n, left, right)
        elif n < lst[mid]:
            right = mid - 1
            return binary_search(lst, n, left, right)
        else:
            print("找到了")
            return True


    n = int(input("请输入一个数字n:")) # 178
    ret = binary_search(lst, n, 0, len(lst)-1)
    print(ret)

二分法：第三种

#切换列表,这种方法主要思想：以中间的数字为界限，如果要找的数字比中间数字大，则左边的数据切割掉不需要了，再以
        #中间数字为起始位置开始切割，不断持续相同切割方法，最后找到我们要找的数据，反之亦然！主要改变的是列表的长度
    def binary_search(lst, n):
        if len(lst) == 0:
            return False
        left = 0
        right = len(lst) - 1
        mid = (left + right) // 2
        if n > lst[mid]:
            left = mid + 1
            # 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值
            return binary_search(lst[mid+1:], n)
        elif n < lst[mid]:
            right = mid - 1
            return binary_search(lst[:mid], n)
        else:
            print("找到了")
            return True

    n = int(input("请输入一个数字n:")) # 178
    ret = binary_search(lst, n)
    print(ret)

八：递归深度：

 # 递归深度
    # def func():
    #     print("哈哈")
    #     func()
    # func()
    # python中最大的递归深度是3000 但是你永远到不了3000

    实际测试说明：最大深度是1000，但是到不了1000
    import sys # system python, os 操作系统
    print(sys.getrecursionlimit())
    sys.setrecursionlimit(3000) # 最大是3000 你到不了3000