lamda匿名函数(与sorted(),ﬁlter(),map() 一起用), 递归函数, 二分查找

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一. 匿名函数

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

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

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

与sorted()在一起用

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

与filter()一起用

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

与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("\t"*n,el) #通过n的大小来对文件夹进行缩进
read(fp, n+1) # 又是文件夹. 继续读取内部的内容递归入口
else:
print("\t"*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) )