内置函数二
一：匿名函数 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
