1. lamda匿匿名函数 2. sorted() 3. filter() 4. map() 5. 递归函数

一.lambda 函数
lambda函数是为了解决一些简单的需求而设计的一句话函数
def func(n):
    return n**n
print(func(10))

f = lambda n: n**n
print(f(10))
lambda表示的是匿名函数,不需要用def来声名出一个函数

语法:
函数名 = lambda 参数:返回值

注意:
函数的参数可以有多个,多个参数之间用逗号隔开
匿名函数不管多复杂,只能写一行,且逻辑结束后直接返回数据
返回值和正常的函数一样,可以是任意数据类型

匿名函数并不是说一定没有名字,这里前面的变量就是一个函数名,说他是匿名原因是我们通过__name__
查看的时候是没有名字的,同意都叫lambda,再调用的时候没有什么特别之处,想正常的函数调用即可.

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

和函数的组合使用:
lst = ['abc', 'abcd','ab'', abcde']
def func(s):
    return len(s)
print(sorted(lst, key=func))

和lambda组合使用
def func(s):
    return len(s)
print(sorted(lst, key=lambda s: len(s)))

三.filter筛选函数
语法: filter(function.Iterable)
function: ⽤用来筛选的函数.在filter中会自动的把iterable中的元素传递给function.然后
根据function返回的True或者False来判断是否保留此项数据
Iterable: 可迭代对象

lst = [1,2,3,4,5,6,7]
ll = filter(lambda x: x%2==0, lst)    # 筛选所有的偶数 print(ll)
print(list(ll))

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))

四.map()映射函数
语法: map(function, iterable)
可以对可迭代对象中的每一个元素进行映射.分别取执行function
计算列列表中每个元素的平方, 返回新列表
def func(e):
    return e*e
mp = map(func, [1, 2, 3, 4, 5])
print(mp)
print(list(mp))

改写成lambda:
print(list(map(lambda x: x * x, [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)))

五.递归
什么是递归呢?就是在函数中调用它本身,这就是递归
在python中递归的深度最大是997.官方文本中说的是1000但是永远到不了1000
递归的应用:
我们可以使用递归来遍历各种树形结构,比如我们的文件夹系统,可以使用递归来遍历改文件夹中的所有文件
import  os
filePath = "文件夹路径"
def read(filePath, n):
    it = os.listdir(filePath)   # 打开文件夹
    for el in it:
        #  拿到路径
        fp = os.path.join(filePath, el) # 获取到绝对路径
        if os.path.isdir(fp):   # 判断是否是文件夹
            print(" "*n,el)
            read(fp, n+1)    # 又是文件夹. 继续读取内部的内容递归入口
        else:
            print(" "*n,el)    # 递归出口

read(filePath, 0)
六.二分查找
二分查找,每次都能够排除一般的数据,查找的效率非常高,但是局限性比较大,必须是有序序列才可以使用二分查找
要求:查找的序列必须是有序序列
while循环来进行二分查找:
lst=[11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
n = 567
left = 0   #最左边的元素的索引位置
right = len(lst) - 1    #最右边的元素的索引位置
while left <= right:    #判断左右两端的值,如果右边的大于左边就说明遍历完成
    middle = (left + right) // 2  #求中间值
    if n > lst[middle]:  #如果我们要查找的n大于中间值,说明n在序列的左边
        left = middle + 1  #下次查找前就把左边的值改成中间值右边一个值,也就是中间值加1的位置
    elif n < lst[middle]:  #如果我们要查找的n小于中间值,说明n在序列的左边
        right = middle - 1 #下次查找前就把右边的值改成中间值左边一个值,也就是中间值减1的位置
    else:       #如果我们要查找的n等于中间值,直接找到,输出结果并退出
        print("存在")
        print(middle)
        break
else:     #否则就是不存在要查找的那个值
    print("不存在")

下面我们试试用递归的方法进行二分查找:
lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
def binary_search(left, right, n):
    middle = (left + right)//2
    if left > right:
        return -1
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle
    return binary_search(left, right, n)  #这一行的return是必须要加上的,否则接收到的结果将永远是None
print(binary_search(0, len(lst)-1, 65) )