Python進階之[非局部變量，閉包，裝飾器]

閱讀Tacotron2源碼 之 Python進階

1. Non-Local Variable with Nested Function
2. Closure in Python
3. Decorator

---

---

---

1. Non-Local Variable with Nested Function

    在Python中，除了全局變量(Global Variable)和局部變量(Local Variable)以外，還有一種變量叫Non-Local Variable。

    Non-Local Variable的存在來源於python容許Nested Function的存在。C/C++中，結構體(類)裏面再定義結構體(類)能夠作到，可是函數裏面再定義函數則不被容許。Python能夠實現嵌套函數的緣由在於Everything in Python is Object，寫嵌套函數的初心無非是外層函數想要利用內層函數的返回值。

    可有可無，python三種變量都是相對的概念，全局變量好理解，就不寫了，主要是Local Variable和Non-Local Variable如何區別。直接看一組代碼就能明白：

# Version 1
def outer():
    y = 40
    def inner():
        nonlocal y
        print("before modified :", y)
        y = 50
        print("after modified  :", y)
    inner()
    print("outer:", y)
outer()

>>>before modified : 40
>>>after modified  : 50
>>>outer: 50

    這是一個典型的Nested Funtion(嵌套函數)，inner()函數嵌套在outer()函數的內部。對於outer()函數來講，y就是它的Local Variable；對於inner()函數來講，有了nonlocal關鍵字，y就是它的Non-Local Variable。

    此時，你可能會認爲Non-Local Variable是用nonlocal關鍵字定義的，其實否則，沒有這個關鍵字，它也是Non-Local Variable。請看下面一組代碼：

# Version 2
def outer():
    y = 40
    def inner():
        # nonlocal y
        print("before modified :", y)
        # y = 50
        # print("after modified  :", y)
    inner()
    print("outer:", y)
outer()
>>>before modified : 40
>>>outer: 40

    仔細觀察，我只是註釋了部分的代碼，此時inner()函數訪問(調用)了變量y，此時對於inner()函數來講，y仍然是它的Non-Local Variable。

    那麼如今一個明顯的問題就是，既然Non-Local Variable不依賴於nonlocal關鍵字來定義，那這個關鍵字存在的意義是什麼？繼續看下面的代碼：

# Version 3
def outer():
    y = 40
    def inner():
        # nonlocal y
        print("before modified :", y)
        y = 50
        print("after modified  :", y)
    inner()
    print("outer:", y)
outer()
>>>Error

    上面Version 3代碼只是註釋掉了Version 1中的關鍵字部分，然而運行倒是報錯的。而後你在看看Version 2和Version 3的區別，就會發現，Version 3試圖在沒有關鍵字nonlocal的聲明前提下去修改Non-Local Variable，因此它報錯了。

總結一下

    Non-Local Variable依賴於嵌套函數中存在，而且有兩種定義方式——顯式定義和隱式定義。顯示定義要用nonlocal關鍵字聲明，此時內部函數不只能夠訪問還能夠修改Non-Local Variable；隱式定義無須聲明，可是此時內部函數只有訪問而沒有修改Non-Local Variable的權利。

---

2. Python Closure

    Closure(閉包)，這個概念與上面的Non-Local Variable同樣，它依賴於Nested Function而存在。一句話說什麼是Closure：

外部函數返回內部函數的嵌套函數，就叫閉包。

    觀察上面代碼，發現外部函數outer()只是調用了內部函數inner()，而並無將其return出來，因此這個嵌套函數不是閉包。下面是一個閉包的例子：

def print_msg(msg):
    def printer():
        print(msg)
    return printer

another = print_msg("Hello")
another()
>>>"Hello"

    由於Everything in Python is Object，因此函數的返回值是另外一個函數徹底沒問題。

    閉包的概念就是這麼簡潔，用法在下面：

del print_msg
another()
>>>Hello


print_msg("Hello")
>>>Traceback (most recent call last):
>>>...
>>>NameError: name 'print_msg' is not defined

    也很好懂，咱們已經把外部函數print_msg()殺死了，可是內部函數printer()卻活了下來，由於在殺死print_msg()以前，another = print_msg("Hello")，至關於another()繼承了內部函數的地址，因此它仍然存在着。

總結一下：

何時須要用到Closure？

1. 必需要寫嵌套函數的時候
2. 嵌套函數的內部函數須要訪問非局部變量的時候
3. 外部函數須要將內部函數做爲返回值

其實我感受說了跟沒說同樣。。。目前以爲閉包就是用在下面要說的裝飾器中。

---

3. Decorator

    Decorator來源於現實需求，現有的代碼功能有短缺，須要添加新功能，可是我想在不大刀改動原有代碼的前提下，添加新功能而且新寫完的代碼具備向後兼容性。

    直接用例子說明：

# Version 1
# 階乘函數
def count(number):
    mul = 1
    for item in range(1, number):
        mul *= item
    print(mul)

def cost(func, number):
    start = time.time()
    func(number)
    end = time.time()
    cost_time = end - start
    return cost_time
    
time = cost(count, 6)
print(time)
>>>6
>>>1s

    上面代碼的需求是要計算階乘函數耗費的時間，一個很直觀的想法就是把階乘函數做爲參數傳給cost()函數，這樣運行cost()函數便可。這個作法能夠可是並不完美，下面看看裝飾器怎麼作：

# Version 2
# 這是一個Closure
def cost(func):
    def _measure_time(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs)
        elapse = time.time() - start
        print("takes {} seconds.".format(elapse))
    return _measure_time

@cost
def count(number):
    mul = 1
    for item in range(number):
        mul *= item
    print(mul)

count(4)
>>>6
>>>takes 1 seconds.

    Version 2就是一個裝飾器，它沒有改動原始的階乘函數，只是新寫了一個閉包cost，而且在階乘函數頭上添加了@cost，使用的時候，發現只運行count()函數，還輸出了消耗的時間，這就叫代碼的向後兼容性。

    再仔細看一下閉包的寫法，用到了兩種參數*args, **kwargs，這樣，不管要裝飾或者稱爲包起來的函數func()須要什麼類型的參數,閉包均可以兼容。

    再提一句，Decorator能夠疊加，以下：

def star(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner

def percent(func):
    def inner(*args, **kwargs):
        print("%" * 30)
        func(*args, **kwargs)
        print("%" * 30)
    return inner

@star
@percent
def printer(msg):
    print(msg)
printer("Hello")

>>>
******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Hello
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************

    觀察輸出，又能夠對閉包和裝飾器有一個直觀的理解。

總結一下：

    裝飾器就是在代碼中不多改動的前提條件下，添加新功能，而且新寫完的代碼具備向後兼容性。