python內置函數(二)

一.lambda匿名函數

　　爲了解決一些簡單的需求而設計的一句話函數

1 # 計算n的n次⽅
2 def func(n):
3   return n**n
4 print(func(10))
5 f = lambda n: n**n
6 print(f(10))

　　lambda表示的是匿名函數.不須要用def來聲明,一句話就能夠聲明出一個函數.

語法:

　　函數名=lambda 參數:返回值

注意:

　　1.函數的參數能夠有不少個,多個參數之間用逗號隔開.

　　2.匿名函數無論多複雜,只能寫一行,且邏輯結束後直接返回數據.

　　3.返回值和正常函數同樣,能夠是任意數據類型.

 

匿名函數並非說必定沒有名字.這裏前面的變量就是一個函數名.說他是匿名函數緣由是咱們經過__name__查看的時候是沒有名字的.統一都叫lambda.在調用的時候沒有什麼特別之處.像正常的函數調用便可

 

二.sorted()

　　排序函數.

　　語法:sorted(Iterable,key=None,reverse=False)

　　　　Iterable:可迭代對象

　　　　key:排序規則(排序函數),在sorted內部會將可迭代對象中的每個元素傳遞給這個函數的參數.根據函數運算的結果進行排序

　　　　reverse:是不是倒序.True:倒序,False:正序.

1 lst = [1,5,3,4,6]
2 lst2 = sorted(lst)
3 print(lst) # 原列表不會改變
4 print(lst2) # 返回的新列表是通過排序的
5 
6 dic = {1:'A', 3:'C', 2:'B'}
7 print(sorted(dic)) # 若是是字典. 則返回排序事後的ke

　　和函數組合使用

1 # 根據字符串⻓度進⾏排序
2 lst = ["麻花藤", "岡本次郎", "中央情報局", "狐仙"]
3 # 計算字符串長度
4 def func(s):
5   return len(s)
6 
7 print(sorted(lst, key=func))

　　和lambda組合使用

 1 # 根據字符串⻓度進⾏排序
 2 lst = ["麻花藤", "岡本次郎", "中央情報局", "狐仙"]
 3 # 計算字符串長度
 4 def func(s):
 5   return len(s)
 6 
 7 print(sorted(lst, key=lambda s: len(s)))
 8 lst = [{"id":1, "name":'alex', "age":18},
 9  {"id":2, "name":'wusir', "age":16},
10   {"id":3, "name":'taibai', "age":17}]
11 # 按照年齡對學生信息進行排序
12 print(sorted(lst, key=lambda e: e['age']))

 

三.filter()

　　篩選函數

　　語法:filter(function,Iterable)

　　　　function:用來篩選的函數.在filter中會自動的把iterable中的元素傳遞給function.而後根據function返回的True或者False來判斷是否保留此項數據

　　　　Iterable:可迭代對象

1 lst = [1,2,3,4,5,6,7]
2 ll = filter(lambda x: x%2==0, lst) # 篩選全部的偶數
3 print(ll)
4 print(list(ll))
5 lst = [{"id":1, "name":'alex', "age":18},
6  {"id":2, "name":'wusir', "age":16},
7   {"id":3, "name":'taibai', "age":17}]
8 fl = filter(lambda e: e['age'] > 16, lst) # 篩選年齡大於16的數據
9 print(list(fl))

 

四.map()

　　映射函數

　　語法:map(function,iterable)能夠對可迭代對象中的每個元素進行映射.分別取執行function

　　計算列表中每一個元素的平方,返回新列表

1 def func(e):
2   return e*e
3 
4 mp = map(func, [1, 2, 3, 4, 5])
5 print(mp)
6 print(list(mp))

　　改寫成lambda

 print(list(map(lambda x: x * x, [1, 2, 3, 4, 5]))) 

　　計算兩個列表中相同位置的數據的和

1 # 計算兩個列表相同位置的數據的和
2 lst1 = [1, 2, 3, 4, 5]
3 lst2 = [2, 4, 6, 8, 10]
4 print(list(map(lambda x, y: x+y, lst1, lst2))

 

五.遞歸

　　在函數中調用函數自己,就是遞歸

1 def func():
2   print("我是誰")
3   func()
4 func()

　　在python中遞歸的深度最大到998

 1 def foo(n): 2 print(n) 3 n += 1 4 foo(n) 5 foo(1) 

 遞歸的應用

　　咱們可使用遞歸來遍歷各類樹形結構,好比咱們的文件夾系統.可使用遞歸來遍歷該文件夾中的全部文件

 1 import os
 2 def read(filepath, n):
 3   files = os.listdir(filepath) # 獲取到當前文件夾中的全部文件
 4  for fi in files: # 遍歷文件夾中的文件, 這裏獲取的只是本層文件名
 5   fi_d = os.path.join(filepath,fi) # 加入文件夾 獲取到文件夾
 6  if os.path.isdir(fi_d): # 若是該路徑下的文件是文件夾
 7   print("\t"*n, fi)
 8   read(fi_d, n+1) # 繼續進行相同的操做
 9   else:
10   print("\t"*n, fi) # 遞歸出口. 最終在這裏隱含着return
11 #遞歸遍歷目錄下全部文件
12 read('../oldboy/', 0)

 

六.二分查找

　　二分查找.每次可以排除掉一半的數據.查找的效率很是高.可是侷限性比較大.必須是有序序列纔可使用二分查找

　　要求:查找的序列必須是有序序列.

 1 # 判斷n是否在lst中出現. 若是出現請返回n所在的位置
 2 # ⼆分查找---非遞歸算法
 3 lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789
 4 n = 567
 5 left = 0
 6 right = len(lst) - 1
 7 count = 1
 8 while left <= right:
 9   middle = (left + right) // 2
10   if n < lst[middle]:
11   right = middle - 1
12   elif n > lst[middle]:
13   left = middle + 1
14   else:
15   print(count)
16   print(middle)
17   break
18   count = count + 1
19 else:
20   print("不存在")
21 
22 
23 # 普通遞歸版本二分法
24 def binary_search(n, left, right):
25   if left <= right:
26   middle = (left+right) // 2
27   if n < lst[middle]:
28  right = middle - 1
29   elif n > lst[middle]:
30   left = middle + 1
31   else:
32   return middle
33   return binary_search(n, left, right) # 這個return必需要加. 不然接收到的永遠是None.
34 
35   else:
36   return -1
37 print(binary_search(567, 0, len(lst)-1))
38 
39 # 另類二分法, 很難計算位置.
40 def binary_search(ls, target):
41   left = 0
42   right = len(ls) - 1
43   if left > right:
44   print("不在這裏")
45   middle = (left + right) // 2
46   if target < ls[middle]:
47   return binary_search(ls[:middle], target)
48   elif target > ls[middle]:
49   return binary_search(ls[middle+1:], target)
50   else:
51   print("在這裏")
52 binary_search(lst, 56

# 時間複雜度最低, 空間複雜度最低的查找方法

1 lst1 = [5,6,7,8]
2 lst2 = [0,0,0,0,0,1,1,1,1]
3 for el in lst1:
4      lst2[el] = 1
5 
6 lst2[4] == 1   # o(1)

只須要查找一次