轉載於：http://blog.csdn.net/u013471155

很多人對裝飾器難以理解，原因是由於以下三點內容沒有搞清楚：

1. 關於函式“變數”（或“變數”函式）的理解
2. 關於高階函式的理解
3. 關於巢狀函式的理解

那麼如果能對以上的問題一一攻破，同時遵循裝飾器的基本原則，相信會對裝飾器有個很好的理解的。那麼我們先來看以下裝飾器的目的及其原則。

1、裝飾器

裝飾器實際上就是為了給某程式增添功能，但該程式已經上線或已經被使用，那麼就不能大批量的修改原始碼，這樣是不科學的也是不現實的，因為就產生了裝飾器，使得其滿足：

1. 不能修改被裝飾的函式的原始碼
2. 不能修改被裝飾的函式的呼叫方式
3. 滿足1、2的情況下給程式增添功能

那麼根據需求，同時滿足了這三點原則，這才是我們的目的。因為，下面我們從解決這三點原則入手來理解裝飾器。

等等，我要在需求之前先說裝飾器的原則組成：

< 函式+實參高階函式+返回值高階函式+巢狀函式+語法糖 = 裝飾器 >

這個式子是貫穿裝飾器的靈魂所在！

2、需求的實現

假設有程式碼：

improt time
def test():
    time.sleep(2)
    print("test is running!")
test()

很顯然，這段程式碼執行的結果一定是：等待約2秒後，輸出

test is running

• 那麼要求在滿足三原則的基礎上，給程式新增統計執行時間（2second）功能

在行動之前，我們先來看一下文章開頭提到的原因1（關於函式“變數”（或“變數”函式）的理解）

2.1、函式“變數”（或“變數”函式）

假設有程式碼：

x = 1
y = x
def test1():
    print("Do something")
test2 = lambda x:x*2

那麼在記憶體中，應該是這樣的：

很顯然，函式和變數是一樣的，都是“一個名字對應記憶體地址中的一些內容”
那麼根據這樣的原則，我們就可以理解兩個事情：

1. test1表示的是函式的記憶體地址
2. test1()就是呼叫對在test1這個地址的內容，即函式

如果這兩個問題可以理解，那麼我們就可以進入到下一個原因(關於高階函式的理解)

2.2高階函式

那麼對於高階函式的形式可以有兩種：

1. 把一個函式名當作實參傳給另外一個函式（“實參高階函式”）
2. 返回值中包含函式名（“返回值高階函式”）

那麼這裡面所說的函式名，實際上就是函式的地址，也可以認為是函式的一個標籤而已，並不是呼叫，是個名詞。如果可以把函式名當做實參，那麼也就是說可以把函式傳遞到另一個函式，然後在另一個函式裡面做一些操作，根據這些分析來看，這豈不是滿足了裝飾器三原則中的第一條，即不修改原始碼而增加功能。那我們看來一下具體的做法：

還是針對上面那段程式碼：

improt time

def test():
    time.sleep(2)
    print("test is running!")

def deco(func):  
    start = time.time()
    func() #2
    stop = time.time()
    print(stop-start)

deco(test) #1

我們來看一下這段程式碼，在#1處，我們把test當作實參傳遞給形參func，即func=test。注意，這裡傳遞的是地址，也就是此時func也指向了之前test所定義的那個函式體，可以說在deco()內部，func就是test。在#2處，把函式名後面加上括號，就是對函式的呼叫（執行它）。因此，這段程式碼執行結果是：

test is running!
the run time is 3.0009405612945557

我們看到似乎是達到了需求，即執行了源程式，同時也附加了計時功能，但是這隻滿足了原則1（不能修改被裝飾的函式的原始碼），但這修改了呼叫方式。假設不修改呼叫方式，那麼在這樣的程式中，被裝飾函式就無法傳遞到另一個裝飾函式中去。

那麼再思考，如果不修改呼叫方式，就是一定要有test()這條語句，那麼就用到了第二種高階函式，即返回值中包含函式名

如下程式碼：

improt time

def test():
    time.sleep(2)
    print("test is running!")

def deco(func):  
    print(func)
    return func 
t = deco(test) #3
#t()#4

test()

我們看這段程式碼，在#3處，將test傳入deco()，在deco()裡面操作之後，最後返回了func，並賦值給t。因此這裡test => func => t，都是一樣的函式體。最後在#4處保留了原來的函式呼叫方式。
看到這裡顯然會有些困惑，我們的需求不是要計算函式的執行時間麼，怎麼改成輸出函式地址了。是因為，單獨採用第二張高階函式（返回值中包含函式名）的方式，並且保留原函式呼叫方式，是無法計時的。如果在deco()裡計時，顯然會執行一次，而外面已經呼叫了test()，會重複執行。這裡只是為了說明第二種高階函式的思想，下面才真的進入重頭戲。

2.3 巢狀函式

巢狀函式指的是在函式內部定義一個函式，而不是呼叫，如：

def func1():
    def func2():
        pass
而不是
def func1():
    func2()

另外還有一個題外話，函式只能呼叫和它同級別以及上級的變數或函式。也就是說：裡面的能呼叫和它縮排一樣的和他外部的，而內部的是無法呼叫的。

那麼我們再回到我們之前的那個需求，想要統計程式執行時間，並且滿足三原則。

程式碼：

improt time

def timer(func) #5
    def deco():  
        start = time.time()
        func()
        stop = time.time()
        print(stop-start)
    return deco

test = timer(test) #6

def test():
    time.sleep(2)
    print("test is running!")   
test() #7

這段程式碼可能會有些困惑，怎麼忽然多了這麼多，暫且先接受它，分析一下再來說為什麼是這樣。

首先，在#6處，把test作為引數傳遞給了timer()，此時，在timer()內部，func = test，接下來，定義了一個deco()函式，當並未呼叫，只是在記憶體中儲存了，並且標籤為deco。在timer()函式的最後返回deco()的地址deco。

然後再把deco賦值給了test，那麼此時test已經不是原來的test了，也就是test原來的那些函式體的標籤換掉了，換成了deco。那麼在#7處呼叫的實際上是deco()。

那麼這段程式碼在本質上是修改了呼叫函式，但在表面上並未修改呼叫方式，而且實現了附加功能。

那麼通俗一點的理解就是：

把函式看成是盒子，test是小盒子，deco是中盒子，timer是大盒子。程式中，把小盒子test傳遞到大盒子temer中的中盒子deco，然後再把中盒子deco拿出來，開啟看看（呼叫）

這樣做的原因是：

我們要保留test()，還要統計時間，而test()只能呼叫一次（呼叫兩次執行結果會改變，不滿足），再根據函式即“變數”，那麼就可以通過函式的方式來回閉包。於是乎，就想到了，把test傳遞到某個函式，而這個函式內恰巧內嵌了一個內函式，再根據內嵌函式的作用域（可以訪問同級及以上，內嵌函式可以訪問外部引數），把test包在這個內函式當中，一起返回，最後呼叫這個返回的函式。而test傳遞進入之後，再被包裹出來，顯然test函式沒有弄丟（在包裹裡），那麼外面剩下的這個test標籤正好可以替代這個包裹（內含test()）。

至此，一切皆合，大功告成，單隻差一步。

3、 真正的裝飾器

根據以上分析，裝飾器在裝飾時，需要在每個函式前面加上：

test = timer(test)

顯然有些麻煩，Python提供了一種語法糖，即：

@timer

這兩句是等價的，只要在函式前加上這句，就可以實現裝飾作用。

以上為無參形式

4、裝飾有參函式

improt time

def timer(func)
    def deco():  
        start = time.time()
        func()
        stop = time.time()
        print(stop-start)
    return deco

@timer
def test(parameter): #8
    time.sleep(2)
    print("test is running!")   
test() 

對於一個實際問題，往往是有引數的，如果要在#8處，給被修飾函式加上引數，顯然這段程式會報錯的。錯誤原因是test()在呼叫的時候缺少了一個位置引數的。而我們知道test = func = deco，因此test()=func()=deco()
,那麼當test(parameter)有引數時，就必須給func()和deco()也加上引數，為了使程式更加有擴充套件性，因此在裝飾器中的deco()和func()，加如了可變引數*agrs和 **kwargs。

完整程式碼如下：

improt time

def timer(func)
    def deco(*args, **kwargs):  
        start = time.time()
        func(*args, **kwargs)
        stop = time.time()
        print(stop-start)
    return deco

@timer
def test(parameter): #8
    time.sleep(2)
    print("test is running!")   
test() 

那麼我們再考慮個問題，如果原函式test()的結果有返回值呢？比如：

def test(parameter): 
    time.sleep(2)
    print("test is running!")   
    return "Returned value"

那麼面對這樣的函式，如果用上面的程式碼來裝飾，最後一行的test()實際上呼叫的是deco()。有人可能會問，func()不就是test()麼，怎麼沒返回值呢？

其實是有返回值的，但是返回值返回到deco()的內部，而不是test()即deco()的返回值，那麼就需要再返回func()的值，因此就是：

def timer(func)
    def deco(*args, **kwargs):  
        start = time.time()
        res = func(*args, **kwargs)#9
        stop = time.time()
        print(stop-start)
        return res#10
    return deco

其中，#9的值在#10處返回。

完整程式為：

improt time

def timer(func)
    def deco(*args, **kwargs):  
        start = time.time()
        res = func(*args, **kwargs)
        stop = time.time()
        print(stop-start)
        return res 
    return deco

@timer
def test(parameter): #8
    time.sleep(2)
    print("test is running!")   
    return "Returned value"
test() 

5、帶引數的裝飾器

又增加了一個需求，一個裝飾器，對不同的函式有不同的裝飾。那麼就需要知道對哪個函式採取哪種裝飾。因此，就需要裝飾器帶一個引數來標記一下。例如：

@decorator(parameter = value)

比如有兩個函式：

def task1():
    time.sleep(2)
    print("in the task1")

def task2():
    time.sleep(2)
    print("in the task2")

task1()
task2()

要對這兩個函式分別統計執行時間，但是要求統計之後輸出：

the task1/task2 run time is : 2.00……

於是就要構造一個裝飾器timer，並且需要告訴裝飾器哪個是task1，哪個是task2，也就是要這樣：

@timer(parameter='task1') #
def task1():
    time.sleep(2)
    print("in the task1")

@timer(parameter='task2') #
def task2():
    time.sleep(2)
    print("in the task2")

task1()
task2()

那麼方法有了，但是我們需要考慮如何把這個parameter引數傳遞到裝飾器中，我們以往的裝飾器，都是傳遞函式名字進去，而這次，多了一個引數，要怎麼做呢？
於是，就想到再加一層函式來接受引數，根據巢狀函式的概念，要想執行內函式，就要先執行外函式，才能呼叫到內函式，那麼就有：

def timer(parameter): #
    print("in the auth :", parameter)

    def outer_deco(func): #
        print("in the outer_wrapper:", parameter)

        def deco(*args, **kwargs):

        return deco

    return outer_deco

首先timer(parameter)，接收引數parameter=’task1/2’，而@timer(parameter)也恰巧帶了括號，那麼就會執行這個函式， 那麼就是相當於：

timer = timer(parameter)
task1 = timer(task1)

後面的執行就和一般的裝飾器一樣了：

import time

def timer(parameter):

    def outer_wrapper(func):

        def wrapper(*args, **kwargs):
            if parameter == 'task1':
                start = time.time()
                func(*args, **kwargs)
                stop = time.time()
                print("the task1 run time is :", stop - start)
            elif parameter == 'task2':
                start = time.time()
                func(*args, **kwargs)
                stop = time.time()
                print("the task2 run time is :", stop - start)

        return wrapper

    return outer_wrapper

@timer(parameter='task1')
def task1():
    time.sleep(2)
    print("in the task1")

@timer(parameter='task2')
def task2():
    time.sleep(2)
    print("in the task2")

task1()
task2()

至此，裝飾器的全部內容結束。