【Python3之匿名函數及遞歸】

1、匿名函數及內置函數補充

1.語法

Python使用lambda關鍵字創造匿名函數。所謂匿名，意即再也不使用def語句這樣標準的形式定義一個函數。

語法：

lambda [arg1[, arg2, ... argN]]: expression

 

例：

普通函數

def func(x,y):
    return x+y print(func) print(func(1,2))

輸出

<function func at 0x102b31f28>
3

等價的匿名函數

#匿名函數
f=lambda x,y:x+y
print(f) print(f(1,2))

輸出

<function <lambda> at 0x107a55f28>
3

 

2.匿名函數配合內置函數的用法

• max,min,zip,sorted的用法

• max(arg1, arg2, *args[, key]) #key=keyfunc

salaries={
'e':3000, 'a':100000000, 'w':10000, 'y':2000 } print(max(salaries)) #默認比較key值大小 res=zip(salaries.values(),salaries.keys()) #以values比較 print(max(res))

 

• 配合匿名函數實現上面功能

salaries={
'e':3000, 'a':100000000, 'w':10000, 'y':2000 } def func(k): return salaries[k] print(max(salaries,key=func)) #傳遞函數 print(max(salaries,key=lambda k:salaries[k])) #配合匿名函數,比較values print(min(salaries,key=lambda k:salaries[k]))

# print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #默認的排序結果是從小到到

輸出

a
a
y

 

補充：

• map(function, iterable, ...)
• 對可迭代函數'iterable'中的每個元素應用‘function’方法，將結果做爲list返回。

 

例：

l=['a','w','y']
res=map(lambda x:x+'_12',l) print(res) print(list(res)) nums=(2,4,9,10) res1=map(lambda x:x**2,nums) print(list(res1))

輸出

<map object at 0x108e0bef0>
['a_12', 'w_12', 'y_12'] [4, 16, 81, 100]

• reduce(function, sequence[, initial]) -> value

•  對sequence中的item順序迭代調用function，函數必需要有2個參數。要是有第3個參數，則表示初始值，能夠繼續調用初始值，返回一個值。

l=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,l,10))　　#10+1+2+3+4+5

輸出

25

 

• filter(function or None, sequence) -> list, tuple, or string

• 對sequence中的item依次執行function(item)，將執行結果爲True（！=0）的item組成一個List/String/Tuple（取決於sequence的類型）返回，False則退出（0），進行過濾。

l=['a_SB','w_SB','y','egon']

res=filter(lambda x:x.endswith('SB'),l) print(res) print(list(res))

輸出

<filter object at 0x10bc43ef0>
['a_SB', 'w_SB']

 

2、遞歸調用

1.定義

遞歸就是在過程或函數裏調用自身，在使用遞歸策略時，必須有一個明確的遞歸結束條件，稱爲遞歸出口。

遞歸的兩個階段：

遞歸和回溯

 

2.遞歸思想

例：

 

階乘函數的定義是：
N! = factorial(N) = 1 * 2 * 3 * ... * N

 

那麼能夠用這種方法來看階乘函數：
factorial(N) = N!
             = N * (N - 1)!
             = N * (N - 1) * (N - 2)!
             = N * (N - 1) * (N - 2) * ... * 3 * 2 * 1
             = N * factorial(N - 1)

 

因而咱們有了階乘函數的遞歸版本：

 

def factorial(n):
    if n == 0 or n == 1: return 1
    else: return (n * factorial(n - 1)) print(factorial(6))

 

能夠很輕易的獲得，6!的結果是720。

 

每個遞歸程序都遵循相同的基本步驟： 
1.初始化算法。遞歸程序一般須要一個開始時使用的種子值（seed value）。要完成此任務，能夠向函數傳遞參數，或者提供一個入口函數，這個函數是非遞歸的，但能夠爲遞歸計算設置種子值。 
2.檢查要處理的當前值是否已經與基線條件相匹配（base case）。若是匹配，則進行處理並返回值。 
3.使用更小的或更簡單的子問題（或多個子問題）來從新定義答案。 
4.對子問題運行算法。 
5.將結果合併入答案的表達式。 
6.返回結果。

3.用途

 

遞歸算法通常用於解決三類問題：
（1）數據的定義是按遞歸定義的。（好比Fibonacci函數）
（2）問題解法按遞歸算法實現。（回溯）
（3）數據的結構形式是按遞歸定義的。（好比樹的遍歷，圖的搜索） 　　

 

遞歸的缺點：遞歸算法解題的運行效率較低。在遞歸調用的過程中系統爲每一層的返回點、局部量等開闢了棧來存儲。遞歸次數過多容易形成棧溢出等。

 

4.二分法

 

l = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]

def search(find_num,seq): if len(seq) == 0: print('not exists') return mid_index=len(seq)//2 mid_num=seq[mid_index] print(seq,mid_num) if find_num > mid_num: #in the right seq=seq[mid_index+1:] search(find_num,seq) elif find_num < mid_num: #in the left seq=seq[:mid_index] search(find_num,seq) else: print('find it') search(77,l) search(72,l) search(-100000,l)

 

輸出

[1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75
[77, 85, 101, 201, 202, 999, 11111] 201 [77, 85, 101] 85 [77] 77 find it [1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75 [1, 2, 10, 33, 53, 71, 73] 33 [53, 71, 73] 71 [73] 73 not exists [1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75 [1, 2, 10, 33, 53, 71, 73] 33 [1, 2, 10] 2 [1] 1 not exists