Python6.2

函數式編程

函數是Python內建支持的一種封裝，我們通過把大段代碼拆成函數，通過一層一層的函數調用，就可以把複雜任務分解成簡單的任務，這種分解可以稱之爲面向過程的程序設計。函數就是面向過程的程序設計的基本單元。
函數式編程（請注意多了一個“式”字）——Functional Programming，雖然也可以歸結到面向過程的程序設計，但其思想更接近數學計算。
瞭解一下計算機（Computer）和計算（Compute）的概念。在計算機的層次上，CPU執行的是加減乘除的指令代碼，以及各種條件判斷和跳轉指令，所以，彙編語言是最貼近計算機的語言。計算則指數學意義上的計算，越是抽象的計算，離計算機硬件越遠。
對應到編程語言，就是越低級的語言，越貼近計算機，抽象程度低，執行效率高，比如C語言；越高級的語言，越貼近計算，抽象程度高，執行效率低，比如Lisp語言。
函數式編程就是一種抽象程度很高的編程範式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之爲沒有副作用。而允許使用變量的程序設計語言，由於函數內部的變量狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。
函數式編程的一個特點就是，允許把函數本身作爲參數傳入另一個函數，還允許返回一個函數！
Python對函數式編程提供部分支持。由於Python允許使用變量，因此，Python不是純函數式編程語言。

高階函數

高階函數英文叫Higher-order function。

變量可以指向函數

以Python內置的求絕對值的函數abs()爲例，調用該函數用abs（-1），但是如果只寫abs：

>>> abs
<built-in function abs>

可見，abs(-10)是函數調用，而abs是函數本身。
要獲得函數調用結果，我們可以把結果賦值給變量：

>>> x = abs(-10)
>>> x
10

如果把函數本身賦值給變量：

>>> f = abs
>>> f
<built-in function abs>

結論：函數本身也可以賦值給變量，即：變量可以指向函數。
如果一個變量指向了一個函數，那麼，可否通過該變量來調用這個函數？

>>> f = abs
>>> f(-10)
10

說明變量f現在已經指向了abs函數本身。直接調用abs()函數和調用變量f()完全相同。

函數名也是變量

函數名其實就是指向函數的變量！對於abs()這個函數，完全可以把函數名abs看成變量，它指向一個可以計算絕對值的函數！如果把abs指向其他對象呢？

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

把abs指向10後，就無法通過abs(-10)調用該函數了！因爲abs這個變量已經不指向求絕對值函數而是指向一個整數10！
當然實際代碼絕對不能這麼寫，這裏是爲了說明函數名也是變量。要恢復abs函數，請重啓Python交互環境。
注：由於abs函數實際上是定義在import builtins模塊中的，所以要讓修改abs變量的指向在其它模塊也生效，要用import builtins; builtins.abs = 10。

傳入函數

變量可以指向函數，函數的參數能接收變量，那麼一個函數就可以接收另一個函數作爲參數，這種函數就稱之爲高階函數。

一個最簡單的高階函數：

>>> def add(x,y,f):
...     return f(x)+f(y)
...
>>> print(add(-5,6,abs))
11

當我們調用add(-5, 6, abs)時，參數x，y和f分別接收-5，6和abs。
編寫高階函數，就是讓函數的參數能夠接收別的函數。

小結

把函數作爲參數傳入，這樣的函數稱爲高階函數，函數式編程就是指這種高度抽象的編程範式。

map/reduce

Python內建了map()和reduce()函數。
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。
寫一個循環，也可以計算出結果：

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print(L)

但是，從上面的循環代碼，能一眼看明白“把f(x)作用在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']

reduce把一個函數作用在一個序列[x1, x2, x3, …]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素做累積計算，效果就是：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
一個序列求和，就可以用reduce實現：

>>> def add(x,y):
...     return x+y
...
>>> reduce(add,[1,2,3,4,5,6])
21

當然求和運算可以直接用Python內建函數sum()，沒必要動用reduce。
但是如果要把序列[1, 2, 3, 4]變換成整數1234，reduce就可以派上用場：

>>> from functools import reduce
>>> def f(x,y):
...     return x*10+y
...
>>> reduce(f,[1,2,3,4])
1234

這個例子本身沒多大用處，但是，如果考慮到字符串str也是一個序列，對上面的例子稍加改動，配合map()，我們就可以寫出把str轉換爲int的函數：

>>> from functools import reduce
>>> def fn(x,y):
...     return x*10+y
...
>>> def char2int(s):
...     digits={'0':0,'1':1,'2':2,'3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
...     return digits[s]
...
>>> reduce(fn,map(char2int,'123456'))
123456

整理成一個str2int的函數就是：

>>> from functools import reduce
>>> digits={'0':0,'1':1,'2':2,'3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
>>> def str2int(s):
...     def fn(x,y):
...         return x*10+y
...     def char2int(s):
...         return digits[s]
...     return reduce(fn,map(char2int,s))
...
>>> str2int('123')
123

還可以用lambda函數進一步簡化（lambda 是python定義匿名函數的語法，lambda x：x*x，這個匿名函數的形參是x，表達式x *x 的值就是這個函數的返回值。）

from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def char2int(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2int, s))

也就是說，假設Python沒有提供int()函數，你完全可以自己寫一個把字符串轉化爲整數的函數，而且只需要幾行代碼！

練習

利用map()函數，把用戶輸入的不規範的英文名字，變爲首字母大寫，其他小寫的規範名字。輸入：[‘adam’, ‘LISA’, ‘barT’]，輸出：[‘Adam’, ‘Lisa’, ‘Bart’]：

>>> list(map(normalize,['adam','LISA','barT']))
['A', 'L', 'B']
>>> def normalize(name):
...     name=name[0].upper()+name[1:].lower()
...     return name
...
>>> list(map(normalize,['adam','LISA','barT']))
['Adam', 'Lisa', 'Bart']

Python提供的sum()函數可以接受一個list並求和，請編寫一個prod()函數，可以接受一個list並利用reduce()求積：

>>> from functools import reduce
>>> def prod(x,y):
...     return x*y
...
>>> reduce(prod,[1,2,3,4,5,6,7,8,9])
362880

利用map和reduce編寫一個str2float函數，把字符串’123.4567’轉換成浮點數123.4567：

from functools import reduce
def str2float(s):
    def fn(x,y):
        return x*10+y
    n=s.index('.')
    s1=list(map(int,[x for x in s[:n]]))
    s2=list(map(int,[x for x in s[n+1:]]))
    return reduce(fn,s1) + reduce(fn,s2)/10**len(s2)
print('\'123.4567\'=',str2float('123.4567')) 
if abs(str2float('123.4567') - 123.4567) < 0.00001:
    print('測試成功!')
else:
print('測試失敗!')


F:\>python hello.py
'123.4567'= 123.4567
測試成功!

Python index() 方法檢測字符串中是否包含子字符串 str ，如果指定 beg（開始） 和 end（結束） 範圍，則檢查是否包含在指定範圍內，該方法與 python find()方法一樣，只不過如果str不在 string中會報一個異常。
index()方法語法：str.index(str, beg=0, end=len(string))
str – 指定檢索的字符串beg – 開始索引，默認爲0。end – 結束索引，默認爲字符串的長度。如果包含子字符串返回開始的索引值，否則拋出異常。
注意：
1行，從 functools 包裏調用 reduce
3-4行，定義一個 fn() 函數，用來把S1，S2這兩個list裏面的元素變成一個數。
5行，很關鍵的一步，利用 index() 函數確定字符串 S 中 ‘.’的位置。
6-7行，先利用切片把我們傳入的 str 分成以前以後兩個部分（其實就是根據小數點分成整數和浮點數，分別處理），然後再把切割好的 str 利用 int 變成整數，map() 函數負責把 int 作用到截取的 str 的每個元素中去。
8行，就說一個知識點，其他的都很好理解，m**n 這個表達的就是 m 的 n 次方。