内置函数二
内置函数二
lambda匿名函数
# 计算n的n次方
def func(n):
return n**n
print(func(10))
f = lambda n : n**2
print(f(10))
lambda表示的是匿名函数，不需要用def来声明，一句话就可以声明处一个函数。
语法 ：
函数名 = lambda 参数：返回值
注：
1.函数的参数可以有多个，多个参数之间用逗号隔开。
2.匿名函数不管多复杂只能用一行，切罗季结束后直接返回数据。
3.返回值和正常的函数一样，可以是任意数据类型。
sorted 排序函数
语法：sorted（lterable,key=None,reverse=False）
lterable:可迭代对象
key：排序规则（排序函数），在sorted内部将可迭代对象的每一个元素传递给这个函数的参数，根据函数运行的结果进行排序。
lst = [1,5,3,7,9,]
lst2 = sorted(lst)
print(lst) # 元列表不会改变
print(lst2) # 返回的新列表是经过排序的
dic = {1:'A',3:'C',2:'B'}
print(sorted(dic)) # 如果是字典，则返回排序过后的key
和函数组合使用
# 根据字符串长度进行排序
lst = ["宫崎骏", "和田光司", "中央情报局", "狐仙"]
def func(s)：
return len(s)
print(sorted(lst,key=func))
和lambda组合使用
# 根据字符串长度进行排序
lst = ["宫崎骏", "和田光司", "中央情报局", "狐仙"]
# 计算字符串长度
def func(s):
return len(s)
print(sorted(lst,key=lambda s: len(s)))
# 按照年龄对学⽣信息进⾏排序
lst = [{"id":1, "name":'alex', "age":18},
{"id":2, "name":'wusir', "age":16},
{"id":3, "name":'taibai', "age":17}]
print(sorted(lst, key=lambda e: e['age']))
filter 筛选函数
语法：filter(function,lterable)
fumction:用来筛选的函数，在filter中会自动的把iterable中的元素传递给function，
然后根据function返回的True或者False来判断是否保留此项数据
lterable:可迭代对象
# 筛选所有偶数
lst = [1,2,3,4,5,6]
l1 = filter(lambda x : x%2==0,lst)
print(l1)
print(list(l1))
# 筛选年龄大于16的数据
lst = [{"id":1, "name":'alex', "age":18},
{"id":2, "name":'wusir', "age":16},
{"id":3, "name":'taibai', "age":17}]
f = filter(lambda e:e['age']>16,lst)
print(list(f))
map() 映射函数
语法：map(function,lterable) 可以对可迭代对象中的每一个元素进行映射，分别去执行function
# 计算列表中每个元素的平方，返回新的列表
def func(e):
return e**e
f = map(func,[1,2,3,4,5])
print(list(f))
改写成lambda
print(list(map(lambd e : e**e,[1,2,3,4,5])))
#计算两个列表中相同位置数据的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x,y:x+y,lst1,lst2)))
递归 ：在函数中调用函数本身，就是递归
def func():
print('我是谁')
func()
func()
在python中递归最大的深度到1000，函数中本身调用次数+运行次数
def func(n):
print(n)
n+=1
func()
func(1)
递归的应用：我们可以使用递归遍历各种树形结构，比如我们的文件夹系统，可以使用递归来遍历文件中的所有文件。
import os
def read(filepath,ceng):
files = os.listdir(filepath) # 获取到文件中的所有文件夹
for fi in files: # 遍历文件夹中文件，这里获取的是本层文件名
fi_d = os.path.join(filepath,fi) # 加入文件夹，获取到文件夹+文件
if os.path.isdir(fi_d): # 如果该路径下的文件是文件夹
print('\t'*ceng,fi)
read(fi_d,ceng+1) # 继续进行相同的操作
else:
print('\t'*ceng,fi) # 递归出口，最后在这里隐含着return
read('e:/123',0) # 递归遍历目录下的所有的文件
二分查找
二分查找，每次能够排除掉一半的数据，查询的效率非常高，但是局限性比较大，必须是有序序列才能使用二分查找。
# 判断n是否在lst中出现，算了几次，返回n所在位置
# 二分查找---非递归算法
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
n = 0
left = 0
right = len(lst)-1
count = 1
while left <= right:
middle = (left + right) // 2
if n < lst[middle]:
right = middle - 1
elif n > [middle]:
left = middle + 1
else:
print(count)
print(mibble)
break
count += 1
else；
print('不在这里')
# 普通递归版本二分法
def binary_search(n,left,right):
if left <= right:
middle = (left + right) //2
if n < lst[middle]:
right = middle -1
elif n > lst[middle]:
left = middle + 1
else:
return middle
return binary_search(n,left,right) # 这个return必须有，否则接受到的永远是None
else:
return -1
print(binary_search(n,0,len(lst)-1))
# 另类二分法，很难计算位置
def binary_search(ls,target):
left = 0
right = len(ls)-1
if left > right:
print('这里没有')
middle = (left + right) //2
if target < ls[middle]:
return binary_search(ls[:middle],target)
elif target > ls[middle]:
return binary_search(ls[niddle:],taret)
else:
print('在这里')
binary_search(lst,（所传值）)