一. lamda匿名函数
计算n的平方 def func(n): return n*n print(func(3)) 9
a=lambda n : n*n print(a(3)) 9
a=lambda x : x*x print(a) print(a.__name__) <function <lambda> at 0x000001EB533FD1E0> <lambda> # 查看函数的函数名
b=lambda x,y:x+y print(b(1,5)) 6
一行搞定一个函数. 但是, 不能完成复杂的函数操作
语法:
函数名 = lambda 参数: 返回值
注意:
1. 函数的参数可以有多个. 多个参数之间用逗号隔开
2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据
3. 返回值和正常的函数一样, 可以是任意数据类型
匿名函数并不是说一定没有名字. 这里前面的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的. 统⼀一都叫lambda. 在调用的时候没有什么特别之处. 像正常的函数调用即可
二. sorted() 排序函数.
语法: sorted(Iterable, key=None, reverse=False)
Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
lst=[1,2,7,6,52,4,9] lst.sort() print(lst) lst=[3,2,8,5,45,9,6] sorted(lst) print(lst) lst=[3,2,8,5,45,9,6] s=sorted(lst) print(s) [1, 2, 4, 6, 7, 9, 52] [3, 2, 8, 5, 45, 9, 6] [2, 3, 5, 6, 8, 9, 45]
lst=["无双剑姬","蛮王","大保健","诺克萨斯","易大师"] def func(lst): return len(lst) s=sorted(lst,key=func) print(s) s=sorted(lst,key=lambda lst:len(lst)) print(s) ['蛮王', '大保健', '易大师', '无双剑姬', '诺克萨斯'] ['蛮王', '大保健', '易大师', '无双剑姬', '诺克萨斯']
lst=["无双剑姬aaa","蛮王aa","大保健aaaaaa","诺克萨斯a","易大师aaaa"] def func(lst): return lst.count("a") li=sorted(lst,key=func) print(li) li=sorted(lst,key=lambda lst:lst.count("a")) print(li) ['诺克萨斯a', '蛮王aa', '无双剑姬aaa', '易大师aaaa', '大保健aaaaaa'] ['诺克萨斯a', '蛮王aa', '无双剑姬aaa', '易大师aaaa', '大保健aaaaaa']
lst=[{"id":1,"name":"宋江","age":28},
{"id":2,"name":"李逵","age":56},
{"id":3,"name":"林冲","age":29},
{"id":4,"name":"花荣","age":18},
{"id":5,"name":"武松","age":30}]
def func(dic):
return dic["age"]
print(sorted(lst,key=func))
print(sorted(lst,key=lambda dic:dic["age"]))
[{'id': 4, 'name': '花荣', 'age': 18}, {'id': 1, 'name': '宋江', 'age': 28}, {'id': 3, 'name': '林冲', 'age': 29}, {'id': 5, 'name': '武松', 'age': 30}, {'id': 2, 'name': '李逵', 'age': 56}]
[{'id': 4, 'name': '花荣', 'age': 18}, {'id': 1, 'name': '宋江', 'age': 28}, {'id': 3, 'name': '林冲', 'age': 29}, {'id': 5, 'name': '武松', 'age': 30}, {'id': 2, 'name': '李逵', 'age': 56}]
三. filter() 筛选函数
语法: filter(function. Iterable)
function: ⽤来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后 根据function返回的True或者False来判断是否保留留此项数据
Iterable: 可迭代对象
lst=[1,2,3,4,5,6,7,8,9] def func(i): return i%2==1 s=filter(func,lst) print(s) <filter object at 0x0000023C1AD15EB8>
lst=[1,2,3,4,5,6,7,8,9] def func(i): return i%2==1 s=filter(func,lst) print(list(s)) [1, 3, 5, 7, 9]
lst=[1,2,3,4,5,6,7,8,9] s=filter(lambda i :i%2==1,lst) print(list(filter(lambda i :i%2==1,lst))) [1, 3, 5, 7, 9]
lst=[{"id":1,"name":"宋江","age":28},
{"id":2,"name":"李逵","age":56},
{"id":3,"name":"林冲","age":29},
{"id":4,"name":"花荣","age":18},
{"id":5,"name":"武松","age":30}
]
s=filter(lambda dic: dic["age"]>40,lst)
print(list(s))
[{'id': 2, 'name': '李逵', 'age': 56}]
四. map() 映射函数
语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射. 分别取执行 function
lst=[1,2,5,6,4,8,24,5,23,25,29,51,12,14] def func(i): return i*i s=map(func,lst) print(list(s))
lst=[1,2,5,6,4,8,24,5,23,25,29,51,12,14] print(list(map(lambda i:i*i,lst)))
[1, 4, 25, 36, 16, 64, 576, 25, 529, 625, 841, 2601, 144, 196] [1, 4, 25, 36, 16, 64, 576, 25, 529, 625, 841, 2601, 144, 196]
lst1=[1,5,8,9,7] lst2=[5,9,8,6,4] print(list(map(lambda x,y:x+y,lst1,lst2))) [6, 14, 16, 15, 11]
五. 递归
在函数中调用函数本身. 就是递归
def func(): print("我喜欢") func() func()
在python中递归的深度最大到998
import sys sys.setrecursionlimit(10000) # 可以调整递归深度. 但是不一定能跑到这里 def func(): print("我喜欢") func() func()
import sys sys.setrecursionlimit(10000) def func(count): print("我喜欢%s" % count) func(count+1) func(1)
递归的应用:
我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统. 可以使用递归来遍历该
文件夹中的所有文件
import os filePath="E:chenwei" def read(filePath,n): it=os.listdir(filePath) # print(it.__iter__()) 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,1)
# 遍历树形结构 import os # filePath="E:chenwei" 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)
六. 二分查找
二分查找. 每次能够排除掉一半的数据. 查找的效率非常高. 但是局限性比较大. 必须是有序序列才可以使用二分查找
要求: 查找的序列必须是有序序列.
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]: left = middle + 1 elif n < lst[middle]: right = middle - 1 else: print(count) print("存在") print(middle) break count = count + 1 else: print("不存在") 4 存在 13
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) print(binary_search(0, len(lst)-1, 66) ) 5
lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111] def binary_search(lst, n): left = 0 right = len(lst) - 1 middle = (left + right) // 2 if right <= 0: print("没找到") return if n > lst[middle]: lst = lst[middle+1:] elif n < lst[middle]: lst = lst[:middle] else: print("找到了") return binary_search(lst, n) binary_search(lst, 65) 没找到