函數式：一種編程範式

純函數式編程：沒有變量，支持高階函數編程

Python不是純函數式編程語言，支持高階函數編程

變量可以指向函數，函數名就是指向函數的一個變量，與普通變量沒有區別

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

map()：是 Python 內置的高階函數，它接收一個函數 f 和一個 list，並通過把函數 f 依次作用在 list 的每個元素上，得到一個新的 list 並返回。

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

輸出結果：

[1, 4, 9, 10, 25, 36, 49, 64, 81]

reduce()函數：接收的參數和 map()類似，一個函數 f，一個list，但行為和 map()不同，reduce()傳入的函數 f 必須接收兩個參數，reduce()對list的每個元素反復調用函數f，並返

回最終結果值。reduce()還可以接收第3個可選參數，作為計算的初始值。

#對list求積
def prod(x, y):
    return x*y

print reduce(prod, [2, 4, 5, 7, 12])

filter()函數：是 Python 內置的另一個有用的高階函數，filter()函數接收一個函數 f 和一個list，這個函數 f 的作用是對每個元素進行判斷，返回 True或 False，filter()根據判斷結果

自動過濾掉不符合條件的元素，返回由符合條件元素組成的新list。

#篩選出平方根不是整數的數

import math

def is_sqr(x):
    r = int(math.sqrt(x))
    return r*r==x

print filter(is_sqr, range(1, 101))

sorted()函數：它可以接收一個比較函數來實現自定義排序，比較函數的定義是，傳入兩個待比較的元素 x, y，如果 x 應該排在 y 的前面，返回 -1，如果 x 應該排在 y 的後面，

返回 1。如果 x 和 y 相等，返回 0。

#利用sorted()高階函數，實現忽略大小寫排序的算法。
 

def cmp_ignore_case(s1, s2):
    u1=s1.lower()
    u2=s2.lower()
    if u1<u2:
        return -1
    if u1>u2:
        return 1
    return 0

print sorted([‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘], cmp_ignore_case)

返回函數：

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

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

例子：

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

def calc_prod(lst):
    def func():
        sum=1
        for x in lst:
            sum = sum * x
            print sum,‘\n‘
        return sum
    return func

f = calc_prod([1, 2, 3, 4])
print f()

閉包：像這種內層函數引用了外層函數的變量（參數也算變量），然後返回內層函數的情況，稱為閉包（Closure）。

返回函數不要引用任何循環變量，或者後續會發生變化的變量，這樣會導致引用返回函數時結果發生改變。

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r = f(i)
        fs.append(r)
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()

匿名函數：關鍵字lambda 表示匿名函數，冒號前面的 x 表示函數參數。只能有一個表達式，不寫return，返回值就是該表達式的結果。

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

裝飾器：利用高階函數返回函數

定義裝飾器

def log(f):
    def fn(*args, **kw):
        print ‘call ‘ + f.__name__ + ‘()...‘
        return f(*args, **kw)
    return fn

調用裝飾器

@log
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

運行結果

call factorial()...
3628800

帶參數的裝飾器

def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print ‘[%s] %s()...‘ % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator

@log(‘DEBUG‘)
def test():
    pass
print test()

decorator返回的新函數函數名已經不是原函數名，而是decorator內部定義的函數名。這對於那些依賴函數名的代碼就會失效。因此需要用到Python內部的functools來復制原函數信息到包裝之後的函數。

import time, functools

def performance(unit):
    def func(f):
        @functools.wraps(f)
        def wrapper(*args,**kw):
            t1=time.time()
            n=f(*args,**kw)
            t2=time.time()
            t = (t2 - t1) * 1000 if unit==‘ms‘ else (t2 - t1)
            print ‘call %s() in %f %s‘ % (f.__name__, t, unit)
            return r
        return wrapper
    return func

@performance(‘ms‘)
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial.__name__

偏函數：functools.partial就是幫助我們創建一個偏函數的，functools.partial可以把一個參數多的函數變成一個參數少的新函數，少的參數需要在創建時指定默認值，這樣，新函數調用的難度就降低了。

import functools

sorted_ignore_case = functools.partial(sorted, cmp=lambda s1, s2: cmp(s1.upper(), s2.upper()))

print sorted_ignore_case([‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘])

高階函數和裝飾器