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

• 函數式編程就是一種抽象程度很高的編程範式。（Python容許使用變量，不是純函數式編程語言）
• 函數式編程的特色：函數能夠賦給變量，因此，可做爲參數傳遞，可做爲返回值返回。

 

 一個最簡單的高階函數：

1 def add(x, y, f):
2     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

1 def sum_(lst):
2     amount = 0
3     for num in lst:
4         amount = add(amount, num)
5     return amount
6  
7 print sum_(lst)

 

1 def sum_(lst):
2     amount = 0
3     for num in lst:
4         amount = add(amount, num)
5     return amount
6  
7 print sum_(lst)

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

1  def multiply(lst):
2  　　product = 1
3  　　for num in lst:
4  　　　　product = product * num
5 　　 return product

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

1 def reduce_(function, lst, initial):
2     result = initial
3     for num in lst:
4         result = function(result, num)
5     return result

如今，想要算乘積：

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

 

• 返回閉包
  

閉包是一類特殊的函數。若是一個函數定義在另外一個函數的做用域中，而且函數中引用了外部函數的局部變量，那麼這個函數就是一個閉包。

可變參數的求和：

1 def calc_sum(*args):
2     ax = 0
3     for n in args:
4         ax = ax + n
5     return ax

返回求和的函數：

1 def lazy_sum(*args):
2     def sum():
3         ax = 0
4         for n in args:
5             ax = ax + n
6         return ax
7     return sum

調用lazy_sum()時，返回的並非求和結果，而是求和函數

1 >>> f = lazy_sum(1, 3, 5, 7, 9)
2 >>> f
3 <function sum at 0x10452f668>
4 >>> f()
5 25

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

 

須要注意的問題是，返回的函數並無馬上執行，而是直到調用了 f() 才執行。咱們來看一個例子：

1 def count():
2     fs = []
3     for i in range(1, 4):
4         def f():
5              return i*i
6         fs.append(f)
7     return fs
8 
9 f1, f2, f3 = count()

1 >>> f1()
2 9
3 >>> f2()
4 9
5 >>> f3()
6 9

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

 若是必定要引用循環變量怎麼辦？方法是再建立一個函數

 1 >>> def count():
 2 ...     fs = []
 3 ...     for i in range(1, 4):
 4 ...         def f(j):
 5 ...             def g():
 6 ...                 return j*j
 7 ...             return g
 8 ...         fs.append(f(i))
 9 ...     return fs