python lambda+sorted+filter+map+递归+二分法
1, lambda 匿名函数
lambda 参数: 返回值
函数名统一都叫lambda.
2, sorted() 排序函数
排序函数
sorted(iterable, key, reverse)
key: 排序规则.
运行流程: 把可迭代对象中的每一个元素交给后面key函数来执行.
得到一个数字(权重). 通过这个数字进行排序
3. filter() 过滤函数
filter(function, iterable)
把可迭代对象中的每一个元素交给前面的函数进行筛选. 函数返回True或者False
4. map() 映射函数
map(function, iterable)
把可迭代对象中的数据交给前面的函数进行执行. 返回值就是map的处理结果
5. 递归
函数自己调用自己
最大深度: 1000 . 到不了1000就停了
import sys
sys.setrexxxxx
6. 二分法
核心: 掐头去尾取中间. 一次砍一半
两种算法: 常规循环, 递归循环
dic = {'5':1,'6':1} o(1)
# 时间复杂度最低, 空间复杂度最低
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)
lambda 匿名函数
语法: lambda 参数: 返回值
# 普通的正常函数 功能简单 函数多了 名字不好起
def func(n):
return n*n
print(func(9)) #81
# 匿名函数, 语法: lambda 参数: 返回值
a = lambda n: n*n
print(a(9)) #81
#查看函数名 .__name__
print(func.__name__) #func
print(a.__name__) #<lambda> 匿名函数的名字都适合lambda
# 也可以认为函数的名字是a
传入多个参数 返回多个返回值
# 传递2个参数
f = lambda a,b: a+b
print(f(3,4)) # 7
# 返回多个返回值
def func(x,y): # 正常函数
return x,y
print(func(3,4)) #(3, 4)
# lambda 多个返回值
f1 = lambda x,y: x,y # 并非一个lambda函数
#等价于
f2 = (lambda x,y: x),(y) #并非返回做个值, 最终是个元组
f3 = lambda x,y: (x,y) #这个才是返回多个返回值
# 小补充:
c = 1,2,3 # 是个元组
print(c)
# (1, 2, 3)
# 练习: 给函数传递2个参数,返回最大的值.
f = lambda a,b: max(a,b)
print(f(89,56))
s = lambda a,b: a if a>b else b
print(f(89,56))
f4 = lambda *args: max(args)
print(f4(3,4,5,6,4,2,3,)) #6
sorted() 排序函数
将可迭代对象进行排序
sorted (iterable, key, reverse) 其中: key=function 仅有函数名没有小括号
运行流程 : 把可迭代对象中的每一个元素交给后面的key函数来执行.
得到一个数字(权重),通过权重进行排序.
# 常规的列表排序: sort() 是列表自带的函数
lst = [16,78,23,22,34,56,73,4]
lst.sort() # 对lst进行排序处理
print(lst) #是列表专用的方法 排序
print(lst.sort()) #是不对的 不能直接打印返回的是None
# 内置函数的排序提供了一个通用的排序方案, sorted( )
1) 对纯数字进行排序
lst = [16,78,23,22,34,56,73,4]
s = sorted(lst)
print(s)
# [4, 16, 22, 23, 34, 56, 73, 78]
2) 根据字符串的长度进行排序
# 根据字符串的长度排序
lst = ['uhdi','还','世界','西游记'] def func(c): return len(c) a = sorted(lst,key=func) #将lst中的每一个元素依次带入func中计算字符串的长度 print(a) b = sorted(lst,key=func,reverse=True) # 倒序, reverse=True print(b) # ['还', '世界', '西游记', 'uhdi'] # ['uhdi', '西游记', '世界', '还']
3) 根据 名字长度排序 或 年龄倒序排序
lst = [{'name':'汪峰','age':48},
{'name':'章子怡','age':38},
{'name':'范冰冰','age':42},
{'name':'李晨','age':40}
]
# 根据名字长度排序:
a = sorted(lst,key=lambda el:len(el['name']))
print(a)
# 根据年龄倒序排序:
b = sorted(lst,key=lambda el: el['age'],reverse=True)
print(b)
filter() 过滤函数 用于筛选
将可迭代对象进行过滤
f = filter (function, iterable) 其中: function 只有函数名,没有小括号,
把可迭代对象中的每一个元素交给前面的函数进行筛选, 函数返回 True或False
注意 : f = filter(函数名,可迭代对象) #获得的是迭代器,不能直接打印, print(f)错误的
# 过滤掉姓张的
lst = ['张无忌','张铁林','汪峰','章子怡','马大帅']
# 1. 常规声明函数
def func(el):
if el[0] == '张':
return False #不想要的
else:
return True #想要的
f = filter(func,lst) #只带入函数名, lst中每一个元素依次带入func
print(f) #直接打印为地址 #<filter object at 0x0000026CA1BE92B0>
print('__iter__'in dir(f)) # True 迭代器, 用for循环打印
for i in f:
print(i)
# 2. 等价于 用lambda函数
f = filter(lambda el:el[0]!='张',lst) #得到的是可迭代对象
for i in f:
print(i)
# 汪峰
# 章子怡
# 马大帅
# 3. 也可以如下输出: 转化为列表
f = filter(lambda el:el[0]!='张',lst)
print(list(f))
# ['汪峰', '章子怡', '马大帅']
map() 映射函数
将可迭代对象进行处理
m = map(function, iterable) 其中: function 只有函数名没有小括号
把可迭代对象中的数据交给前面的函数执行. 返回的值就是map的处理结果.
注意: m = map(函数名,可迭代对象) #获得的是迭代器,不能直接打印,print(m)错误的
#可以转化为list再打印,print(list(m))
1) 计算列表中每个数字的平方.
lst = [1,4,7,2,5,8]
# def func(el):
# return el**2
# m = map(func,lst)
m = map(lambda el: el**2, lst) # 把后面的可迭代对象中的每一个元素传递给function,
# 结果就是function的返回值
print(list(m))
2) 将两个列表中的元素进行对应相加处理, (水桶效应) 类似 zip() 函数
# 水桶效应, 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))
3) 分而治之 一个数据要多种方法处理多次
m = map (func1, map (func2, map (func3, lst) ) ) 其中: m获取的是迭代器
递归
(贪吃蛇)
函数自己调用自己, 用于具有相同操作的功能
典型的一层层打开文件
1) 默认的递归是个死循环, 递归的深度就是自己调用自己的次数
官方给的最大深度是1000,但达不到1000,在这之前就会报错
count=1
def func():
global count
print('alex是很帅的',count)
count += 1
func() # 函数中调用自己
func()
2) 遍历 E:\A学习\python--study\workplace 文件夹.
打印所有的文件和普通文件的文件名
# 文件操作需要引入os import os def func(filepath,n): # n 用来记录tab键 # 打开文件夹,查看当前目录中的文件 files = os.listdir(filepath) for file in files: # 获取到文件file的路径(组合路径),获取文件 file_p = os.path.join(filepath,file) # 判断文件是否为文件夹 if os.path.isdir(file_p): print('\t'*n,file,':') func(file_p,n+1) else: print('\t'*n,file) #打印文件 func('E:\A学习\python--study\workplace',0)
二分法查找
使用二分法,必须是有序的可迭代对象
1) 查找一个数是否在某个数列中, 常规二分法
#查找一个数,是否在某个列表中 lst = [22,33,45,76,54,34,56,34,67,98,90,23] lst.sort() # 首先对列表进行排列, n = 98 left = 0 right = len(lst)-1 while left <= right: #注意边界问题 mid = (left + right)//2 if lst[mid] > n: right = mid - 1 elif lst[mid] < n: left = mid + 1 else: print('找到了这个数') break else: print('没有找到这个数')
2) 使用递归的思想来完成二分查找
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 lst[mid] < n: left = mid +1 return func(n,left,right) # 加了return,才会每次调用都会有返回值 elif lst[mid] > n: right = mid -1 return func(n,left,right) else: print('找到这个数了') return mid # 返回这个数的索引 else: print('没有找到这个数.') return -1 ret = func(66,0,len(lst)-1) print(ret) # ret就是索引 # 找到这个数了 # 4
浙公网安备 33010602011771号