函數式編程

函數式編程的特點

把計算視爲函數而非指令；
純函數式編程：不需要變量，沒有副作用，測試簡單；
支持高階函數，代碼簡潔；

Python支持的函數式編程

不是純函數式編程，允許有變量；
支持高階函數，函數也可以作爲變量傳入；
支持閉包，有了閉包就能返回函數；
有限度的支持匿名函數；

高階函數

變量可以指向函數：直接對這個變量調用相當於調用了這個函數；
函數名其實就是指向函數的變量

>>> abs = len
>>> abs(-10)
>>> ERROR
>>> abs([1, 2, 3])

3

高階函數：能接收函數做參數的函數

>>> def add(x, y, f) :
...     return f(x) + f(y)
...
>>> add(-5, 9, abs)
>>> 
14

Python中的map()函數

map()是Python內置的高階函數，它接收一個函數f和一個list，並通過把函數f依次作用在list的每個元素上，得到一個新的list並返回。例如，對於list[1, 2, 3, 4, 5, 6, 7, 8, 9]，如果希望把list的每個元素都平方，就可以用map()函數：

def f(x) :
    return x * x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

輸出結果：

[1, 4, 9, 16, 25, 36, 49, 81]

注意：map()函數不改變原有的list，而是返回一個新的list。

例：假設用戶輸入的英文名字不規範，沒有按照首字母大寫，後續字母小寫的規則，利用map()函數，把一個list（包含若干不規範的英文名字）變成一個包含規範英文名字的list：

輸入

['adam', 'LISA', 'barT']

輸出：

['Adam', 'Lisa', 'Bart']

def format_name(s) :
    return (s[0].upper() + s[1 :].lower())
print map(format_name, ['adam', 'LISA', 'barT'])

Python中的reduce()函數

reduce()函數也是Python內置的一個高階函數。reduce()函數接收的參數和map()類似，一個函數f，一個list，但行爲和map()不同，reduce()傳入的函數f必須接收兩個參數，reduce()對list的每個元素反覆調用函數f，並返回最終結果值：

def f(x, y) :
    return x + y
print reduce(f, [1, 3, 4, 5, 9])

Python中的filter()函數

filter()函數是Python內置的另一個有用的高階函數，filter()函數接收一個函數f和一個list，這個函數f的作用是對每個元素進行判斷，返回True或False。filter()根據判斷結果自動過濾掉不符合條件的元素，返回由符合條件元素組成的新list。例如，要過濾出list[1, 4, 6, 7, 9, 12, 17]中的偶數：

def is_odd(x) :
    return x % 2 == 1
print filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

輸出：

[1, 7, 9, 17]

例：用filter()過濾出1-100平方根是整數的數：

import math
def is_sqr(x) :
    if math.sqrt(x) - math.floor(math.sqrt(x)) == 0
        return x
print filter(is_sqr, range(1, 101))

Python中的自定義排序函數

Python內置的sorted()函數可對list進行排序：

>>> sorted([36, 5, 12, 9, 21])

[5, 9, 12, 21, 36]

但sorted()也是一個高階函數，它可以接收一個比較函數來實現自定義排序。比較函數的定義是：傳入兩個待比較的元素x, y，如果x應該排在y前面，返回-1；如果x應該排在y後面，返回1.如果x和y相等，返回0。因此，如果我們要實現倒序排序，只需要利用一個比較函數，配合sorted()即可：

def reverse_cmp(x, y) :
    if x > y
        return -1
    if x < y
        return 1
    else 
        return 0
sorted([36, 5, 12, 9, 21], reverse_cmp)

輸出：

[36, 21, 12, 9, 5]

sorted()也可以對字符串進行排序，字符串默認按照ASCII大小來比較：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
>>> 
['Credit', 'Zoo', 'about', 'bob']

例：對字符串排序時，有時候忽略大小寫排序更符合習慣。請利用sorted()高階函數，實現忽略大小寫排序的算法。

輸入：

['bob', 'about', 'Zoo', 'Credit']

輸出：

['about', 'bob', 'Credit', 'Zoo']

def cmp_ignore_case(s1, s2) :
    if s1.lower() > s2.lower() :
        return 1
    if s1.lower() < s2.lower() :
        return -1
    else
        return 0
print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore)

Python中返回函數

Python的函數不但可以返回int、str、list、dict等數據類型，還可以返回函數！
例如，定義一個函數 f()，我們讓它返回一個函數 g，可以這樣寫：

def f():
    print 'call f()...'
    # 定義函數g:
    def g():
        print 'call g()...'
    # 返回函數g:
    return g

仔細觀察上面的函數定義，我們在函數 f 內部又定義了一個函數 g。由於函數 g 也是一個對象，函數名 g 就是指向函數 g 的變量，所以，最外層函數 f 可以返回變量 g，也就是函數 g 本身。
調用函數 f，我們會得到 f 返回的一個函數：

>>> x = f()   # 調用f()
call f()...
>>> x   # 變量x是f()返回的函數：
<function g at 0x1037bf320>
>>> x()   # x指向函數，因此可以調用
call g()...   # 調用x()就是執行g()函數定義的代碼

請注意區分返回函數和返回值：

def myabs():
    return abs   # 返回函數
def myabs2(x):
    return abs(x)   # 返回函數調用的結果，返回值是一個數值

例：編寫一個函數calc_prod(lst)，它接收一個list，返回一個函數，返回函數可以計算參數的乘積。

def calc_prod(list) :
    def lazy_prod() :
        def prod(x, y) :
            return x * y
        return reduce(prod, list)
    return lazy_prod
f = calc_prod([1, 2, 3, 4])
print f()

Python中的閉包

在函數內部定義的函數和外部定義的函數是一樣的，只是他們無法被外部訪問：

def g():
    print 'g()...'

def f():
    print 'f()...'
    return g

將 g 的定義移入函數 f 內部，防止其他代碼調用 g：

def f():
    print 'f()...'
    def g():
        print 'g()...'
    return g

但是，考察上一小節定義的 calc_sum 函數：

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

注意: 發現沒法把 lazy_ sum 移到 calc_ sum 的外部，因爲它引用了 calc_sum 的參數 lst。像這種內層函數引用了外層函數的變量（參數也算變量），然後返回內層函數的情況，稱爲閉包（Closure）。閉包的特點是返回的函數還引用了外層函數的局部變量，所以，要正確使用閉包，就要確保引用的局部變量在函數返回後不能變。舉例如下：

# 希望一次返回3個函數，分別計算1x1,2x2,3x3:
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

你可能認爲調用f1()，f2()和f3()結果應該是1，4，9，但實際結果全部都是 9（請自己動手驗證）。原因就是當count()函數返回了3個函數時，這3個函數所引用的變量 i 的值已經變成了3。由於f1、f2、f3並沒有被調用，所以，此時他們並未計算 i*i，當 f1 被調用時：

>>> f1()
9     # 因爲f1現在才計算i*i，但現在i的值已經變爲3

因此，返回函數不要引用任何循環變量，或者後續會發生變化的變量。

def count() :
    fs = []
    for i in range(1, 4)
        def prod(j)
            def f()
                return j * j
            return prod
        r = f(i)
        fs.append(f(r))
    return fs

Python中的匿名函數

高階函數可以接收函數做參數，有些時候，我們不需要顯式地定義函數，直接傳入匿名函數更方便。在Python中，對匿名函數提供了有限支持。還是以map()函數爲例，計算 f(x)=x2 時，除了定義一個f(x)的函數外，還可以直接傳入匿名函數：

>>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

通過對比可以看出，匿名函數 lambda x: x * x 實際上就是：

def f(x):
    return x * x

關鍵字lambda 表示匿名函數，冒號前面的 x 表示函數參數。
匿名函數有個限制，就是只能有一個表達式，不寫return，返回值就是該表達式的結果。
使用匿名函數，可以不必定義函數名，直接創建一個函數對象，很多時候可以簡化代碼：

>>> sorted([1, 3, 9, 5, 0], lambda x,y: -cmp(x,y))
[9, 5, 3, 1, 0]

返回函數的時候，也可以返回匿名函數：

>>> myabs = lambda x: -x if x < 0 else x 
>>> myabs(-1)
1
>>> myabs(1)
1

函數式編程

函數式編程