Python學習之函數語言程式設計

stonezhu發表於2018-06-16
Python函數程式設計

Python學習目錄

  1. 在Mac下使用Python3
  2. Python學習之資料型別
  3. Python學習之函式
  4. Python學習之高階特性
  5. Python學習之函數語言程式設計
  6. Python學習之模組
  7. Python學習之物件導向程式設計
  8. Python學習之物件導向高階程式設計
  9. Python學習之錯誤除錯和測試
  10. Python學習之IO程式設計
  11. Python學習之程式和執行緒
  12. Python學習之正則
  13. Python學習之常用模組
  14. Python學習之網路程式設計

練習程式碼

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

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

函式是Python內建支援的一種封裝，我們通過把大段程式碼拆成函式，通過一層一層的函式呼叫，就可以把複雜任務分解成簡單的任務，這種分解可以稱之為程式導向的程式設計。函式就是程式導向的程式設計的基本單元。

​而函數語言程式設計（請注意多了一個“式”字）——Functional Programming，雖然也可以歸結到程式導向的程式設計，但其思想更接近數學計算。

我們首先要搞明白計算機（Computer）和計算（Compute）的概念。在計算機的層次上，CPU執行的是加減乘除的指令程式碼，以及各種條件判斷和跳轉指令，所以，組合語言是最貼近計算機的語言。而計算則指數學意義上的計算，越是抽象的計算，離計算機硬體越遠。對應到程式語言，就是越低階的語言，越貼近計算機，抽象程度低，執行效率高，比如C語言；越高階的語言，越貼近計算，抽象程度高，執行效率低，比如Lisp語言。

高階函式

在python中函式名是指向函式的變數，當函式的引數也是函式的時候，這種函式我們稱之為高階函式。

def add(x, y, f):
    return f(x) + f(y)
add(1, -6, abs)
複製程式碼

map/reduce

map()函式接收兩個引數，一個是函式，一個是Iterable，map將傳入的函式依次作用到序列的每個元素，並把結果作為新的Iterator返回。

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

>>> [1, 4, 9, 16, 25, 36, 49, 64, 81]
複製程式碼

reduce把一個函式作用在一個序列[x1, x2, x3, ...]上，這個函式必須接收兩個引數，reduce把結果繼續和序列的下一個元素做累積計算，效果如下:

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
複製程式碼

結合map和reduce可以整理出一個str2int的函式:

from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def char2num(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))
複製程式碼

filter

Python內建的filter()函式用於過濾序列。

和map()類似，filter()也接收一個函式和一個序列。和map()不同的是，filter()把傳入的函式依次作用於每個元素，然後根據返回值是True還是False決定保留還是丟棄該元素。

例如，在一個list中，刪掉偶數，只保留奇數，可以這麼寫：

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 結果: [1, 5, 9, 15]
複製程式碼

sorted

對list進行排序：

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
複製程式碼

此外，sorted()函式也是一個高階函式，它還可以接收一個key函式來實現自定義的排序，例如按絕對值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
複製程式碼

字串排序:

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
複製程式碼

忽略大小寫:

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
複製程式碼

要進行反向排序，不必改動key函式，可以傳入第三個引數reverse=True

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']
複製程式碼

返回函式

定義

高階函式除了可以接受函式作為引數外，還可以把函式作為結果值返回。

我們來實現一個可變引數的求和。通常情況下，求和的函式是這樣定義的：

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 lazy_sum.<locals>.sum at 0x101c6ed90>
複製程式碼

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

>>> f()
25
複製程式碼

閉包

如上所示的例子中，我們在函式lazy_sum中又定義了函式sum，並且，內部函式sum可以引用外部函式lazy_sum的引數和區域性變數，當lazy_sum返回函式sum時，相關引數和變數都儲存在返回的函式中，這種稱為“閉包（Closure）”。

注意點：返回函式不要引用任何迴圈變數，或者後續會發生變化的變數。

如下所示：

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
複製程式碼

匿名函式

關鍵字lambda表示匿名函式，冒號前面的x表示函式引數。匿名函式有個限制，就是隻能有一個表示式，不用寫return，返回值就是該表示式的結果。

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

裝飾器

程式碼執行期間動態增加功能的方式，稱之為“裝飾器”（Decorator）。本質上，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()
call now():
2015-3-25
複製程式碼

把@log放到now()函式的定義處，相當於執行了語句：now = log(now),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()
execute now():
2015-3-25
複製程式碼

和兩層巢狀的decorator相比，3層巢狀的效果是這樣的：>>> now = log('execute')(now)

有個問題，經過decorator裝飾之後的函式，它們的__name__已經從原來的'now'變成了'wrapper'：

>>> now.__name__
'wrapper'
複製程式碼

Python內建的functools.wraps用來複制函式_name_屬性的：

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
複製程式碼

或者針對帶引數的裝飾器：

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
複製程式碼

偏函式

Python的functools模組提供了很多有用的功能，其中一個就是偏函式（Partial function）。把一個函式的某些引數給固定住（也就是設定預設值），返回一個新的函式，呼叫這個新函式會更簡單。

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

比如要使用int()函式去轉換二進位制字串，原本的寫法是：int(x, base=2)，如果量大的話，很麻煩，所以我們可以這麼寫：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85
複製程式碼

上面的in2 = functools.partial(int, base=2)相當於：

kw = { 'base': 2 }
int('10010', **kw)
複製程式碼

下一篇：Python學習之模組

相關文章