1,lambda: 匿名函数
2.sorgted() 排序函数
3,filter() 过滤函数 筛选
4,map() 映射函数
5.递归
6.二分法
一. 匿名函数: lambda
lambda 表示的是匿名函数,不用def 来声明,一句话就可以声明一个函数.
例如:我们为力了解决一些简单的需求而设计了一句话函数:
def func(n): return n *n return func(9) print(ret) # 81
但是我们用匿名函数就会相对来说方便一些
匿名函数语法: 函数名= lambda 参数 : 返回值
例: 同上 匿名函数的操作方法
a = lambda n : n*n print(a(9) # 81
def func(a,b) return a + b x = lambda a,b : a + b print(x(1,2)) # 3
笔试题
def func(x,y) return x ,y print(func(1,2)) # (1,2) 元组形式 匿名函数方法: 错误(大坑) a = lambda x,y : 1,2 print(a) # (<function <lambda> at 0x0000000000613E18>, 2) 前三项会算到一起 正确的方法: a = lambda x,y : (1,2) print(a) # (1,2) 元组形式
匿名函数,给函数传递多个参数,返回最大值
func = lambda *ages : max(ages) #单行函数 print(func(1,2,3,4,5,6,66,7,8,99,34,2,32,53,5,256)) # 256
注意;
1.函数的参数可以是多个,多个参数之间用逗号隔开
2.匿名函数不管多复杂,只能写一行,且逻辑结束后直接返回数据.
3.返回值的和正常函数一样,可以是任意数据类型
匿名函数的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的,统一都叫 lambda .在调用的时候没有什么特别之处.
二. sorted() 排序函数
语法: sorted(Iterable,key ,reverse)
iterable:可迭代对象
key;排序规则.
运行流程:sorted函数内部会把可迭代对象中的每一个元素交给后面的key 函数来执行,得到一个数字(权重),通过这个数字进行排序.
reverse: 是否倒序 True;是 False: 否
例: 列表的排序
lis = [1,2,4,55,67,8,9,32,45] lis.sort() # 列表的方法 print(lis) # [1,2,4,8,9,32,45,55,67] 内置函数提供了一个通用的排序方案, sorted() s = sorted(lis) print(lis) # [1,2,4,8,9,32,45,55,67]
例; 列表
lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"] def func(a): return len(a)//2 ll = sorted(lst, key=func) print(ll) # ['聊斋', '西游记', '葫芦娃', '水浒传', '年轮', '亮剑', '三国演义'] def func(s): return len(s)%2 ll = sorted(lst, key=func) print(l1) # ['聊斋', '三国演义', '年轮', '亮剑', '西游记', '葫芦娃', '水浒传']
例:字典 和lambda组合使用
lst = [ {'name':"汪峰","age":48}, {"name":"章子怡",'age':38}, {"name":"alex","age":39}, {"name":"wusir","age":32}, {"name":"赵一宁","age":28} ] # 按照名字长度排序 ll = sorted(lst, key=lambda el: len(el['name']), reverse=False) print(ll) #结果 [{'name': '汪峰', 'age': 48}, {'name': '章子怡', 'age': 38}, {'name': '赵一宁', 'age': 28}, {'name': 'alex', 'age': 39}, {'name': 'wusir', 'age': 32}] #按照名字长度排序 倒序 ll = sorted(lst, key=lambda el: len(el['name']), reverse=True) print(ll) #结果 [{'name': 'wusir', 'age': 32}, {'name': 'alex', 'age': 39}, {'name': '章子怡', 'age': 38}, {'name': '赵一宁', 'age': 28}, {'name': '汪峰', 'age': 48}]
三.filter() 过滤函数 筛选
语法; filter(function,iterable)
把可迭代对象中的每一个元素交给前面的函数(function)进行筛选,函数(function)返回 True 或者 False .
所有返回的 True 都会被留下,所有返回的 False 都会被过滤掉.
例:
lst = ["张无忌", "张铁林", "赵一宁", "石可心","马大帅"] f = filter(lambda el : el[0] != "张",lst) # 将lst中的每一项传递给func, 所有返回True的都会保留, 所有返回False都会被过滤掉 print("__iter__"in dir(f)) #判断是否可以进行迭代 for e in f: print(e) # True 赵一宁 石可心 马大帅
例:
lst = [ {"name":"汪峰", "score":48}, {"name":"章子怡", "score":39}, {"name":"赵一宁","score":97}, {"name":"石可心","score":90} ] f = filter(lambda el: el['score'] < 60 , lst) # 根据分数低于60分的 去16期的人 print(list(f)) # [{'name': '汪峰', 'score': 48}, {'name': '章子怡', 'score': 39}]
四.map() 映射函数
语法: map(function,iterable)
把可迭代对象中的数据交给前面的函数进行执行,返回值就是map的处理结果.
例: 计算列表中每个数字的平方
lst = [1,4,7,2,5,8]
lst = [1,4,7,2,5,8] def func(el): return el**2 m = map(func,[1,4,7,2,5,8]) print(lst(m)) # [1, 16, 49, 4, 25, 64] #转换成 lambda m = map(lambda el ; el**2,lst) #把后面的可迭代对象中的每一个元素传递给function, 结果就是function的返回值print(lst(m)) # [1, 16, 49, 4, 25, 64]
分而治之 : map(func1, map(func2, map(func3 , lst)))
例;
计算两个列表中相同位置的数据的和
lst1 = [1, 3, 5, 7,8]
lst2 = [2, 4, 6, 8, 10]
m = map(lambda x,y : x + y ,lst1,lst2)
print(list(m))
# [3, 7, 11, 15, 18]
水桶效应(短板效应), zip()
lst1 = [1, 3, 5, 7]
lst2 = [2, 4, 6, 8, 10]
m = map(lambda x, y, z: x + y+ z, lst1, lst2, [5,1,2,3,6])
print(list(m))
# [8, 8, 13, 18]
五.递归
函数自己调用自己
递归深度. 你可以自己掉用自己的次数.
最大深度: 1000, 到不了1000就停了.
官方文档中递归最大深度是1000. 在这之前就会给你报错
例;
count = 1 def func(): global count print("alex是很帅的", count) count = count + 1 func() func() #
........ alex是很帅的 990 alex是很帅的 991 alex是很帅的 992 alex是很帅的 993 alex是很帅的 994 alex是很帅的 995 alex是很帅的 996 alex是很帅的 997 alex是很帅的 998Traceback (most recent call last): File "E:/python_01/day15/code/08 递归.py", line 11, in <module> func() File "E:/python_01/day15/code/08 递归.py", line 10, in func func() File "E:/python_01/day15/code/08 递归.py", line 10, in func func() File "E:/python_01/day15/code/08 递归.py", line 10, in func func() [Previous line repeated 993 more times] File "E:/python_01/day15/code/08 递归.py", line 7, in func print("alex是很帅的", count) RecursionError: maximum recursion depth exceeded while calling a Python object Process finished with exit code 1
递归的应用:
我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统. 可以使递用归来遍历该文件夹中的所有文件
# 遍历 D:/sylar文件夹, 打印出所有的文件和普通文件的文件名 import os def func(filepath, n): # d:/sylar/ # 1,打开这个文件夹 files = os.listdir(filepath) # 2. 拿到每一个文件名 for file in files: # 文件名 # 3. 获取到路径 f_d = os.path.join(filepath, file) # d:/sylar/文件名/ # 4. 判断是否是文件夹 if os.path.isdir(f_d): # 5. 如果是文件夹. 继续再来一遍 print("\t"*n, file,":") # 打印文件名 func(f_d, n + 1) else: # 不是文件夹. 普通文件 print("\t"*n, file) func("d:/sylar",0)
六.二分法查找
核心: 掐头去尾取中间. 一次砍一半
两种算法: 常规循环, 递归循环
要求: 查找的序列必须是有序序列.
例: for循环方法查找
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789 ] n = 79 for el in lst: if el == n: print("找到了") break else: print("没有") # 没有
例: 二分法查找; 使用二分法可以提高效率, 前提条件:有序序列 /非递归二分法查找
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789] n = 88 left = 0 right = len(lst) - 1 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("找到这个数了") break 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: mid = (left+right)//2 if n < lst[mid]: right = mid -1 return func(n,left,right) if n > lst[mid]: left = mid + 1 return func(n,left,right) if n == lst[mid]: print("找到这个数了") return mid else: print("没有这个数") return -1 ret = func(77,0,len(lst) - 1) print(ret) # 找到这个数了 6
另类二分法,很难计算位置
def binary_search(ls, target): left = 0 right = len(ls) - 1 if left > right: print("不在这里") middle = (left + right) // 2 if target < ls[middle]: return binary_search(ls[:middle], target) elif target > ls[middle]: return binary_search(ls[middle+1:], target) else: print("在这里") binary_search(lst, 567)
最快的查找方法:(面试题)
例:
# 时间复杂度最低, 空间复杂度最低 lst1 = [5,6,7,8] lst2 = [0,0,0,0,0,1,1,1,1] for el in lst1: lst2[el] = 1 lst2[4] == 1 # o(1)
列表相对字典省空间
