一.lambda匿名函数 (一行搞定一个函数,但是不能完成复杂的函数操作)
语法:函数名 = lambda 参数 : 返回值
注意:
1.函数的参数可以有多个,多个参数之间用逗号隔开
2.匿名函数不管多复杂,只能写一行,且逻辑结束后直接返回数据
3.返回值和正常的函数一样,可以是任意数据类型
例如:普通函数
def func(n)
return n*n
print(func(6)) ======>36
例如:lambda
a = lambda x : x*x (lambda是匿名函数,x参数后面是函数体(return的内容))
print(a) =====>36
二.sorted排序函数
语法: sorted(可迭代对象,key=函数(排序规则),reverse=(是否倒序,等于True就是倒序))
key:排序规律(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数,根据函数运算的结果进行排序
例如:
lst = [1,2,6,3,4,9,5]
lst.sort()
print(lst) =====>[1,2,3,4,5,6,9]
例如: sorted是内置函数,它会返回给你一个新列表,新列表是被排过序的
lst = [1,2,6,3,4,9,5]
ll = sorted(lst)
print(ll) ======>[1,2,3,4,5,6,9]
例如: 如果是字典,则返回排序过后的key
dic = {2:"wusir",5:"alex",1:"taibai"}
print(sorted(dic)) =====>[1,2,5]
#给列表排序,根据字符串的长度进行排序:
例如: 常用的函数
lst = ["大洋哥","尼古拉斯","赵四","刘能啊","wusir"]
def func(i):
return len(i)
ll = sorted(lst,key=func) 内部:把可迭代对象中的每一个元素传递给func 最后返回数字
print(ll) =====>["赵四","大洋哥","刘能啊","尼古拉斯","wusir"]
例如: 把函数换成lambda写法
lst = ["大洋哥","尼古拉斯","赵四","刘能啊","wusir"]
ll = sorted(lst,key = lambda i : len(i))
print(ll) ======>["赵四","大洋哥","刘能啊","尼古拉斯","wusir"]
例如:
#按照学生年龄对学生信息进行排序
lst = [
{"id":1,"name":"alex","age":18}
{"id":2,"name":"wusir","age":25}
{"id":3,"name":"太白","age":21}
]
print(sorted(lst,key = lambda dic : dic["age"]))
三.filter()筛选函数 (迭代器)
语法:filter(函数,可迭代对象)
第一个参数函数,将第二个参数中的每一个元素传递给函数,函数如果返回Ture,则留下该元素
例如:
#筛选所有的偶数
lst = [1,2,3,4,5,6,7,8]
ll = filter(lambda i : i%2 == 0 ,lst)
print(ll) =========>[2.4.6.8]
例如:
筛选出年龄大于20的
lst = [
{"id":1,"name":"alex","age":18}
{"id":2,"name":"wusir","age":25}
{"id":3,"name":"太白","age":21}
]
ll = filter(lambda dic : dic["age"]>20,lst)
print(list(ll))
四.map()映射函数 (迭代器)
语法:map(函数,可迭代对象) 可以对可迭代对象中的每一个元素进行映射,分别取,执行函数
例如:
#计算列表中的每个元素的平方,并返回新列表
lst = [1,2,3,4,5]
ll = map(lambda i : i**2,lst)
print(list(ll)) =======>[1,4,9,16,25]
例如:
#计算两个列表中相同位置的数据的和
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]
如果函数中有多个参数,后面对应的列表要一一对应 (计算出来的列表长度是按照最短的那个列表)
五.递归
在函数中自己调用自己,就是递归
语法:
def func():
print("我是谁")
func()
func()
在python中递归的深度最大到998
例如:
import sys
sys.setrecursionlimit(1000) ======>可以调整递归深度,但是不一定可以跑得到
def func(n):
print(n)
n = n +1
func(n)
func(1)
递归的应用:
可以通过使用递归来遍历各种树形结构,比如文件夹系统,可以使用递归来遍历该文件夹中的所有文件
例如:
import os
def read(filepath,n)
files = os.listdir(filepath) #获取到当前文件夹中的所有文件
for fi in files: #遍历文件夹中的文件,这里获取到的只是本层文件名
i = os.path.join(filepath,fi) #加入文件夹,获取到文件夹 或者文件
if os.path.isdir(i): #判断该路径下的是文件还是文件夹
print(" "*n,fi)
read(i,n+1) # 是文件夹,就继续进行相同的操作 继续打开文件夹 递归入口
else:
print(" "*n,fi) 如果是文件 输出 递归出口
read(filepath,0) #递归遍历目录下的所有文件
六.二分法 (二分查找)
二分查找,每次能够排除掉一半的数据,查找效率非常高,但是局限性比较大,必须是有序序列才可以使用二分查找
要求:查找的序列必须是有序序列
例如:
#判断n是否在列表中出现,如果出现请返回n所在的位置
第一种:纯算法(非递归算法)
lst = [22,33,44,55,66,77,88,99,101,238,345,456,567,678,789]
n = 567
left = 0
right = len(lst) - 1
count = 1
while left <= right:
middle = (left+right)//2
if n < lst[middle]:
right = middle -1
elif n > lst[middle]:
left = middle + 1
else:
print(count) =====>查询找了几次
print("存在")
print(middle)
break
count = 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(567,0,len(lst)-1))
第三种:另类二分法 很难计算位置
def binary_search(lst,n):
left = 0
right = len(lst) - 1
middle = (left + right) //2
if right <= 0:
print("没找到")
return
if n>lst[middle]:
lst = lst[middle+ 1 : ]
elif n < lst[middle]:
lst = lst[ : middle - 1]
else:
print("找到了")
return middle
return binary_search(left,right,n)
print(binary_search(0,len(lst)-1,567))