lambda 匿名函数
: 表达式 变量= lambda 参数 : 函数体(直接return 的内容)
其中 当函数中有多个参数时, 参数中间用 , 逗号隔开
所有的匿名函数 的名字都叫 lambda
可以一行搞定一个函数 ,但是 不能完成复杂的函数操作
e.g
def func(n): 变量 = lambda : 函数体
return n+n ====> 整个函数用匿名函数来写 ===> a= lambda x : x+x
print(func(3)) ====> 6 print(a(3))====> 6
sortde()排序函数
语法: sorted( 可迭代对象 , key = 函数的排序规则 , reverse=True(倒序)(若不倒序就不写) )
排序规则 : 最后返回值必须是数字, 这样才有依据排序
e.g lst= [ '谢大脚' , ' 刘能 ' , ' 尼古拉斯 ' ]
l1=sorted( lst , key=lambda x : len (x) , reverse = True ) # 按照元素长短来排序 , 倒序
print(l1)======> [ ' 尼古拉斯' , ' 谢大脚' , '刘能' ]
filter() 筛选函数 ====> 结果出来是个迭代器 因此最后需要 用 list 括起来
语法 : li= filter ( 函数 , 可迭代对象 )
e.g def f ( i ):
return i % 2==1
lst = [1,2,4,5,3,6] ===> l1= filter ( lambda i : i%2==1, lst)
l1= filter(f, lst)
print( list( l1 ) )====> [ 1, 5,3] print( list( l1 ) )====> [ 1, 5,3
map() ===> 出来也是一个1迭代器 也要用 list 括起来
语法 : map ( 函数 , 可迭代对象 )
e.g
lst1=[ 1,2,3,4,5]
lst2=[5,4,3,2]
print(list(map(lambda x , y : x+y , lst1 lst2)))===> [ 6,6,6,6] 把可迭代对象中 相对应的每个元素的和 按照短的取值
递归
自己调用自己 , 最大的深度是 997 , 998 就爆了
难点 : 不好想 , 要找规律 , 不好读
e.g
import sys
sys.setrecursionlimit(10000) # d可调用的递归深度 , 但是 不一定可以跑到
import os
file Path = " d:sylar ..."
def read (file Path, n)
it = os .listdir (file Path) # 查看文件夹中的文件
print('_ _iter_ _' in dir( it )) ===> 可以看出是可迭代对象
for el in it : # el 只是文件名, 但是其中还有文件
if os.Path.isdir( os . Path .join ( filePath , el ) ) : # 判断是不是文件夹 ,若是就再一次调用函数,若不是就打印
print( ' *n ', el) # 格式
read ( os .path . join ( file path , el ) , n+1 ) 调用一次n+1 ,向里边缩进一层 # 递归入口
else:
print( " * n " , el ) #不是文件夹直接打印
read ( faithpath , 0 )
其中
os . Path .join ( filePath , el ) 是将filepath 路径和el 文件夹名的路径放在一起, 就成了 el 文件夹的路径了 ,再按照 el
文件夹路径打开文件夹, 若不放到一块 , el 就只是一个文件夹的名字, 不是文件夹打不开
二分法
二分法查找 : 要求 查找的序列必须是有序序列
每次排除一半, 效率高,, 但是局限性大
掐头结尾取中间, 不停的改变左和右, 间接改变中间, 效率高
e.g 查找66所在位置
lst=[ 11, 22, 33,44,55,66,77,88,99]
方法一: 不用递归 纯算法
lst=[ 11, 22, 33,44,55,66,77,88,99]
left=0 # 最左边的值的索引值
right= len(lst) - 1 # 最右边的值得索引值
count = 1
while left <=right:
middle = ( left + right )//2 # 中间值索引为两边和除以2 取整
if n > lst [ middle ] : # 若66 比中间值大. 它应该在中间的右边 ,
left = middle +1 # 这时最左边值的索引应该是 中间向右移动 middle+1
elif n < lst [ middle ] : # 若66 比中间值小. 它应该在中间的左边 ,
right = middle -1 ## 这时最右边值的索引应该是 中间向左移动 +1
else : # 若 66 等于中间值 , 那66 所在位置就是索引为 middle 的位置
print ( count )
print ("存在")
print ( middle )
count = count+1 # 获得循环次数
else:
print ('不存在')
方法二: 递归
lst=[ 11, 22, 33,44,55,66,77,88,99]
def binary_search ( left , right , n)
middle = ( left + right ) //2
if left > right : # 递归出口
print ("没找到")
return -1
if n > lst[ middle ] : #
left = middle +1
elif n < lst [ middle ]:
right = middle -1
else:
return middle # return 只接收第一次调用函数的结果 ,如果再调用一次函数他就不管用了
return binary_search ( left , right , n) # 这个return 接收的是第二次或者以后调用函数执行的结果, 返回的是后来调
用的结果, 若不写就没有后来函数执行的结果, 会返回None
print ( binary_search( 0, len(lst) , 66)
方法三: 递归
lst=[ 11, 22, 33,44,55,66,77,88,99]
def binary_search( lst , n)
left = 0
right= len( lst ) -1
middle = ( left + right ) //2
if right <=0: # 递归出口
print("没找到")
if n > lst [ middle ]:
lst = lst [ middle +1 : ] # 若值比中间只大 , 列表直接就变为中间右半边的列表了
elif n < lst [ middle ]:
lst= lst [ : middle-1 ] # 若值比中间值小 , 列表就变为 中间 左半边的列表了
else :
print ("找到了")
return 1
binary_search( lst , n) # 递归入口