python函數語言程式設計（一）map/reduce、filter、sorted
1. 變數可以指向函式
函式本身也可以賦值給變數，即：變數可以指向函式：
>>>f = abs
>>>f(-10)
10
2. 傳入函式
既然變數可以指向函式，函式的引數能接收變數，那麼一個函式就可以接收另一個函式作為引數，這種函式就稱之為高階函式。
一個最簡單的高階函式：
defadd(x, y, f):
return f(x) + f(y)
當我們呼叫add(-5,6, abs)時，引數x，y和f分別接收-5，6和abs，根據函式定義，我們可以推導計算過程為：
x = -5
y = 6
f = abs
f(x) +f(y) ==> abs(-5) + abs(6) ==> 11
return11
用程式碼驗證一下：
>>>add(-5, 6, abs)
11
編寫高階函式，就是讓函式的引數能夠接收別的函式。
3. map
我們先看map。map()函式接收兩個引數，一個是函式，一個是Iterable，map將傳入的函式依次作用到序列的每個元素，並把結果作為新的Iterator返回。
有一個函式f(x)=x2，要把這個函式作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下：
>>>def f(x):
return x * x
>>>r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>>list(r)
[1, 4,9, 16, 25, 36, 49, 64, 81]
map()傳入的第一個引數是f，即函式物件本身。由於結果r是一個Iterator，Iterator是惰性序列，因此通過list()函式讓它把整個序列都計算出來並返回一個list。
map()作為高階函式，事實上它把運算規則抽象了，因此，我們不但可以計算簡單的f(x)=x2，還可以計算任意複雜的函式，比如，把這個list所有數字轉為字串：
>>>list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1','2', '3', '4', '5', '6', '7', '8', '9']
4. reduce
再看reduce的用法。reduce把一個函式作用在一個序列[x1, x2, x3, ...]上，這個函式必須接收兩個引數，reduce把結果繼續和序列的下一個元素做累積計算，其效果就是：
reduce(f,[x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方說對一個序列求和，就可以用reduce實現：
>>>from functools import reduce
>>>def add(x, y):
. returnx + y
>>>reduce(add, [1, 3, 5, 7, 9])
25
要把序列[1, 3, 5,7, 9]變換成整數13579:
>>>from functools import reduce
>>>def fn(x, y):
return x * 10 + y
>>>reduce(fn, [1, 3, 5, 7, 9])
13579
5. map、reduce結合使用
可以寫出把str轉換為int的函式：
fromfunctools import reduce
defstr2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3,'4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
return reduce(fn, map(char2num, s))
還可以用lambda函式進一步簡化成：
fromfunctools import reduce
defchar2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3,'4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
defstr2int(s):
return reduce(lambda x, y: x * 10 + y,map(char2num, s))
6. map/reduce用例
(1)利用map()函式，把使用者輸入的不規範的英文名字，變為首字母大寫，其他小寫的規範名字。輸入：['adam', 'LISA', 'barT']，輸出：['Adam', 'Lisa','Bart']：
defnormalize(name):
return name.lower().capitalize() #str.lower()將所有的字串變成小寫
#str.capitalize()返回一個首字母大寫的字串。
L1 =['adam', 'LISA', 'barT']
L2 =list(map(normalize, L1))
print(L2)
(2)python提供的sum()函式可以接受一個list並求和，編寫一個prod()函式，可以接受一個list並利用reduce()求積：
fromfunctools import reduce
defprod(list):
def mul(x,y):
return x*y
return reduce(mul,list)
print('3* 5 * 7 * 9 =', prod([3, 5, 7, 9]))
(3)利用map和reduce編寫一個str2float函式，把字串'123.456'轉換成浮點數123.456：
importmath
fromfunctools import reduce
defstr2float(s):
index = s.index('.') #str.index()得到字串索引位置,為3(0、1、2、3)
n = len(s) - 1 - index #計算小數位數
s = s.replace('.', '') #用空取代.,變成'123456'
def chr2num(s):
return{'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]
def cal(x,y):
return x * 10 + y
return reduce(cal, map(chr2num,s))/math.pow(10, n)
#先將字串寫list[1,2,3,4,5,6];再寫作整數123456;對整數除以10的n次方，n為小數位數
print('str2float(\'123.456\')=', str2float('123.456'))
print(type(str2float('123.456')))
7. filter
Python內建的filter()函式用於過濾序列。
和map()類似，filter()也接收一個函式和一個序列。和map()不同的是，filter()把傳入的函式依次作用於每個元素，然後根據返回值是True還是False決定保留還是丟棄該元素。
在一個list中，刪掉偶數，只保留奇數，可以這麼寫：
defis_odd(n):
return n % 2 == 1
list(filter(is_odd,[1, 2, 4, 5, 6, 9, 10, 15]))
# 結果: [1, 5, 9, 15]
把一個序列中的空字串刪掉，可以這麼寫：
defnot_empty(s):
return s and s.strip()
#str.strip()移除字串頭尾指定的字元（預設為空格），此處s字串若為空，false
list(filter(not_empty,['A', '', 'B', None, 'C', ' ']))
# 結果: ['A', 'B', 'C']
可見用filter()這個高階函式，關鍵在於正確實現一個“篩選”函式。
注意到filter()函式返回的是一個Iterator，也就是一個惰性序列，所以要強迫filter()完成計算結果，需要用list()函式獲得所有結果並返回list。
8. 用filter求素數
計算素數的一個方法是埃氏篩法，它的演算法理解起來非常簡單：
首先，列出從2開始的所有自然數，構造一個序列：
2, 3,4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一個數2，它一定是素數，然後用2把序列的2的倍數篩掉：
3, 4,5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一個數3，它一定是素數，然後用3把序列的3的倍數篩掉：
5, 6,7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一個數5，然後用5把序列的5的倍數篩掉：
7, 8,9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
不斷篩下去，就可以得到所有的素數。
用Python來實現這個演算法，可以先構造一個從3開始的奇數序列：
def_odd_iter():
n = 1
while True:
n= n + 2
yield n
注意這是一個生成器，並且是一個無限序列。
然後定義一個篩選函式：
def_not_divisible(n):
return lambda x: x % n > 0
最後，定義一個生成器，不斷返回下一個素數：
defprimes():
yield 2
it = _odd_iter() # 初始序列
while True:
n = next(it) # 返回序列的第一個數
yield n
it = filter(_not_divisible(n), it) # 構造新序列
這個生成器先返回第一個素數2，然後，利用filter()不斷產生篩選後的新的序列。
由於primes()也是一個無限序列，所以呼叫時需要設定一個退出迴圈的條件：
# 列印1000以內的素數:
for nin primes():
if n < 1000:
print(n)
else:
break
9. filter用例
回數是指從左向右讀和從右向左讀都是一樣的數，例如12321，909。請利用filter()濾掉非回數：
defis_palindrome(n):
return str(n)==str(n)[::-1] andlen(str(n))>1
#a[::1]將列表a倒序處理，如果a＝[1,2,3]，則a[::－1]=[3，2，1]
#字串'xxx'也可以看成是一種list，每個元素就是一個字元。
output=filter(is_palindrome,range(1, 10000))
print(list(output))
10. sorted
Python內建的sorted()函式就可以對list進行排序：
>>>sorted([36, 5, -12, 9, -21])
[-21,-12, 5, 9, 36]
此外，sorted()函式也是一個高階函式，它還可以接收一個key函式來實現自定義的排序例如按絕對值大小排序：
>>>sorted([36, 5, -12, 9, -21], key=abs)
[5, 9,-12, -21, 36]
key指定的函式將作用於list的每一個元素上，並根據key函式返回的結果進行排序。
我們再看一個字串排序的例子：
>>>sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit','Zoo', 'about', 'bob']
預設情況下，對字串排序，是按照ASCII的大小比較的，由於'Z' < 'a'，結果，大寫字母Z會排在小寫字母a的前面。
現在，我們提出排序應該忽略大小寫，按照字母序排序。要實現這個演算法，不必對現有程式碼大加改動，只要我們能用一個key函式把字串對映為忽略大小寫排序即可。忽略大小寫來比較兩個字串，實際上就是先把字串都變成大寫（或者都變成小寫），再比較。
這樣，我們給sorted傳入key函式，即可實現忽略大小寫的排序：
>>>sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about','bob', 'Credit', 'Zoo']
要進行反向排序，不必改動key函式，可以傳入第三個引數reverse=True
>>>sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo','Credit', 'bob', 'about']
11. sorted用例
(1)假設我們用一組tuple表示學生名字和成績：
L =[('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
用sorted()對上述列表分別按名字排序：
L =[('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
defby_name(t):
return t[:][0]
L2 =sorted(L, key=by_name)
print(L2)
(2)再按成績從高到低排序：
L =[('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
defby_score(t):
return t[:][1]
L2 =sorted(L, key=by_score, reverse=True)
print(L2)