裝飾器函數

裝飾器函數

開發封閉原則（先從別人偷來一波好文章，簡單易懂）

  什麼是開放封閉原則？有的同窗問開放，封閉這是兩個反義詞這還能組成一個原則麼？這不先後矛盾麼？其實不矛盾。開放封閉原則是分狀況討論的。

  咱們的軟件一旦上線以後（好比你的軟件主要是多個函數組成的）,那麼這個軟件對功能的擴展應該是開放的，好比你的遊戲一直在迭代更新，推出新的玩法，新功能。可是對於源代碼的修改是封閉的。你就拿函數舉例，若是你的遊戲源代碼中有一個函數是閃躲的功能，那麼你這個函數確定是被多個地方調用的，好比對方扔雷，對方開槍，對方用刀，你都會調用你的閃躲功能，那麼若是你的閃躲功能源碼改變了，或者調用方式改變了，當對方發起相應的動做，你在調用你的閃躲功能，就會發生問題。因此，開放封閉原則具體具體定義是這樣：

1. 對擴展是開放的

  咱們說，任何一個程序，不可能在設計之初就已經想好了全部的功能而且將來不作任何更新和修改。因此咱們必須容許代碼擴展、添加新功能。

1. 對修改是封閉的

  就像咱們剛剛提到的，由於咱們寫的一個函數，頗有可能已經交付給其餘人使用了，若是這個時候咱們對函數內部進行修改，或者修改了函數的調用方式，頗有可能影響其餘已經在使用該函數的用戶。OK，理解了開封封閉原則以後，咱們聊聊裝飾器。

  什麼是裝飾器？從字面意思來分析，先說裝飾，什麼是裝飾? 裝飾就是添加新的，好比你家剛買的房子，下一步就是按照本身的喜歡的方式設計，進行裝修，裝飾，地板，牆面，家電等等。什麼是器？器就是工具，也是功能，那裝飾器就好理解了：就是添加新的功能。

  好比我如今不會飛，怎麼才能讓我會飛？給我加一個翅膀，我就能飛了。那麼你給我加一個翅膀，它會改變我原來的行爲麼？我以前的吃喝拉撒睡等生活方式都不會改變。它就是在我原來的基礎上，添加了一個新的功能。

今天咱們講的裝飾器（裝修，翅膀）是以功能爲導向的，就是一個函數。

被裝飾的對象：好比毛坯房，我本人，其實也是一個函數。

因此裝飾器最終最完美的定義就是：在不改變原被裝飾的函數的源代碼以及調用方式下，爲其添加額外的功能。

---

接下來，咱們經過一個例子來爲你們講解這個裝飾器：

需求介紹：你如今xx科技有限公司的開發部分任職，領導給你一個業務需求讓你完成：讓你寫代碼測試小明同窗寫的函數的執行效率。

import time
def index():
    time.sleep(2)  # 模擬一下網絡延遲以及代碼的效率
    print('歡迎訪問博客園主頁')
    
start_time = time.time()
index()
end_time = time.time()
print(f'此函數的執行效率爲{end_time-start_time}')

可是你完成的是一個測試其餘函數的執行效率的功能，若是讓你測試一下，小張，小李，小劉的函數效率呢？ 你是否是全得複製

import time
def index():
    time.sleep(2)  # 模擬一下網絡延遲以及代碼的效率
    print('歡迎訪問博客園首頁')

def home(name):
    time.sleep(3)  # 模擬一下網絡延遲以及代碼的效率
    print(f'歡迎訪問{name}主頁')

start_time = time.time()
index()
end_time = time.time()
print(f'此函數的執行效率爲{end_time-start_time}')

start_time = time.time()
home('diege')
end_time = time.time()
print(f'此函數的執行效率爲{end_time-start_time}')

重複代碼太多了，因此要想解決重複代碼的問題，怎麼作？咱們是否是學過函數，函數就是以功能爲導向，減小重複代碼。

import time
def index():
    time.sleep(2)  # 模擬一下網絡延遲以及代碼的效率
    print('歡迎訪問博客園主頁')

def inner():
    start_time = time.time()
    index()
    end_time = time.time()
    print(f'此函數的執行效率爲{end_time-start_time}')

inner()

雖然將測試功能的代碼封裝成了一個函數，可是這樣，你只能測試小明同窗的的函數index，你要是測試其餘同事的函數呢？你怎麼作？

import time
def index():
    time.sleep(2)  # 模擬一下網絡延遲以及代碼的效率
    print('歡迎訪問博客園主頁')

def home(name):
    time.sleep(3)  # 模擬一下網絡延遲以及代碼的效率
    print(f'歡迎訪問{name}主頁')

def inner():
    start_time = time.time()
    index()
    home('diege')
    end_time = time.time()
    print(f'此函數的執行效率爲{end_time-start_time}')

timer()

要是像上面那麼作，每次測試其餘同事的代碼還須要手動改，這樣是否是太low了？因此如何變成動態測試其餘函數？咱們是否是學過函數的傳參？可否將被裝飾函數的函數名做爲函數的參數傳遞進去呢？

import time
def index():
    time.sleep(2)  # 模擬一下網絡延遲以及代碼的效率
    print('歡迎訪問博客園主頁')

def home(name):
    time.sleep(3)  # 模擬一下網絡延遲以及代碼的效率
    print(f'歡迎訪問{name}主頁')

def timmer(func):  # func == index 函數
    start_time = time.time()
    func()  # index()
    end_time = time.time()
    print(f'此函數的執行效率爲{end_time-start_time}')

timmer(index)

這樣我將index函數的函數名做爲參數傳遞給timmer函數，而後在timmer函數裏面執行index函數，這樣就變成動態傳參了。好，如今將上面的代碼快速練一遍。 練習完了以後，發現有什麼問題麼？ 對比着開放封閉原則說： 首先，index函數除了完成了本身以前的功能，還增長了一個測試執行效率的功能，對不？因此也符合開放原則。 其次，index函數源碼改變了麼？沒有，可是執行方式改變了，因此不符合封閉原則。 原來如何執行？ index() 如今如何執行？ inner(index)，這樣會形成什麼問題？ 假如index在你的項目中被100處調用，那麼這相應的100處調用我都得改爲inner(index)。很是麻煩，也不符合開放封閉原則。

實現真正的開放封閉原則：裝飾器。

只要把那個閉包的執行過程整清楚，那麼這個你想不會都難。

import time

def timer(func):  # func = index
    def inner():
        start_time = time.time()
        func()
        end_time = time.time()
        print(f'此函數的執行效率爲{end_time-start_time}')
    return inner

# @timer
def index():
    time.sleep(2)  # 模擬一下網絡延遲以及代碼的效率
    print('歡迎訪問博客園主頁')
    return '訪問成功'

foo = timer(index)
foo()

咱們分析一下代碼，代碼執行到這一行：foo = timer(index) 先執行誰？看見一個等號先要執行等號右邊， timer(index) 執行timer函數將index函數名傳給了func形參。內層函數inner執行麼？不執行，inner函數返回 給foo變量。因此咱們執行foo() 就至關於執行inner閉包函數。 foo(),這樣既測試效率又執行了原函數，有沒有問題？固然有啦！！你要解決原函數執行方式不改變的問題，怎麼作？ 因此你能夠把 foo 換成 index變量就完美了！ index = timer(index)，特別要注意函數外面的index實際是inner函數的內存地址而不是index函數。理解一下，這個timer就是最簡單版本裝飾器，在不改變原index函數的源碼以及調用方式前提下，爲其增長了額外的功能，測試執行效率。

下面爲修改後代碼

import time

def timer(func):  # func = index
    def inner():
        start_time = time.time()
        func()
        end_time = time.time()
        print(f'此函數的執行效率爲{end_time-start_time}')
    return inner

# @timer
def index():
    time.sleep(2)  # 模擬一下網絡延遲以及代碼的效率
    print('歡迎訪問博客園主頁')
    return '訪問成功'

index = timer(index)
index()

用語法糖來實現

import time

def timer(func):  # func = index
    def inner():
        start_time = time.time()
        func()
        end_time = time.time()
        print(f'此函數的執行效率爲{end_time-start_time}')
    return inner

@timer
def index():
    time.sleep(2)  # 模擬一下網絡延遲以及代碼的效率
    print('歡迎訪問博客園主頁')
    return '訪問成功'

#index = timer(index)
index()

有了 @ ，咱們就能夠省去index = timer(index)這一句了，直接調用index()便可獲得想要的結果。大家看到了沒有，index() 函數不須要作任何修改，只需在定義的地方加上裝飾器，調用的時候仍是和之前同樣，若是咱們有其餘的相似函數，咱們能夠繼續調用裝飾器來修飾函數，而不用重複修改函數或者增長新的封裝。這樣，咱們就提升了程序的可重複利用性，並增長了程序的可讀性。

裝飾器在 Python 使用如此方便都要歸因於 Python 的函數能像普通的對象同樣能做爲參數傳遞給其餘函數，能夠被賦值給其餘變量，能夠做爲返回值，能夠被定義在另一個函數內。

拓展連接： https://www.cnblogs.com/jin-xin/articles/10871410.html https://www.runoob.com/w3cnote/python-func-decorators.html