函數語言程式設計就是一種抽象程度很高的程式設計正規化，純粹的函數語言程式設計語言編寫的函式沒有變數，因此，任意一個函式，只要輸入是確定的，輸出就是確定的，這種純函式我們稱之為沒有副作用。而允許使用變數的程式設計語言，由於函式內部的變數狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函式是有副作用的。

函數語言程式設計的一個特點就是，允許把函式本身作為引數傳入另一個函式，還允許返回一個函式！

Python對函數語言程式設計提供部分支援。由於Python允許使用變數，因此，Python不是純函數語言程式設計語言。

返回函式

函式可以把函式作為返回值返回，如果不需要立刻求和，而是在後面的程式碼中，以不返回求和的結果，而是返回求和的函式：

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

呼叫lazy_sum()時，返回的並不是求和結果，而是求和函式：

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>

呼叫函式f時，才真正計算求和的結果：

>>> f()
25

上面這種形式稱為閉包。

呼叫lazy_sum()時，每次呼叫都會返回一個新的函式，即使傳入相同的引數：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

f1()和f2()的呼叫結果互不影響。

閉包

返回的函式在其定義內部引用了局部變數 args，所以，當一個函式返回了一個函式後，其內部的區域性變數還被新函式引用。

閉包用起來簡單，實現起來可不容易。

錯誤示範

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，但實際結果是：

>>> f1()
9
>>> f2()
9
>>> f3()
9

全部都是9！原因就在於返回的函式引用了變數i，但它並非立刻執行。等到3個函式都返回時，它們所引用的變數i已經變成了3，因此最終結果為9。

返回閉包時牢記的一點就是：返回函式不要引用任何迴圈變數，或者後續會發生變化的變數。

如果一定要引用迴圈變數怎麼辦？方法是再建立一個函式，用該函式的引數繫結迴圈變數當前的值，無論該迴圈變數後續如何更改，已繫結到函式引數的值不變：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被執行，因此i的當前值被傳入f()
    return fs

匿名函式 lambda

傳入函式時，有些時候，直接傳入匿名函式更方便。

匿名函式lambda x: x * x實際上就是：

def f(x):
  return x * x

關鍵字lambda表示匿名函式，冒號前面的x表示函式引數。

匿名函式有個限制，就是隻能有一個表示式，不用寫return，返回值就是該表示式的結果。

用匿名函式有個好處，因為函式沒有名字，不必擔心函式名衝突。此外，匿名函式也是一個函式物件，也可以把匿名函式賦值給一個變數，再利用變數來呼叫該函式：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

同樣，也可以把匿名函式作為返回值返回，比如：

def build(x, y):
  return lambda: x * x + y * y

裝飾器

函式也是一個物件，而且函式物件可以被賦值給變數，所以，通過變數也能呼叫該函式。

>>> def now():
... print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25

函式物件有一個__name__屬性，可以拿到函式的名字：

>>> now.__name__
'now'
>>> f.__name__
'now'

假設我們要增強now()函式的功能，比如，在函式呼叫前後自動列印日誌，但又不希望修改now()函式的定義，這種在程式碼執行期間動態增加功能的方式，稱之為“裝飾器”（Decorator）。

Decorator就是一個返回函式的高階函式。可以定義如下：

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

觀察上面的log，因為它是一個decorator，所以接受一個函式作為引數，並返回一個函式。我們要藉助Python的@語法，把decorator置於函式的定義處：

@log
def now():
    print('2015-3-25')

呼叫now()函式，不僅會執行now()函式本身，還會在執行now()函式前列印一行日誌：

>>> now()
call now():
2015-3-25

把@log放到now()函式的定義處，相當於執行了語句：

now = log(now)

如果decorator本身需要傳入引數，那就需要編寫一個返回decorator的高階函式，寫出來會更復雜。比如，要自定義log的文字：

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

這個3層巢狀的decorator用法如下：

@log('execute')
def now():
    print('2015-3-25')

相當於

now = log('execute')(now)

裝飾器會改變 函式__name__屬性
Python內建的functools.wraps 可以解決這個問題，只需記住在定義wrapper()的前面加上@functools.wraps(func)即可。

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

偏函式

當函式的引數個數太多，需要簡化時，使用functools.partial可以建立一個新的函式，這個新函式可以固定住原函式的部分引數，從而在呼叫時更簡單。

例如
int()函式可以把字串轉換為整數，當僅傳入字串時，int()函式預設按十進位制轉換，如果傳入base引數，就可以做N進位制的轉換：

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

要轉換大量的二進位制字串，每次都傳入int(x, base=2)非常麻煩
簡化程式碼

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

建立偏函式時，實際上可以接收函式物件、*args和**kw這3個引數

int2 = functools.partial(int, base=2)
int2('10010')

相當於

kw = { 'base': 2 }
int('10010', **kw)

當傳入：

max2 = functools.partial(max, 10)

實際上會把10作為*args的一部分自動加到左邊，也就是：

max2(5, 6, 7)

相當於：

args = (10, 5, 6, 7)
max(*args)