函數式編程--函數和閉包

• 函數式編程就是一種抽象程度很高的編程范式。（Python允許使用變量，不是純函數式編程語言）
• 函數式編程的特點：函數可以賦給變量，所以，可作為參數傳遞，可作為返回值返回。

 

 一個最簡單的高階函數：

def add(x, y, f):
    return f(x) + f(y)

add(-5, 6, abs) , abs 作為參數傳入 add 函數中 ，又作為參數返回

 

•  作為參數

一個列表運算的例子：lst = range(5)

加法:只需 for 循環遍歷 lst ，依次相加，返回 amout

1 amount = 0
2 for num in lst:
3     amount = add(amount, num

def sum_(lst):
    amount = 0
    for num in lst:
        amount = add(amount, num)
    return amount
 
print sum_(lst)

 

def sum_(lst):
    amount = 0
    for num in lst:
        amount = add(amount, num)
    return amount
 
print sum_(lst)

乘法：初始值換成了1以及函數add換成了乘法運算符　　

 def multiply(lst):
 　　product = 1
 　　for num in lst:
 　　　　product = product * num
　　 return product

把這個流程抽象出來，而將加法、乘法或者其他的函數作為參數傳入：

def reduce_(function, lst, initial):
    result = initial
    for num in lst:
        result = function(result, num)
    return result

現在，想要算乘積：

print reduce_(lambda x, y: x * y, lst, 1)

 

• 返回閉包
  

閉包是一類特殊的函數。如果一個函數定義在另一個函數的作用域中，並且函數中引用了外部函數的局部變量，那么這個函數就是一個閉包。

可變參數的求和：

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

返回求和的函數：

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 sum at 0x10452f668>
>>> f()
25

在函數lazy_sum中又定義了函數sum，並且，內部函數sum可以引用外部函數lazy_sum的參數和局部變量，當lazy_sum返回函數sum時，相關參數和變量都保存在返回的函數中，稱為閉包

 

需要注意的問題是，返回的函數並沒有立刻執行，而是直到調用了 f() 才執行。我們來看一個例子：

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

f1, f2, f3 = count()

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

 返回閉包時牢記的一點就是：返回函數不要引用任何循環變量，或者后續會發生變化的變量。

 如果一定要引用循環變量怎么辦？方法是再創建一個函數

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