我與python約個會：19. 再說函數~那些不得不知道的事兒

前面的課程中，我們已經對函數有了簡單的瞭解
函數的聲明、函數的的調用、函數的參數以及返回值等等

本節內容主要對函數中的一些高級操作進行講解，方便大家在項目操作過程中對函數的操作更加靈活一些

• 函數遞歸
• 函數變量賦值
• 參數中的函數
• 匿名函數
• 返回值中的函數:閉包
• 偏函數
• 裝飾器

1. 函數遞歸

函數的遞歸，就是讓在函數的內部調用函數自身的情況，這個函數就是遞歸函數。
遞歸函數其實是另外一種意義的循環
如：計算一個數字的階乘操作，將這個功能封裝成函數fact(num)
提示：階乘算法是按照小於等於當前數字的自然數進行乘法運算
計算5的階乘：5 X 4 X 3 X 2 X1
計算n的階乘：n X (n - 1) X ... X 3 X 2 X 1

# 定義一個遞歸函數
def fact(num):
    if n == 1:
        return n
    return n * fact(n - 1)
# 執行函數
>>> fact(1)
1
>>> fact(2)
2
>>> fact(3)
6
>>> fact(4)
24
>>> fact(5)
120
>>> fact(9)
362880

遞歸操作，整個計算過程如下
計算5的階乘：fact(5)
fact(5)
->5 X fact(5 - 1)
->5 X (4 X fact(4 - 1))
->5 X (4 X (3 X fact(3 - 1)))
->5 X (4 X (3 X (2 X fact(2 - 1)))))
=>5 X (4 X (3 X (2 X 1)))
=>5 X (4 X (3 X 2))
=>5 X (4 X 6)
=>5 X 24
=>120

我們在之前說過，遞歸就是另外一種特殊的循環：函數級別的循環
所以遞歸函數也可以使用循環來進行實現
但是循環的實現思路沒有遞歸清晰。

使用遞歸函數時一定需要注意：遞歸函數如果一旦執行的層數過多就會導致內存溢出程序崩潰。

有一種做法是將遞歸函數的返回值中，不要添加表達式，而是直接返回一個函數，這樣的做法旨在進行尾遞歸優化，大家如果有興趣的話可以上網自行查詢一下；由於不同的解釋器對於函數遞歸執行的不同的處理，所以遞歸的使用請慎重分析和操作。

2. 函數變量賦值

函數，是一種操作行爲
函數名稱，其實是這種操作行爲賦值的變量
調用函數，其實是通過這個賦值的變量加上一堆圓括號來進行函數的執行

# 定義了一個函數，函數命名爲printMsg
def printMsg (msg):
    print("you say :" + msg)
# 通過變量printMsg來進行函數的調用
printMsg("my name is jerry!")

既然函數名稱只是一個變量，變量中存放了這樣的一個函數對象
我們就可以將函數賦值給另一個變量

# 將函數賦值給變量pm
pm = printMsg;
# 就可以通過pm來進行函數的執行了
pm(" my name is tom!")

3. 參數中的函數

函數作爲一個對象，我們同樣可以將函數當成一個實際參數傳遞給另一個函數進行處理

# 系統內置求絕對值函數abs()，賦值給變量f
f = abs;
# 定義一個函數，用於獲取兩個數據絕對值的和
def absSum(num1, num2, fn):
    return fn(num1) + fn(num2)
# 調用執行函數
res = absSum(-3, 3, f)
# 執行結果
~ 6

函數作爲參數進行傳遞，極大程度的擴展了函數的功能，在實際操作過程中有非常廣泛的應用。

4. 匿名函數

在一個函數的參數中，需要另一個函數作爲參數進行執行：

def printMsg(name, fn):
    print(name)
    fn()

常規做法是我們定義好自己的函數，然後將函數名稱傳遞給參數進行調用

def f():
    print("日誌記錄：函數執行完成")
printMsg("jerry", f)

重點在這裏

我們通過如下的方式來調用函數

printName("tom", lambda:print("函數執行完成..."))
# 執行結果
tom
函數執行完成

在printName函數調用時，需要一個函數作爲參數的地方，出現了lambda這樣一個詞彙和後面緊跟的語句

lambda是一種表達式，一種通過表達式來實現簡單函數操作的形式，lambda表達式可以看成是一種匿名函數
常規的lambda表達式的語法結構是

lambda 參數列表：執行代碼

如下面這樣的lambda表達式

lambda x, y: x * y
# 就是定義了類似如下的代碼：
def test(x, y):
    x * y

lambda表達式已經在後端開發的各種語言中出現了，以其簡潔的風格和靈活的操作風靡一時，但是需要注意，lambda表達式簡化了簡單函數的定義，但是同時也降低了代碼的可讀性
所以這樣的lambda表達式，可以使用，但是要慎重使用，切記不能濫用，否則造成非常嚴重的後果：你的代碼由於極差的可讀性就會變成一次性的！

5. 返回值中的函數：閉包

函數作爲對象，同樣也可以出現在返回值中，其實就是在函數中又定義了另外的函數
在一個函數中定義並使用其他的函數，這樣的方式在不同的編程語言中有不同的管理方式，在Python中，這樣的方式也成爲閉包。

# 在一個函數outerFn中定義了一個函數innerFn
def outerFn():
    x = 12;
    def innerFn():
        x = x *12
    return innerFn;
# 執行函數
f = outerFn();
f()
# 執行結果：144

# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 什麼是閉包，閉包就是在函數A中添加定義了另一個函數B
# 最後將函數B返回，通過函數B就可以直接使用局部變量，擴大了局部變量的作用域
# 
# 爲什麼要使用閉包，閉包就是爲了再多人協同開發項目過程中，同時會有多個人寫多
# 個python文件並且要互相引入去使用，此時如果不同的開發人員定義的全局變量出現
# 名稱相同，就會出現變量值覆蓋引起的數據污染，也稱爲變量的全局污染。爲了避免
# 出現這樣的情況，我們通常通過閉包來管理當前文件中變量的使用。
#
# 怎麼使用閉包，閉包函數中可以定義其他的任意多個變量和函數，在閉包函數執行的
# 時候這些函數都會執行，也就是將函數的執行從程序加載執行->遷移->閉包函數執行的
# 過程
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

6. 偏函數

常規函數操作中，我們在函數的參數中可以添加參數的默認值來簡化函數的操作，偏函數也可以做到這一點，偏函數可以在一定程度上更加方便的管理我們的函數操作
偏函數通過內置模塊functools的partial（）函數進行定義和處理

如之前我們學習過的一個類型轉換函數int(str)，用於將一個字符串類型的數字轉換成整數，同樣的，可以在類型轉換函數中指定將一個字符串類型的數字按照指定的進制的方式進行轉換

# 將一個字符串類型的123轉換成整數類型的123
int("123")  # 123
# 將一個字符串12按照16進制轉換成十進制的整數
int("12", base=16)  # 18
# 將一個字符串17按照8進制轉換成十進制的整數
int("17", base=8)  15
# 將一個字符串1110按照2進制轉換成十進制的整數
int("1110", base=2) 14

# 注意：上述要轉換的字符串的整數必須滿足對應的進制，否則會轉換報錯
# 按照八進制轉換，但是要轉換的字符串中的數字不是8進制數字
int("9", base=8)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 8: '9'
# 按照2進制轉換，但是要轉換的字符串不是2進制數字
int("3", base=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 2: '3'

上述這樣的操作方式，通過一個命名關鍵字參數base的方式來指定轉換進制，可讀性較好，但是操作起來稍顯繁瑣，我們可以通過functools的partial()函數進行改造如下：

# functools.partial()函數語法結構
新函數名稱 = functools.partial(函數名稱, 默認賦值參數)

通過對指定的函數進行參數的默認賦值，然後將這樣的一個新的函數保存在變量中，通過這個新函數就可以執行更加簡潔的操作了

# 原始的2進制數據轉換
int("111", base=2)
~執行結果：7
# 引入我們需要的模塊functools
import functools
# 通過偏函數擴展一個新的函數int2
int2 = functools.partial(int, base=2)
# 使用新的函數，新的函數等價於上面的int("111", base=2)
int2("111")
~執行結果：7

系統內置函數可以通過上述的形式進行封裝，那麼我們自定義函數是否也可以封裝呢

# 定義一個函數，可以根據用戶輸入的類型來遍歷數據
def showData(data, *, type=1):
    if type == 1:     #打印字符串
        print(data)
    elif type ==2:   # 遍歷列表、元組、集合
        for x in data:
            print(x)
    elif type == 3: # 遍歷字典
        for k, v in data.items():
            print(k, v)
# 打印字符串
showData("hello functools partial");
# 打印列表
showData([1,2,3,4,5], type=2)
# 打印元組
showData((1,2,3,4,5), type=2)
# 打印集合
showData({1,2,3,4,5}, type=2)
# 打印字典
showData({"1":"a", "2":"b", "3":"c"}, type=3)

# 使用偏函數進行改造
import functools
showString = functools.partial(showData, type=1)
showList = functools.partial(showData, type = 2)
showDict = functools.partial(showData, type = 3)
# 打印字符串
showString ("hello functools partial");
# 打印列表
showList ([1,2,3,4,5])
# 打印元組
showList ((1,2,3,4,5))
# 打印集合
showList ({1,2,3,4,5})
# 打印字典
showDict ({"1":"a", "2":"b", "3":"c"})
# * * * * * * * * * * * * * * * * * * * * * *
# 整個世界，清淨了...
# * * * * * * * * * * * * * * * * * * * * * *

7. 裝飾器函數處理

裝飾器是在不修改函數本身的代碼的情況下，對函數的功能進行擴展的一個手段

裝飾器，整個名詞是從現實生活中抽象出來的一個概念
所謂裝飾，生活中其實就是不改造原來的物體的情況下給物體增加額外的一些功能的手段，比如一個房子蓋好了~但是不喜歡房子現在的牆壁顏色，不喜歡房子原始地板的顏色，就可以通過裝修的形式，給房子額外增加一些裝飾，讓房子更加的豪華溫馨
此時：房子->裝修->額外的樣式

我們定義一個簡單的函數，用於進行數據的遍歷

# 定義一個函數，可以根據用戶輸入的類型來遍歷數據
def showData(data, *, type=1):
    if type == 1:     #打印字符串
        print(data)
    elif type ==2:   # 遍歷列表、元組、集合
        for x in data:
            print(x)
    elif type == 3: # 遍歷字典
        for k, v in data.items():
            print(k, v)

此時，我們想要給這個函數增加額外的功能，在函數執行之前和函數執行後增加額外的日誌的記錄，記錄函數執行的過程，大致功能如下

print("遍歷函數開始執行")
showData("hello my name is showData")
print("遍歷函數執行完成")

這樣的代碼也是能滿足我們的需要的，但是這個函數的調用如果可能出現在很多地方呢？是不是就需要在每次調用的時候都要在函數的前後寫這樣的代碼呢？肯定不太現實

我們通過如下的方式來定義一個函數，包裝我們的showData()函數

# 定義一個包裝函數
def logging(func):
    def wrapper(*args, **kw):
        print("遍歷函數開始執行----")
        res = func(*args, **kw)
        print("遍歷函數執行完成----")
        return res;
    return wrapper
# 在我們原來的函數前面添加一個註解
@logging
def showData(data, *, type=1):
    if type == 1:     #打印字符串
        print(data)
    elif type ==2:   # 遍歷列表、元組、集合
        for x in data:
            print(x)
    elif type == 3: # 遍歷字典
        for k, v in data.items():
            print(k, v)

# 執行函數，我們會發現在函數執行時，出現了額外的添加的功能。
showData("my name is jerry!")
# 執行結果
~ 遍歷函數開始執行----
~ my name is jerry!
~ 遍歷函數執行完成----

裝飾器函數執行的全過程解析
一、定義過程
1.首先定義好了一個我們的功能處理函數showData(data, * , type = 1)
2.然後定了一個功能擴展函數logging(func)，可以接受一個函數作爲參數
3.使用python的語法@符號，給功能處理函數增加一個標記，將@logging 添加到功能處理函數的前面
二、執行過程
1.直接調用執行showData("my name is jerry!")

2.python檢查到函數頂部聲明瞭@logging，將當前函數作爲參數傳遞給 logging()函數，就是首先執行logging(showData)

3.功能處理函數的參數"my name is jerry"，傳遞給功能擴展函數的閉包函數wrapper(*args, **kw)

4.在閉包函數wrapper中，可以通過執行func(*args, **kw)來執行我們的> 功能處理函數showData()，這樣就可以在執行func(*args,**kw)之前和之後添加我們自己需要擴展的功能
[備註：函數中的參數，不論傳遞什麼參數，都可以通過(*args, **kw)來接收，請參考函數參數部分內容]

5.執行過程如下圖所示：

裝飾器函數執行過程圖解