内置函数二
一：匿名函数 lambda函数
lambda 表示匿名函数，不需要用def 来申明。 语法： 函数名=lambda 参数:返回值 ----〉 案例：f=lambda n:n*n
例子01：
计算n*n 的值： f=lambda n:n*n print(f(10)) 打印：100
例子02：
计算n的n次方 def func(n): return n*n print(func(2)) #打印：4
匿名函数的注意事项：
1：函数参数能-是多行，多个参数用逗号隔开 2：匿名函数不管多复杂，只能写一行，且逻辑结束后直接返回数据 3：返回值和正常的函数一样，可以是任意数据类型
二：sorted 函数：
排序函数：
001：sorted
sorted(Iterable,key=None,reverse=False)
Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每⼀个元素传递给这个函
数的参数. 根据函数运算的结果进⾏排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
根据大小排序
lst=[1,5,3,4,6] lst2=sorted(lst) print(lst) #[1, 5, 3, 4, 6] print(lst2) #[1, 3, 4, 5, 6] 进过sorted函数后，返回了从小到大排序好的数
例子：
根据字符串长度进行排序,和函数组合使用 #revserse Ture 则降序，反则升序 lst=["马虎疼","qwer","哎呦喂啊啊","旺财"] def func(s): return len(s) print(sorted(lst,key=func)) #['旺财', '马虎疼', 'qwer', '哎呦喂啊啊']
#计算字符串长度
def func(s): return len(s) print(sorted(lst,key=lambda s:len(s))) #['旺财', '马虎疼', 'qwer', '哎呦喂啊啊'] lst1=[{"id":1,"name":"xuxiansheg","age":18}, {"id":2,"name":"haha","age":12}, {"id":3,"name":"enen","age":15}
按照年龄排序：
print(sorted(lst1,key=lambda n:n["age"])) 打印：[{'id': 2, 'name': 'haha', 'age': 12}, {'id': 3, 'name': 'enen', 'age': 15}, {'id': 1, 'name': 'xuxiansheg', 'age': 18}]
三： filter() 筛选函数：
语法：filter() #filter只保留，返回为真的数据，过滤list的作用
filter() ：用来筛选函数，在filter 中会自动把iterable中的元素
传递给function 然后根据function返回的True 或则False 来判断是否保留此项数据
例子01： lst=[1,2,3,4,5,6,7] ll=filter(lambda x:x%2==0,lst) #筛选所有的偶数 print(ll) #<filter object at 0x00000063DE87DB38> print(list(ll)) #[2, 4, 6] 例子02： lst1=[{"id":1,"name":"xuxiansheg","age":18}, {"id":2,"name":"haha","age":12}, {"id":3,"name":"enen","age":15} ] fl=filter(lambda e:e["age"]>12,lst1) #筛选 print(list(fl)) a=list(fl) print(a) # 打印：[{'id': 1, 'name': 'xuxiansheg', 'age': 18}, # {'id': 3, 'name': 'enen', 'age': 15}]
四： map()映射函数 #map是帮你循环调用函数，这个函数返回就保存什么。
map语法：map(function,iterable) 可以对迭代对象中的每一个元素
映射分别取执行function
例子01： # map 对每个元素进行映射（#############） def func(e): return e*e mp=map(func,[1,2,3,4,5]) #对每个元素平方，返回新的列表 print(mp) #打印：<map object at 0x000000DFDD76D2B0> print(list(mp)) #[1, 4, 9, 16, 25] 例子02： 改写成lambda: lambda 必须一行写出来，直接返回值 print(list(map(lambda x:x*x,[1,2,3,4,5]))) #打印：[1, 4, 9, 16, 25] 例子03： #计算两个列表中相同位置的数据和 lst1=[1,2,3,4,5] lst2=[2,4,6,8,10] print(list(map(lambda x,y:x+y,lst1,lst2))) #[3, 6, 9, 12, 15] 例子04： #map案例： lst=["1_123", "alex_456", "wusir_123", "wusir_456", "alex_789"] m=map(lambda s:s=="1_456",lst) print(list(m)) def fun(s): if s=="1_456": return "登陆成功"
五：在函数中调用函数本身，就是递归：################
def func(): print("我是谁！") func() func() #循环打印： 我是谁 #python中递归的深度最⼤到1000 但是永远到不了一千 def foo(n): print(n) n+=1 foo(n) foo(1)
六：递归的应用（############重点）
说明：# # 我们可以使⽤递归来遍历各种树形结构, 比如我们的⽂件夹系统. 可以使⽤递归来遍历该 # # ⽂件夹中的所有⽂件
例子：01
import os
def func(path):
lst=os.listdir(path) #打开一个文件夹
print(lst)
for el in lst: #当前文件夹内的所有文件名。包括文件夹的名字
#拼接文件的真实路径
# file_real_path=os.path.join(path,el) #文件路径的固定写法 os.path.join(path,el)
q = os.path.join(path, el) # 文件路径的固定写法
#判断这个路径是文件夹还是文件
if os.path.isdir(q):
#递归的入口
print(el)
func(q) #重新执行刚才的操作，如果是文件则继续打开
else:#不是文件夹，是文件则返回文件名
print(el)
func("F:/1")
#####################习题！
#计算1-3+5-7+9......99的结果 sum=0 fu=1 for i in range(1,100,2): sum+=i*fu fu=-fu print(sum)
七：二分法（掐头去尾取中间）###最主要的是：二分法需要的是已经排序好的列表才行！
二分法：第一种
lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963] left=0 right=len(lst)-1 num=int(input("请输入您需要判读的数字：")) while 1: if left<=right: #左右索引可以相等 mid=(left+right)//2 ##每次的都是以中间值为分界的 if lst[mid]>num: ###说明我们要找的数字在中间值得左边 right=mid-1 elif lst[mid]<num: ### 说明我们呢要找的值在中间值得右边 left=left+1 else: print("找到了！") break else: print("没找到！")
二分法：第二种
0 1 2 3 4 5 6 7 8 lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963] def binary_search(lst, n, left, right): if left > right: return False mid = (left + right) // 2 if n > lst[mid]: left = mid + 1 #重点# 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值############################## return binary_search(lst, n, left, right) elif n < lst[mid]: right = mid - 1 return binary_search(lst, n, left, right) else: print("找到了") return True n = int(input("请输入一个数字n:")) # 178 ret = binary_search(lst, n, 0, len(lst)-1) print(ret)
二分法：第三种
#切换列表,这种方法主要思想：以中间的数字为界限，如果要找的数字比中间数字大，则左边的数据切割掉不需要了，再以 #中间数字为起始位置开始切割，不断持续相同切割方法，最后找到我们要找的数据，反之亦然！主要改变的是列表的长度 def binary_search(lst, n): if len(lst) == 0: return False left = 0 right = len(lst) - 1 mid = (left + right) // 2 if n > lst[mid]: left = mid + 1 # 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值 return binary_search(lst[mid+1:], n) elif n < lst[mid]: right = mid - 1 return binary_search(lst[:mid], n) else: print("找到了") return True n = int(input("请输入一个数字n:")) # 178 ret = binary_search(lst, n) print(ret)
八：递归深度：
# 递归深度 # def func(): # print("哈哈") # func() # func() # python中最大的递归深度是3000 但是你永远到不了3000 实际测试说明：最大深度是1000，但是到不了1000 import sys # system python, os 操作系统 print(sys.getrecursionlimit()) sys.setrecursionlimit(3000) # 最大是3000 你到不了3000