python中的內置函數(2)

一.lambda匿名函數
定義:爲了解決一些簡單的需求而設計的一句話函數
例子:計算n的n次方

1 def func(n):#正常的寫法
2     return n**2
3 print(func(10))  #100
4 
5 f=lambda n:n**2
6 print(f(10))   #100

這裏的lambda小時的是匿名函數,不須要用def來聲明,一句話就能夠聲明出一個函數

語法:
函數名=lambda 參數:返回值

注意:
　　1.函數的參數能夠有多個,多個參數之間用逗號隔開,多個返回值也須要用逗號隔開,而且須要用小括號括起來
　　2.匿名函數無論多複雜,只能寫一行
　　3.返回值和正常函數同樣,能夠是任意數據類型

匿名函數並非說必定沒有名字,這裏前面的變量就能夠看作函數名,說他匿名的緣由是咱們經過__name__查看的時候統一都叫lambda
__name__的使用方法:__name__在這裏用的看起來沒有多大的做用,實際上在一個大的文件中,函數可能被屢次調用傳遞,這時只能經過__name__來查看

1 def func(n): 2     return n**2
3 print(func(10))  #100
4 print(func.__name__) 5 
6 f=lambda n:n**2
7 print(f(10)) 8 print(f.__name__)   #<lambda>

匿名函數也能夠用*args()和**args():

1 f=lambda *args:max(args) 2 print(f(1,2,3,4,55,9,2,1))  #55

二.sorted() 排序函數,內置函數提供的一個供可迭代對象排序的通用的方案
　　語法:sorted(iterable,key==none,reverse=false)
　　key:排序規則,在sorted的內部,會將可跌倒對象的每個元素傳遞給這個函數的形參,根據函數運算的結果進行排序
　　reverse:是否倒敘,默認是False,不是倒敘即正序,true是正序

1 lst2=sorted(lis)  #原列表不會改變,返回的是一個新列表
2 print(lst2)  #[1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 8, 55]

★★★★★★★★★★★★★★★★★★★★★★內置函數通常不會改變原對象,會產生並返回一個新的對象

對字典排序

1 dic={1:'啊',2:'想',3:'睡覺',4:'不能睡'} 2 dic1=sorted(dic) 3 print(dic1)  #[1, 2, 3, 4] 返回的是排序後的 key

根據字符串的長度排序

1 lis=['殺雞取卵','殺雞給猴看','殺人如麻,咦,嚇人','殺氣騰騰,闊怕'] 2 print(sorted(lis,key=lambda el:len(el)))

1 dic=[ 2     {'name':'汪峯','age':20}, 3     {'name':'章子怡','age':18}, 4     {'name':'美麗','age':13} 5 ] 6 dic1=sorted(dic,key=lambda el:el['age'],reverse=True) 7 print(dic1)  #[{'name': '汪峯', 'age': 20}, {'name': '章子怡', 'age': 18}, {'name': '美麗', 'age': 13}]

三.filter()篩選函數
　　語法:filter(function,iterable)
　　function:用來篩選的函數,在filter中自動的會吧iterable中的每個元素傳給function,而後根據function返回的true或False來判斷是否保留此項數據
　　iterable:可迭代對象

 1 lis=[1,2,3,4,5,5,66,98,55,15,20]  2 lis1=filter(lambda el:el%2==0,lis)   #符合函數的內容就是true,留下,不符合函數的內容就是False,篩掉
 3 print(lis1)   #<filter object at 0x000002B514A08860> #返回的是內存地址
 4 print(list(lis1))   #[2, 4, 66, 98, 20]
 5 
 6 lis=['周冬雨','李易峯','周杰倫','李連杰','李小龍']  7 ll=filter(lambda el :el[0]=='周',lis)  8 print(list(ll))   #['周冬雨', '周杰倫']
 9 
10 dic=[ 11     {'name':'汪峯','age':20}, 12     {'name':'章子怡','age':18}, 13     {'name':'美麗','age':13} 14 ] 15 baobao=filter(lambda el:el['age']<15,dic) 16 print(list(baobao))   #[{'name': '美麗', 'age': 13}]

四.map():映射函數
　　語法:map(function,iterable) 將列表中的每個元素都踐行function操做,返回獲得的列表的地址

 1 def func(e):  2     return e*e  3 mp=map(func,[1,2,3,4])  4 print(list(mp))   #[1, 4, 9, 16]
 5 
 6 lis=[1,2,3,4,5,6]  7 mp=map(lambda el :el**2,lis)  8 print(list(mp))   #[1, 4, 9, 16, 25, 36]
 9 
10 計算兩個列表中相同位置的數據的和 11 lis=[1,2,3,4,5,6] 12 # lis2=[6,5,4,3,2,1]
13 # mp=map(lambda el1, el2 :el1+el2 ,lis,lis2)
14 # print(list(mp)) #[7, 7, 7, 7, 7, 7]
15 
16 map()也存在水桶效應 17 lis=[1,2,3] 18 lis2=[6,5,4,3,2,1] 19 mp=map(lambda el1, el2 :el1+el2 ,lis,lis2) 20 print(list(mp))  #[7, 7, 7]

分而治之:一我的處理一個量特別大的數據太慢,並且耗內存,因此假設這我的找了五我的來完成,
可是五我的的工做量依舊很大,因此這五我的每一個人又找了十我的......一次下去直達工做量合適
lis=[1,2,4,5,5,8,6,6,5,5,5,6,6,5,55,5,9,5,5,44,4,8,56,98,5654,654565,65,65,56,5,6,5,456,48,9,89,8,98,56]
mp  =  map  ( func1  , map ( func2  , map  ( func3  , lis ) ) )
func3的目的是將這個這個大工做量的list切片成五份
func2的目的是將這五份中的每一份又切片成十份
func3的目的是將一共的50份每份都作映射處理,獲得想要的結果
print(list(mp))

五.遞歸:在函數中調用函數自己就是遞歸

 1 i=1
 2 def func(i):  3     print(i)  4     print('我是專業的!')  5     i+=1
 6  func(i)  7 func(i)  8 我是專業的!  9 995
10 我是專業的! 11 996
12 我是專業的! 13 997
14 我是專業的! 15 998    #在python中遞歸的最大深度到998,官方的最大深度是1000,可是在這以前會報錯

遞歸的做用:能夠使用遞歸來便利各類樹形結構,好比文件夾系統,能夠使用遞歸便利一個文件夾中的全部文件

 1 import os  #引入os模塊
 2 def func(filepath,n):   #failpath是要打開的文件的路徑 n用來控制文件或文件夾前有幾個tab鍵,以造成層次
 3     files=os.listdir(filepath)    #os模塊中的方法,獲取當前文件夾中的全部文件名
 4     for fi in files:     #將全部的文件名遍歷
 5         fi_d=os.path.join(filepath,fi)    #引用os模塊中的方法,將e:/python和文件名連在一塊兒,組成一個新的路徑
 6         if os.path.isdir(fi_d):       #判斷該路徑下的文件是否是文件夾
 7             print('\t'*n+fi+':')  #前面加指定個數的tab鍵,文件名,冒號
 8             func(fi_d,n+1)     #繼續調用func函數
 9         else: 10             print('\t'*n+fi)   #直接打印文件名
11 func('e:/python',0)

六.二分法查找:
　　二分法查找,每次可以 排除掉一半的數據,查找的效率很是高,可是有必定的侷限性,必須是有序序列才能夠使用二分法查找
判斷n是否在lst中,若是存在返回n所在位置的索引
普通版本二分法

 1 lst=[11,22,33,44,55,66,77,88,99,123,145,156,178,189,215,246,287,298,568,687,789,890,960]  2 n=246
 3 left=0  4 right=len(lst)-1
 5 middle=(left+right)//2
 6 while left<=right:  7     if n<lst[middle]:  8         right=middle-1
 9         middle = (left + right) // 2
10     elif n>lst[middle]: 11         left=middle+1
12         middle = (left + right) // 2
13     elif n==lst[middle]: 14         print('找到了',middle) 15         break
16 else: 17     print('沒找到')

遞歸版本二分法

 1 lst=[11,22,33,44,55,66,77,88,99,123,145,156,178,189,215,246,287,298,568,687,789,890,960]  2 def func(n,left,right):  3     if left <=right:  4         middle=(left+right)//2
 5         if n<lst[middle]:  6             right=middle-1
 7             return func(n, left, right)  8         elif n>lst[middle]:  9             left=middle+1
10             return func(n, left, right) 11         elif n==lst[middle]: 12             print('找到了') 13             return middle  #這個位置返回的值返回的是給調用他的函數,而不是直接返回給第一個func
14     else: 15         print('沒找到') 16         return -1
17 ret=func(78,0,len(lst)-1) 18 print(ret)