内置函数二. 递归 二分法

一、lambda匿名函数

       为了解决一些简单的需求而设计的一句话函数，如下示例：

    # 以前的写法
    def func(n):
        return n ** n
    print(func(10))

    # lambda函数
    f = lambda n : n ** n
    print(f(10))
    print(f.__name__)  # 结果为：<lambda>
    # __name__可以查看函数的名字，匿名函数__name__的值都是<lambda>

　　lambda表示的是匿名函数，不需要用def来声明，一句话就可以声明出一个函数，语法如下：

              函数名 = lambda 参数 ： 返回值

注意：

       1，函数的参数可以有多个，多个参数之间用逗号隔开；

       2，匿名函数不管多复杂，只能写一行，且逻辑结束后直接返回数据；

       3，返回值和正常的函数一样，可以是任意数据类型；

再注意：匿名函数有两个返回值时，返回值用()括起来，如下示例：

    suiyi = lambda x, y : (x+1, y+2)   
    print(suiyi(2,3))  # 结果为：(3, 5)

　　匿名函数并不是说一定没有名字，上面的例子中匿名函数前面变量就是一个函数名，说它匿名是因为我们通过__name__查看的时候是没有名字的，统一都叫lambda，在调用的时候没有什么特别之处，像正常的函数调用即可。

二、sorted()

       前边我们学了一个排序函数sort()，这是列表的专用排序函数，详见“python数据类型二（列表和元组）”，python的内置函数中为我们提供了一个通用的排序方案：sorted()。

       排序函数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]，返回新列表是经过排序的

    dic = {1:'a', 3:'c', 2:'b'}
    print(sorted(dic)) # 结果为：[1, 2, 3]
    # 如果是字典，则返回排序过后的key

和普通函数组合使用，示例如下：

    # 根据字符串长度进行排序
    lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
    # 计算字符串长度
    def func(s):
        return len(s)
    print(sorted(lst, key=func))
    # 结果为：['狐仙', '麻花藤', '冈本次郎', '中央情报局']

和lambda匿名函数组合使用，示例如下：

    # 根据字符串长度进行排序
    print(sorted(lst, key=lambda s : len(s)))
    # 结果也为：['狐仙', '麻花藤', '冈本次郎', '中央情报局']

    # 有如下列表，按照年龄对学生信息进行排序
    lst = [
        {'id':1, 'name':'alex', 'age':18},
        {'id':2, 'name':'wusir', 'age':17},
        {'id':3, 'name':'taibai', 'age':19}
    ]
    print(sorted(lst, key=lambda el : el['age']))

三、filter()

       筛选函数：语法：filter(function, Iterable)

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

                            Iterable：可迭代对象

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

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

四、map()

       映射函数：语法：map(function, iterable)对可迭代对象中的每一个元素进行映射，分别去执行function。

    # 计算列表中的每个元素的平方，返回新列表，如下示例：
    def func(e):
        return e*e
    mp = map(func, [1,2,3,4,5])
    print(list(mp))  # 结果为：[1, 4, 9, 16, 25]
    # 改写成lambda匿名函数
    print(list(map(lambda e : e*e, [1,2,3,4,5])))

    # 计算两个列表中相同位置的数据的和(遵循水桶效应，即长度取决于最短的列表长度)
    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]

注意：map()函数的代码很简单，但是思想很重要，分而治之的思想，map(func1, map(func2, map(func3 , lst)))。

五、递归

       在函数中调用函数本身，就是递归。如下示例：

    def func():
        print("我是谁")
        func()
    func()

　　递归深度就是函数自己调用自己的次数，官方文档中递归最大深度是1000. 但是在这之前就会报错，所以到不了1000。下面示例可以显示递归的深度：

    def foo(n):
        print(n)
        n += 1
        foo(n)
    foo(1)

递归的应用：

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

    import os
    def read(filepath, n):
        files = os.listdir(filepath)   # 获取到当前文件夹中的所有文件
        for fi in files:  # 遍历文件夹中的文件，这里获取的只是本层文件名
            fi_d = os.path.join(filepath, fi)
            if os.path.isdir(fi_d): # 如果该路径下的文件是文件夹
                print("	"*n, fi)
                read(fi_d, n+1)  # 继续进行相同的操作
            else:
                print("	"*n, fi)  # 递归出口，最终在这里隐含着return

    # 递归遍历目录下所有文件
    read('e:/pythonDemo', 0)

六、二分法查找（核心：掐头去尾取中间，一次砍一半）

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

    # 判断n是否在lst中出现，如果出现请返回n所在的位置
    # 方法一：二分法--常规循环，非递归算法
    lst = [22,33,44,55,66,77,88,99,101,238,345,456,567,678,789]
    n = 567
    left = 0
    right = len(lst) - 1
    count = 1
    while left <= right:
        mid = (left + right) // 2
        if n < lst[mid]:
            right = mid - 1
        elif n > lst[mid]:
            left = mid + 1
        else:
            print(f"查找了{count}次")
            print(f"索引是{mid}")
            break
        count += 1
    else:
        print("不存在")

    # 方法二：递归二分法
    def search(n, left, right):
        if left <= right:
            mid = (left+right)//2
            if n < lst[mid]:
                right = mid - 1
            elif n > lst[mid]:
                left = mid + 1
            else:
                return mid
            return search(n, left, right)
            # 这个return必须要加，否则接收到的永远是None。
        else:
            return -1

    print(f"索引是{search(567, 0, len(lst)-1)}")

    # 方法三：另类二分法，弊端是无法获取查找元素的位置，只能判断是否存在
    def search2(lst, target):
        left = 0
        right = len(lst) - 1
        if left > right:
            print("不存在")
        mid = (left+right)//2
        if target < lst[mid]:
            return search2(lst[:mid],target)
        elif target > lst[mid]:
            return search2(lst[mid+1:],target)
        else:
            print("存在")
    search2(lst, 567)

二分法拓展：

    # 查找的时间复杂度最低, 空间复杂度最低
    lst1 = [5,6,7,8]
    lst2 = [0,0,0,0,0,0,0,0,0]  # lst1的最大数字是n就设置n+1个元素的lst2
    for el in lst1:
        lst2[el] = 1   # 将lst2中的下标分别为lst1中元素的元素设置为1
    # lst2 = [0,0,0,0,0,1,1,1,1]
    if lst2[6] == 1:   # o(1)，查找一次即可知道是否存在
        print("存在")
    else:
        print("不存在")

补充：上篇遗留问题（repr()函数）

repr()的官方文档写的是：Return the canonical string representation of the object，翻译为：返回对象的规范字符串表示形式。

    print("你好. 我\叫周润发") # 对用户是友好的. 非正式的字符串，结果为：你好. 我叫周润发

    # 正式(官方)的字符串, 面向对象的时候能用到
    print(repr("你好, 我"叫周润发")) # 程序中内部存储的内容, 这个是给程序员看的
    # 结果为：'你好, 我"叫周润发'

    print("我叫%r" % "周润发") # %r 实际上调用的是repr() 结果为：我叫'周润发'

    # 原样输出
    print(r"马化腾说:"哈哈哈, " 
	")

    print("你好") # 用户看着舒服
    print(repr("你好")) # 真实的字符串表示形式(正式的)