lamda匿名函数，递归，二分查找

一、匿名函数lamda

　　为了解决一些简单的需求而设计的一句话函数.  lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数

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

a = lambda x, y: x + y  # lambda 匿名函数 一行搞定一个函数. 但是, 不能完成复杂的函数操作
print(a(2, 5))  #7
print(a.__name__) 
b = lambda x, y: x * y
print(b(4, 5))  #20

　　（1）与sorted()在一起用

lst = [{'id': 1, 'name': 'alex', 'age': 18},
       {'id': 2, 'name': 'taibai', 'age': 55},
       {'id': 3, 'name': 'wusir', 'age': 33},
       {'id': 4, 'name': 'ritian', 'age': 22},
       {'id': 5, 'name': 'nvshen', 'age': 18},
       ]
l1 = sorted(lst, key=lambda dic:dic['age'])  #根据列表里的字典的年龄大小来排序
print(l1)
# [{'id': 1, 'name': 'alex', 'age': 18}, {'id': 5, 'name': 'nvshen', 'age': 18}, 
#  {'id': 4, 'name': 'ritian', 'age': 22}, {'id': 3, 'name': 'wusir', 'age': 33}, 
#  {'id': 2, 'name': 'taibai', 'age': 55}]

　　（2）与filter()一起用　

lst = [{'id': 1, 'name': 'alex', 'age': 18},
       {'id': 2, 'name': 'taibai', 'age': 55},
       {'id': 3, 'name': 'wusir', 'age': 33},
       {'id': 4, 'name': 'ritian', 'age': 44},
       {'id': 5, 'name': 'nvshen', 'age': 22},
       ]
li = filter(lambda dic: dic['age'] > 40, lst)  #过滤掉列表里年龄没有超过40的字典
print(list(li))
# [{'id': 2, 'name': 'taibai', 'age': 55}, {'id': 4, 'name': 'ritian', 'age': 44}]

　　（3）与map()一起用

lst1 = [1, 2, 3, 4, 5]
lst2 = [6, 7, 8, 9, 10]
print(list(map(lambda x, y: x + y, lst1, lst2)))  #把两个列表索引相同的元素相加,组成一个新列表
#[7, 9, 11, 13, 15]

二. 递归函数

　　 在函数中调用函数本身. 就是递归.

def f():
    print('hello ,world')
    f()  #调用自身
f()  #最多调用996层,然后报错

import sys
sys.setrecursionlimit(10000)    # 可以调整递归深度. 但是不一定能跑到

　　递归的应用: 可以使用递归来遍历各种树形结构, 比如文件夹系统. 可以使用递归来遍历该文件夹中的所有文件.

# 遍历树形结构
import  os
filePath = "d:pycharm"
def read(filePath, n): #n的值可以用来对文件缩进
    it = os.listdir(filePath)   # 打开文件夹
    for el in it:
        #  拿到路径
        fp = os.path.join(filePath, el) # 获取到绝对路径
        if os.path.isdir(fp):   # 判断是否是文件夹
            print("	"*n,el)  #通过n的大小来对文件夹进行缩进
            read(fp, n+1)    # 又是文件夹. 继续读取内部的内容 递归入口
        else:
            print("	"*n,el)    # 递归出口

read(filePath, 0)  #初始值为0,第一层文件夹不用缩进

三. 二分查找

　   二分查找. 每次能够排除掉一半的数据, 查找的效率非常高, 但是局限性比较大, 必须是有序列才可以使用而分查找    

　　要求: 查找的序列必须是有序列.

# 判断n是否在lst中出现. 如果出现请返回n所在的位置 
# 二分查找: 非递归算法 
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
count = 1
while left <= right:  #当作表索引小于等于右边索引,可以继续比较
    middle = (left + right) // 2  #中间索引
    if n > lst[middle]:  #若n大于中间值,则n的取值在右边部分,middle的索引需要向右移动一位
        left = middle + 1  
    elif n < lst[middle]:  #若n小于中间值,则n的取值在左边部分,middle的索引需要向左移动一位
        right = middle - 1
    else:
        print(count)  #比较的次数
        print("存在")
        print(middle)
        break
    count = count + 1
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:  #比较结束后没有n的值,再进行比较时就会出现左索引大于右边索引,
        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需要获得再次调用的返回值
print(binary_search(0, len(lst)-1, 65) )