二：函数递归，匿名，表达式

总结：
今日内容：
    函数递归  ******
    算法之二分法
    生成式     *****
    匿名函数        ***
    常用的内置函数      ****
   
   
    一：函数递归（函数不能无限制的递归下去，无任何意义）
            了解：在python中最大递归深度为1000，或者988左右，是python自己处理好的，最大递归深度也可更改
            概念：函数在调用阶段直接或间接的又调用自身
            递归分为两个阶段：
                            1，回溯：由未知条件向已知条件推导的过程，是重复的问题复杂度越来越低的过程
                            2，递推：一次次往回推导的过程

            总结：递归函数不要考虑循环多少次，只需要把握结束条件
                  即必须要有结束条件

            案列：
                l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12]]]]]]]]]]]]
                # 将列表中的数字依次打印出来(循环的层数是你必须要考虑的点)
                def get_num(l):
                    for i in l:#循环取出列表中中的值
                        # print(i,type(i))     #此时的i 为两个值，1和列表，因为大列表中包含1和一个列表，共两个元素
                        if type(i) is int:   # 若循环得到的i为 int 类型 则打印
                            print(i)
                        else:               # 如果不是则继续调用函数         **************************
                            get_num(i)      #  此时函数括号中的实参为一个列表 ，此列表i中又包含一个字符和一个列表    ***********************
                get_num(l)      结果为：1 2 3 4 5 6 7 8 9 10 11 12

                案列总结：l，列表中包含一个int的字符和一个列表，共两个 ‘元素’
                            通过for循环得到的结果 也是一个int型字符 和一个列表
                            然后判断的到的字符的类型，如果为int型，就是结果，复杂度又少了一层
                            依次类推，最后循环取出所有符合要求的值
                    注意：else         后面的代码，
                          get_num(i)   此时函数括号中的实参为一个列表 ，此列表i中又包含一个字符和一个列表
                解题思路：1，对容器进行for循环取值，理清取出来的值是什么，和是什么类型，
                          2，提出条件，即判断条件语句，执行满足条件的代码
                          3，不满足条件，拿到不满足条件，对其进行分析类型和，让后传参给函数，继续执行
                                间接或直接的调用自身

    二：函数之二分法：（解决问题的高效的方法）
                    容器里面的数字必须有大小数字
                    （提高效率，减低取值或者操作的次数，快速达到想要的结果）

                案例：
                    判断或取值的列子
                        target_num = 45
                        l = [1,2,3,4,5,6,7,8,9,22,12,34,45,56,67,78,]
                        l.sort(reverse=False)  #[1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 22, 34, 45, 56, 67, 78]
                        def get_num(l,target_num):  #注意传的参数
                            if not l:
                                print('列表不存在')
                                return
                            # 获取列表中间的索引
                            msg_index = len(l)//2    #整除   例子：r = [1,2.3,4,5]   print(len(r)//2)   =》2
                            # 判断target_num 的值和列表中间索引对应值的大小
                            if target_num >l[msg_index]:
                            #将列表进行切片，切取列表右半部分
                                num_rigit = l[msg_index + 1:]   #注意要加一  索引右边开始一直到最后，即列表后半段
                                #再次递归调用get_num
                                get_num(num_rigit,target_num)  #再次调用 注意括号中的是列表和你给的参数
                            elif target_num < l[msg_index]:      #前半段列表
                                # 切取列表左半部分
                                num_left = l[0:msg_index]
                                # 递归调用
                                get_num(num_left,target_num)
                            else:
                                print('找到了！',target_num)  #注意在这里是变量名，不加双引号
                        get_num(l,target_num)

    三：三元表达式：
                         值1 if 条件 else 值2
                            条件成立   值1
                            条件不成立   值2
                        案列：
                            x = 22222
                            y = 111111
                            res = x if x > y else y
                            # 如果if后面的条件成立返回if前面的值 否则返回else后面的值
                            print(res)
        列表生成式：
                        l = ['w1_sg','www_sg','sd','w12']
                        res = [name for name in l if name.endswith('_sg') ]     # 后面不支持再加else的情况
                        print(res)
                        先for 循环依次取出列表里的每一个元素
                        然后交由if判断 条件成立才会交给for前面的代码
                        如果条件不成立 当前的元素就直接舍弃
                         res = ['%s_DSB'%name for name in l]    增加
        字典生成式  注意
                    ....l1 = ['jason','123','read']
                        d = {i:j for i,j in enumerate(l1) if j != '123'}
                        print(d)   # {0: 'jason', 2: 'read'}
                    案列：
                    res = {i for i in range(10) if i != 4}
                    print(res)   #{0, 1, 2, 3, 5, 6, 7, 8, 9}
    四：匿名函数
                没有名字的函数
            特点：临时存在用完就没了
                关键字：(lambda 参数1，参数2:返回值)(参值1，参值2)
                注意：：（冒号）左边的相当于函数的形参
                        ：（冒号） 右边相当于函数的返回值
                    匿名函数通常不会单独使用，是配合内置函数一起使用的
            案例：res = (lambda x,y:x+y)(1,2)
                  print(res)     答案为 3
    五：常用内置函数
             map zip filter sorted reduce
             map 映射
                    l = [1,2,3,4,5,6]
                    print(list(map(lambda x:x+5,l ))) 基于for循环   #[6, 7, 8, 9, 10, 11]   l是列表名
             zip 拉链     基于for循环
                    有多少拉多少与之都匹配的
                    l1 = [1,2,]
                    l2 = ['jason','egon','tank']
                    l3 = ['a','b','c']
                    print(list(zip(l1,l2,l3)))   #[(1, 'jason', 'a'), (2, 'egon', 'b')]
            filter  过滤
                    l4 = [1,2,3,4,5,6]
                    print(list(filter(lambda x:x == 3, l4)   # 基于for循环   过滤掉不是3的字符
            sorted   反转
                    l5 = ['jason','egon','nick','tank']
                    print(sorted(l5,reverse=True))     # 反转降序，按首字母  ['tank', 'nick', 'jason', 'egon']
            reduce          ************************
                   案列：
                    from functools import reduce

                    l = [1,2,3,4]
                    print(reduce(lambda x,y:x+y,l,))   #12 为初始值  ，即第一个参数次      结果位22
                    如果初始值不存在，则按照下面的规律：
                              第一次先获取两个元素相加
                               之后每次获取一个与上一次相加的结果再相加       此题为 10

补充（了解）
一：递归深度： 
# import sys
# print(sys.getrecursionlimit())  # 不是很精确   获取递归深度
# sys.setrecursionlimit(2000)      更改递归深度
二：注释方式：
# def index():
    # pass  # 第一种顶替方式(推荐使用pass)
    # ...  # 第二种顶替方式

1,排序：reverse=True   为倒序  即降序
        reverse=Flase  为顺序  即升序
        l.sort(reverse=True)   把列表中的字符按降序排
2，字符编码对应关系：
            a-z  97 122
            A-Z  65 90
        print(chr(97))  为 a
3,单词：iterable  可迭代
        filter  过滤