Python學習筆記：Python函數語言程式設計

學自廖雪峰巨佬的Python3教程：https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317848428125ae6aa24068b4c50a7e71501ab275d52000

1.我們通過把大段程式碼拆成函式，通過一層一層的函式呼叫，就可以把複雜任務分解成簡單的任務，這種分解可以稱之為面向過程的程式設計。函式就是面向過程的程式設計的基本單元。而函數語言程式設計就是一種抽象程度很高的程式設計正規化，純粹的函數語言程式設計語言編寫的函式沒有變數，因此，任意一個函式，只要輸入是確定的，輸出就是確定的，這種純函式我們稱之為沒有副作用。而允許使用變數的程式設計語言，由於函式內部的變數狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函式是有副作用的。

2.高階函式

• map()和reduce()

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

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

由於結果r是一個Iterator，因此需要通過list()函式將整個序列都計算出來並返回一個list()

reduce()把一個函式作用在一個一個序列上，這個函式必須接收兩個引數，reduce把結果和序列的下一個元素做累積計算

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

還可以通過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 str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))
 

 

程式碼如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


def normalize(name):
    return str.upper(str.lower(name)[:1]) + str.lower(name)[1:len(str.lower(name))]


# 測試:
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

程式碼如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import reduce


def prod(L):
    def fn(x, y):
        return x * y

    return reduce(fn, L)


# 測試
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
    print('測試成功!')
else:
    print('測試失敗!')

 程式碼如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import reduce


def str2float(s):
    def char2num(s):
        digit = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
        return digit[s]

    def fn(x, y):
        return x * 10 + y

    s1 = s[:s.index('.')]
    s2 = s[s.index('.') + 1:]

    return reduce(fn, map(char2num, s1)) + reduce(fn, map(char2num, s2)) / pow(10, len(s2))


# 測試
print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
    print('測試成功!')
else:
    print('測試失敗!')

• filter

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

比如只保留序列裡的奇數

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

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

用filter求素數，使用篩法

首先構造一個從3開始的奇數序列，這是一個生成器，並且是一個無限序列：

def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

 然後定義一個篩選函式，這裡使用了lambda表示式，構建了一個閉包：

def _not_divisible(n):
    return lambda x: x % n > 0

最後定義一個生成器，不斷返回下一個素數：

def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一個數
        yield n
        it = filter(_not_divisible(n), it) # 構造新序列

 呼叫primes()生成器，並且設定退出迴圈的條件：

# 列印1000以內的素數:
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

程式碼如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


def is_palindrome(n):
    count = 0
    i = 0

    if 0 < n < 9:
        return True
    else:
        while i < len(str(n)) // 2:
            if str(n)[i] == str(n)[len(str(n)) - 1 - i]:
                count += 1
            i += 1

    return count == len(str(n)) // 2


# 測試:
output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101,
                                                  111, 121, 131, 141, 151, 161, 171, 181, 191]:
    print('測試成功!')
else:
    print('測試失敗!')

• sorted

Python內建的sorted()函式用於對list進行排序，預設順序從小到大，還可以接收一個key函式來實現自定義的排序，例如按絕對值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

key指定的函式將作用於list的每一個元素上，並根據key函式返回的結果進行排序

對字串排序則是按照ASCII的大小比較的，如果要實現反向排序，則可以傳入第三個引數reverse=True

程式碼如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]


def by_name(t):
    return t[0]


L2 = sorted(L, key=by_name)
print(L2)


def by_score(t):
    return -t[1]


L2 = sorted(L, key=by_score)
print(L2)

3.返回函式

• 函式作為返回值

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

實現一個可變引數的求和很簡單，但是，如果不需要立刻求和，而是在後面的程式碼中，根據需要再計算呢？答案就是可以不反悔求和的結果，而是返回求和的函式：

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

 當呼叫lazy_sum()的時候，返回的並不是求和結果，而是求和函式，呼叫函式f的時候，才真正計算求和的結果：

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

在這個例子中，我們在函式lazy_sum中又定義了函式sum，並且，內部函式可以引用外部函式lazy_sum的引數和區域性變數，當lazy_sum返回函式sum時，相關引數和變數都儲存在返回的函式中，這種程式結構稱為閉包。

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

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

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

• 閉包（我可以吐槽一下這個東西真的很毒嗎）

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

f1, f2, f3 = count()

在上面的例子中，每次迴圈，都建立了一個新的函式，然後，把建立的3個函式都返回了。你可能認為呼叫f1(),f2(),f3()結果應該是1，4，9，但實際結果是：

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

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

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

程式碼如下：（這裡引用大佬程式碼= =因為我閉包學的還不夠好嗚嗚）

方法1：使用list在函式內部引用其地址，並改變其值

def createCounter():
    a = [0]
    def counter():
        a[0] += 1
        return a[0]
    return counter

執行分析：

呼叫createCounter，例項化counterA物件，給a賦初值[0]，給counterA的返回值是counter()函式；
print語句內呼叫counterA，開始執行函式counter()，a[0]+=1->a[0]=1，返回a[0]的值給counter()，然後再返回給counterA()，
迴圈5次這個過程。

方法2：利用生成器，完成數值加1

def createCounter():
    def counter():
        n = 1
        while True:
            yield n
            n += 1
    c = counter()  
    def g():
        return next(c)
    return g

執行分析：

呼叫createCounter，例項化counterA物件，內部呼叫counter()並例項化c物件，返回值為函式g；

print語句內呼叫CounterA，獲取返回值為函式g，呼叫函式g，獲取返回值為next(c)，呼叫函式counter()，生成器返回值1，n+=1，迴圈5次這個過程。

理解容易實現難啊！

4.匿名函式

當傳入函式時，有些時候，不需要顯式的定義函式，直接傳入匿名函式更方便。

以map()函式為例，計算f(x)=x^2，關鍵字lambda表示匿名函式，冒號前的x表示函式引數

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

匿名函式有個限制，就是隻能有一個表示式，不用寫return。此外，匿名函式也是一個函式物件，也可以把匿名函式賦值給一個變數，再利用變數來呼叫該函式。

程式碼如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


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


# L = list(filter(is_odd, range(1, 20)))

L = list(filter(lambda x: x % 2 != 0, range(1, 20)))

print(L)

5.裝飾器

由於函式也是一個物件，而且函式物件可以被複制給變數，所以通過變數也能呼叫該函式。
函式物件有一個__name__屬性，可以拿到函式的名字：

>>> def now():
...     print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25
>>> 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
def now():
    print('2015-3-25')

相當於執行了語句

now = log(now)

呼叫now()函式時，相當於現在指向了新的函式，即在log()函式中返回的wrapper()函式，wrapper()函式的引數定義是(*args,**kw)，因此，wrapper()函式可以接受任意引數的呼叫，在wrapper函式內，首先列印日誌，再緊接著在return處呼叫原始函式。

如果修飾器本身需要傳入引數，那就需要編寫一個返回修飾器的高階函式。比如要自定義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


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

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

>>>print(now.__name__)
wrapper

首先執行now函式的時候，就會先執行log('execute')，傳入引數為text='execute'，返回的是decorator函式，再呼叫返回的decorator函式，返回的是wrapper函式，再呼叫返回的wrapper函式，列印傳入的text和函式名，然後呼叫now函式本身，輸出日期。

但是看經過decorator裝飾之後的函式，它的__name__已經從原來的now變成了wrapper，因為返回的那個wrapper()函式名字就是wrapper，所以需要把原始函式的__name__等屬性複製到wrapper()函式中，否則有些依賴函式簽名的程式碼執行就會出錯。Python內建的functools.wraps就是幹這個的，所以一個完整的decorator寫法如下

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

def metric(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kw):
        t1 = time.time()
        fx = fn(*args, **kw)
        t2 = time.time()
        print('%s executed in %s ms' % (fn.__name__, t2 - t1))
        return fx

    return wrapper

程式碼如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


def begin_call(func):
    def wrapper(*args, **kw):
        print("begin")
        x = func(*args, **kw)
        print("end")

    return wrapper

def log(func):
    def wrapper(*args,**kw):
        print("xxxxxxxxxx")
        return func(*args,**kw)
    return wrapper


def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print(text)
            return func(*args, **kw)
        return wrapper
    return decorator


@log('love')
def one_plus(x):
    print(x + 1)


one_plus(1)

6.偏函式

Python的偏函式和數學意義上的不一樣，在介紹函式引數的時候，通過設定引數的預設值，可以降低函式呼叫的難度，而偏函式也可以做到這一點。

假設要轉換大量的二進位制字串，每次都傳入Int(x,base=2)非常麻煩，因此可以定義一個int2()的函式，預設把base=2傳進去：

def int2(x, base=2):
    return int(x, base)

而使用functools.partial就是幫助我們建立偏函式的，不需要自己定義int2()，可以直接使用下面的程式碼建立一個新的函式int2：

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

創建出來的偏函式也是可以傳入其他值的