内置函数2 递归

lambda 匿名函数

　　语法 lambda 参数;返回值

a = lambda n : n * n 
print(a)
 
#n = 2
#4

s = lambda x,y:x,y
print(s) 
#这个会报错，默认认为  x,y:x  是一对元组，y  没有传值，会报错

s = lambda x,y:(x,y)
print(s) 
#用括号括起来说明这是一个整体，就ok

sorted()  排序函数

　　内置函数中提供了一个通用的排序方案

　　

lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"]
def func():
    ruturn len(lst) % 2
li = sorted(lst,key = func)
print(li)
# 聊斋 三国演义 年轮 亮剑 西游记 葫芦娃 水浒传

lst = [
    {'name':"汪峰","age":48},
    {"name":"章子怡",'age':38},
    {"name":"alex","age":39},
    {"name":"wusir","age":32},
    {"name":"赵一宁","age":28}
    ]
li = dorted(lst,key = lambda el : len(el['name']))
print(li)
#{'name': 'wusir', 'age': 32}, {'name': 'alex', 'age': 39},
# {'name': '章子怡', 'age': 38},
# {'name': '赵一宁', 'age': 28}, {'name': '汪峰', 'age': 48}]

filter()   筛选函数

　　

lst = [
    {"name":"汪峰", "score":48},
    {"name":"章子怡", "score":39},
    {"name":"赵一宁","score":97},
    {"name":"石可心","score":90}
]
f = filter(lambda el : el['score'] < 60,lst)
print(list(f))

map

　　一句话，分而治之

map (func1,map(func2,map(func3,map)))

递归

　　递归函数有最大的深度是 1000，实际到 998 左右就会报错

　　可以调整最大的深度，import sys        但是不建议这样做

二分法

　　一句话 掐头去尾取中间

　　二分法使用场景   有序序列

　　

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 ]
n - 66
left = 0
right = len(lst) - 1     #获取索引 索引从0 开始
while left <= right:    #边界，当右边的比左边还小的适合退出循环
    mid = (left + right)//2     #必须整除，索引没有小数
    if lst[mid] > n:
        right = mid - 1
    if lst[mid] < n:
        left = mid + 1
    if lst[mid] == n:
        print('找到了')
else:
    print('没有这个数')

递归来完成二分法

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789]
def func(n,left,right):
    if left <= right:
        print('哈哈')
        mid = (left + right)// 2
        if n > lst[mid]:
            left = mid + 1
            return func(n,left,right)
        if n <lst[mid]:
            right = right + 1
            return func(n,left,right)
        if n ==lst[mid]:
            print('找到了')
            return mid
    else:
        prinit('没有这个数')
        return -1

ret = func(66,0,len(lst) - 1)
print(ret)