标签：自身 大于 简单的 read color obj 递归 isp 判断
1）当需要用到很简单的函数时，可以使用lambda；一行可定义一个函数，但是不能完成复杂的函数操作
2）语法：
lambda x,y: x+y
lambda后的变量为参数，冒号后面时函数体（直接return的内容）
#普通函数
def func(n): return n*n print(func(3))
#匿名函数
a = lambda n: n*n print(a) #直接打印为内存地址 print(a(3))
3)lambda生成的匿名函数，函数名都为lamdba;可以通过函数__name__查看
def func(n): return n*n print(func(3)) a = lambda n: n*n print(a) #直接打印为内存地址 print(a(3)) x = func print(x.__name__) print(a.__name__) 输出： 9 <function <lambda> at 0x000001C0FFC1B0D0> 9 func <lambda>
3）lambda(匿名函数)注意事项
①函数的参数可以有多个，多个参数之间只能用逗号隔开
②匿名函数不管有多复杂，只能写一行，且逻辑结束后直接返回数据
③返回值和正常的函数一样，可以是任意的数据类型；若要返回一个列表，可使用推导式
注：匿名函数并不是一定没有名字，前面的变量就是一个函数名；只是通过__name__查看的时候是没有名字的，同意都叫lambda,在调用的时候没有特殊之处，像正常的函数调用即可
1）语法
sorted(lterable，key=None,reverse=False)
参数说明：
lterable:可迭代对象
key:排序规则（排序函数）,在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数，根据函数运算的结果进行排序
#sort()是列表自身的一个方法，是对自身的一个修改和处理 lst = [2,7,3,8,13,9] lst.sort() print(lst) #sotred()是一个内置函数，返回的是一个新列表，新列表是被排序的 lst = [2,7,3,8,13,9] lst_new = sorted(lst) print(lst_new) 输出： [2, 3, 7, 8, 9, 13] [13, 9, 8, 7, 3, 2]
#倒叙排列
lst = [2,7,3,8,13,9] lst_new = sorted(lst,reverse=True) print(lst_new) 输出： [13, 9, 8, 7, 3, 2]
#参数key的使用：根据字符串的长度对列表进行排序
lst = ["英雄联盟","飞车","DNF","剑灵","地下城勇士"] def func(s): return len(s) lst_new = sorted(lst,key = func) #是把可迭代对象中的每一个元素传递给func print(lst_new) 输出： [‘飞车‘, ‘剑灵‘, ‘DNF‘, ‘英雄联盟‘, ‘地下城勇士‘]
#lambda配合sorted()一起使用
lst = ["英雄联盟","飞车","DNF","剑灵","地下城勇士"] lst_new = sorted(lst,key = lambda s: len(s)) print(lst_new) 输出： [‘飞车‘, ‘剑灵‘, ‘DNF‘, ‘英雄联盟‘, ‘地下城勇士‘]
#将列表中的人，按照年龄进行排序
lst = [ {"id":1,"name":"九尾妖狐","age":26}, {"id":2,"name":"惩戒之箭","age":28}, {"id":3,"name":"远古巫灵","age":18} ] lst_new = sorted(lst,key = lambda dic :dic["age"]) print(lst_new) 输出： [{‘id‘: 3, ‘age‘: 18, ‘name‘: ‘远古巫灵‘}, {‘id‘: 1, ‘age‘: 26, ‘name‘: ‘九尾妖狐‘}, {‘id‘: 2, ‘age‘: 28, ‘name‘: ‘惩戒之箭‘}]
1）语法
filter(function,lterable)
参数说明：
function:用来筛选的函数，会自动的把iterable中的元素传递给function，然后根据function返回的True或False来判断是否保留次项数据，如果是True则保留下该元素
lterable:可迭代对象
注：filter的返回结果是一个迭代器
#判断哪些是技术
def func(i): return i % 2 == 1 lst= [1,2,3,4,5,6,7,8] ll = filter(func,lst) print(ll) print(list(ll)) 输出： <filter object at 0x000001865882CAC8> [1, 3, 5, 7]
#通过lambda修改以上程序
lst= [1,2,3,4,5,6,7,8] ll = filter(lambda i:i%2==1,lst) print(ll) print(list(ll)) 输出： <filter object at 0x0000022E8728CAC8> [1, 3, 5, 7]
#筛选出列表中年龄大于20的元素
lst = [ {"id":1,"name":"九尾妖狐","age":26}, {"id":2,"name":"惩戒之箭","age":28}, {"id":3,"name":"远古巫灵","age":18} ] lst_new = filter(lambda dic:dic["age"]>20,lst) print(list(lst_new)) 输出： [{‘age‘: 26, ‘name‘: ‘九尾妖狐‘, ‘id‘: 1}, {‘age‘: 28, ‘name‘: ‘惩戒之箭‘, ‘id‘: 2}]
1）语法：
map(function,iterable)
可以对可迭代对象中的每一个元素进行映射，分别取执行的function（即把可迭代对性的每一项取出来，执行前面的函数）；返回的也是一个迭代器
#计算列表中每个元素的平方，返回新列表
lst = [1,2,3,4,5,6,7,8,9] def func(i): return i * i a = map(func,lst) #相当于把一个大的集合，分开处理，处理完成后再收回 print(list(a)) 输出： [1, 4, 9, 16, 25, 36, 49, 64, 81]
#map()配合lambda表达式
lst = [1,2,3,4,5,6,7,8,9] a = map(lambda x : x * x ,lst) print(list(a)) 输出： [1, 4, 9, 16, 25, 36, 49, 64, 81]
#使用lambda时，如果函数中有多个参数，后面对应的别表要一一对应
#将两个列表相加 lst1 = [1,22,53,23,10] lst2 = [2,10,20,31,11] print(list(map(lambda x,y:x+y,lst1,lst2))) 输出： [3, 32, 73, 54, 21]
因为每次调用函数都会开辟新的内存空间，所以递归函数如果没有次数限制，内存一定会爆，所以在python中有一个最大的内存深度为997
1）可通过sys模块中setrecusionlimit()调整最大递归深度，但是不一定只执行得到
import sys sys.setrecursionlimit(1000) def func(count): print(str(count)) func(count + 1) func(1)
2）递归最大得用处就是遍历树型解构
#通过递归查找文件和文件夹
import os filePath = "d:\代码\python" def read(filePath, n): it = os.listdir(filePath) # 打开文件夹 for el in it: # 拿到路径 fp = os.path.join(filePath, el) # 获取到绝对路径 if os.path.isdir(fp): # 判断是否是文件夹 print("\t"*n,el) read(fp, n+1) # 又是文件夹. 继续读取内部的内容 递归入口 else: print("\t"*n,el) # 递归出口 read(filePath, 0)
每次能够排除掉一半得数据，查找得效率非常高，但是局限性比较大，必须是有序序列才可以使用二分查找
1）二分法查找一个数（不使用递归）
lst = [4,7,10,23,66,136,254,666,728,999] n = 136 left = 0 right = len(lst)-1 while left<=right: middle = (left + right) // 2 if n<lst[middle]: right = middle - 1 elif n>lst[middle]: left = middle + 1 else: print("数字存在，位置为："+str(middle)) break else: print("数字不存在") 输出： 数字存在，位置为：5
2）通过递归得方式实现（以取列表左右两边值的方式实现）
lst = [4,7,10,23,66,136,254,666,728,999] def func(left,right,n): middle = (left+right)//2 if n>lst[middle]: left = middle + 1 elif n < lst[middle]: right = middle - 1 else: return middle return func(left,right,n) #如果不返回，第二次调用函数得到得结果接收不到 print(func(0,len(lst)-1,66)) 输出： 4
3）通过递归得方式实现（以切列表得方式实现），只能判断数字是否存在于列表中，无法确定在哪
lst = [4,7,10,23,66,136,254,666,728,999] def func(lst,n): left = 0 right = len(lst) - 1 middle = (right+left)//2 if left>right: print("找不到") return -1 if n > lst[middle]: lst = lst[middle+1:] elif n < lst[middle]: lst = lst[:middle-1] else: print("找到了") return return func(lst,n) func(lst,66) 输出： 找到了
python学习第13天----lambda、sorted、map、filter、递归、二分查找
标签：自身 大于 简单的 read color obj 递归 isp 判断
原文地址：https://www.cnblogs.com/piaolaipiaoqu/p/13853699.html
