匿名函數與函數遞歸

1、什麼是匿名函數

　　匿名函數就是沒有名字的函數，又叫lambda表達式。用於一些簡單的須要用函數去解決的問題，特色是隻能在定義時使用一次，且函數體只有一行

　　匿名函數的定義就至關於只產生一個變量的值，而沒有綁定任何名字，因此會在定義完以後就被回收，沒法重複使用，只能在定義時使用一次

2、爲什麼要用匿名函數

　　當某一個功能僅使用一次就沒有再重複使用的必要了，就能夠定義成匿名函數

3、匿名函數的應用

參數能夠有多個，用逗號隔開，返回值和正常的函數同樣能夠是任意的數據類型

# 把下面的函數轉換成匿名函數
def add(x, y): return x + y s = add(5, 8) print(s) # 結果：
s = (lambda x, y: x + y)(5, 8) print(s)

匿名函數的應用

# 取出最大工資對應的人名
 salaries = { 'qiu': 2000, 'xi': 30000, 'qiuxi': 2500, 'rufeng': 3000 } def func(k): return salaries[k] print(max(salaries,key=func))   # xi

# 1. 將可迭代對象salaries變成迭代器對象iter_obj # 2. next(iter_obj)獲得一我的名，而後將該人名看成參數傳給key指定的函數，而後調用函數將函數的返回值看成比較依據 # 3. 比較大小，取出最大值對應的人名

# 上面的函數還能夠用匿名函數來實現
print(max(salaries, key=lambda k: salaries[k])) # 一樣，取出最小的使用函數min
print(min(salaries, key=lambda k: salaries[k]))

max函數與匿名函數

# 將全部人的工資大小排序，輸出排序後的人名
 salaries = { 'qiu': 2000, 'xi': 30000, 'qiuxi': 2500, 'rufeng': 3000 } # 從大到小
print(sorted(salaries, key=lambda k: salaries[k], reverse=True)) # 從小到大
print(sorted(salaries, key=lambda k: salaries[k])) # 運行後
['xi', 'rufeng', 'qiuxi', 'qiu'] ['qiu', 'qiuxi', 'rufeng', 'xi']

sorted函數與匿名函數

# 爲每一個名字加上一串字符
names = ['qiu', 'xi', 'ru', 'feng'] # 手動實現
new_names = [] for name in names: new_names.append(name+'_nice') print(new_names) # 列表生成式
new_names = [name+'_nice' for name in names] print(new_names) # map+匿名函數
res = map(lambda x: x+'_nice', names) print(res)  # Python3裏會打印函數地址
print(list(res)) # 運行後
['qiu_nice', 'xi_nice', 'ru_nice', 'feng_nice'] ['qiu_nice', 'xi_nice', 'ru_nice', 'feng_nice'] <map object at 0x0000012E7A848A90> ['qiu_nice', 'xi_nice', 'ru_nice', 'feng_nice']

map函數與匿名函數

# 1到100的求和

# 手動實現
res = 0 for i in range(101): res += i print(res) # 列表生成式
print(sum([i for i in range(101)])) # reduce+匿名函數
from functools import reduce print(reduce(lambda x, y: x + y, [i for i in range(101)])) # 運行
5050
5050
5050

reduce函數和匿名函數

# 提取包含指定字符的元素並輸出
names=['qiu_nice','xi_nice','ru_nice','feng'] # 方式一:手動實現
new_names = [] for name in names: if name.endswith('nice'): new_names.append(name) print(new_names) # 方式二:列表生成式
new_names = [name for name in names if name.endswith('nice')] print(new_names) # 方式三:filter+匿名函數
res = filter(lambda name: name.endswith('nice'),names) print(res)      # Python3輸出地址
print(list(res)) # 運行
['qiu_nice', 'xi_nice', 'ru_nice'] ['qiu_nice', 'xi_nice', 'ru_nice'] <filter object at 0x000001DBBE8C8390> ['qiu_nice', 'xi_nice', 'ru_nice']

filter函數與匿名函數

4、什麼是函數遞歸

　　函數的遞歸調用是函數嵌套調用的一種特殊形式，即在調用一個函數的過程當中又直接或者間接地調用了該函數自己

　　遞歸本質就是一個循環的過程，可是遞歸必須知足兩個原則：

　　　　一、每進入下一層遞歸，問題的規模必須有所減小

　　　　二、遞歸必須有一個明確的結束條件或者說有一個明確的進入下一層遞歸的條件

　　而且遞歸有兩個明確的階段：

　　　　一、回溯：一層一層的遞歸調用下去

　　　　二、遞推：在某一層結束掉遞歸，而後一層一層返回

5、爲什麼要用遞歸

　　在某些狀況下，基於遞歸來使用重複的過程比循環更加簡單

6、遞歸的使用

一、猜年齡

　　小明是新來的同窗，麗麗問他多少歲了。他說：我不告訴你，可是我比滔滔大兩歲。滔滔說：我也不告訴你，我比曉曉大兩歲。曉曉說：我也不告訴你，我比小星大兩歲。小星也沒有告訴他，說：我比小華大兩歲。最後小華說，我告訴你，我今年18歲了

這個怎麼辦呢？固然，有人會說，這個很簡單啊，知道小華的，就會知道小星的，知道小星的就會知道曉曉的，以此類推，就會知道小明的年齡啦。這個過程已經很是接近遞歸的思想了。

小華	18
小星	18+2
曉曉	20+2
滔滔	22+2
小明	24+2

age(5) = age(4)+2
age(4) = age(3) + 2 
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 18

def calc_age(n): if n == 1: return 18
    else: return calc_age(n-1)+2

print(calc_age(5)) # 26

代碼實現

二、取元素

　　給定一個嵌套列表，取出列表中的每一個元素輸出打印

　　li = [1, [2, [3, [4, [5, [6, [7, [8, [9, ]]]]]]]]]

li = [1, [2, [3, [4, [5, [6, [7, [8, [9, ]]]]]]]]] def func(l): for i in l: if type(i) is list: func(i) else: print(i) func(li)

代碼實現

7、二分法查找

假設要在電話簿中找一個名字以K打頭的人，能夠從頭開始翻頁，直到進入以K打頭的部分。但你極可能不這樣作，而是從中間開始，由於你知道以K打頭的名字在電話簿中間。這是一個查找問題，可使用二分查找算法來解決。而算法就是一組完成任務的指令，是高效解決問題的一種思路。

假設我從1到100隨便想一個數字，你的目標是以最少的次數猜到這個數字。你每次猜想後，我會說小了、大了或對了。假設你從1開始依次往上猜，每次加一個數，這樣每次猜想都只能排除一個數字。若是我想的數字是99，你得猜99次才能猜到！這是簡單查找，更準確的說法是傻找，這顯然是一種糟糕的猜數法。

假設你從50開始猜，若是小了，排除了一半的數字！至此，你知道1～50都小了。接下來，你猜75，大了，那餘下的數字又排除了一半！！使用二分查找時，你猜想的是中間的數字，從而每次都將餘下的數字排除一半。接下來，你猜63（50和75中間的數字），大了，猜57，對了，這就是二分查找。無論我內心想的是哪一個數字，你在7次以內都能猜到，由於每次猜想都將排除不少數字！

使用二分查找時，每次都排除一半的數字

使用二分法，數字列表是有序的

# 從小到大排列的數字列表
nums = [1, 13, 15, 23, 27, 31, 33, 57, 73, 81, 93, 94, 97, 101] def binary_search(find_num,nums): if len(nums) == 0: print('不存在') return mid_index = len(nums) // 2
    if find_num > nums[mid_index]: # 在右邊
        nums = nums[mid_index + 1:] binary_search(find_num, nums) elif find_num < nums[mid_index]: # 在左邊
        nums = nums[:mid_index] binary_search(find_num, nums) else: print('找到了') binary_search(97, nums)

代碼實現