摘要：裝飾器的高級用法介紹下面這些旨在介紹裝飾器的一些更有趣的用法。裝飾器在定義時向函數(shù)和方法添加功能，它們不用于在運行時添加功能。接受參數(shù)的裝飾器有時，除了裝飾的函數(shù)之外，裝飾器還可以使用參數(shù)。

首先我要承認(rèn)，裝飾器非常難！你在本教程中看到的一些代碼將會有一些復(fù)雜。大多數(shù)人在學(xué)習(xí)Python時都跟裝飾器做過斗爭，所以如果這對你來說很奇怪，不要感到沮喪，因為同樣的大多數(shù)人都可以克服這種苦難。在本教程中，我將逐步介紹了解裝飾器的過程。首先我假設(shè)你已經(jīng)可以編寫基本函數(shù)和基本類。如果你不能做這些事，那么我建議你在回到這里之前先學(xué)習(xí)如何去做到編寫基本函數(shù)和基本類（除非你迷路了，在這種情況下你可以原諒）。

假設(shè)我們正在執(zhí)行一段代碼，執(zhí)行時間比我們想的還要長一些。這段代碼由一堆函數(shù)調(diào)用組成，我們確信這些調(diào)用中至少有一個調(diào)用構(gòu)成了我們代碼中的瓶頸。我們?nèi)绾握业狡款i？現(xiàn)在有一個解決方案，就是我們現(xiàn)在要關(guān)注的解決方案，就是對函數(shù)執(zhí)行進(jìn)行計時。

讓我們從一個簡單的例子開始。我們只有一個函數(shù)需要計時，func_a

def func_a(stuff):
    do_important_things_1()
    do_important_things_2()
    do_important_things_3()

一種方法是將時鐘代碼放在每個函數(shù)調(diào)用周圍。所以就像這樣：

func_a(current_stuff)

看起來會更像這樣：

before = datetime.datetime.now()
func_a(current_stuff)
after = datetime.datetime.now()
print （"Elapsed Time = {0}".format(after-before)）

這樣就可以了。但是如果我們有多次調(diào)用func_a并且我們想要為所有這些計時會發(fā)生什么呢？我們可以用計時代碼包圍func_a的每個調(diào)用，但是這樣做也有不好的效果。它只準(zhǔn)備編寫一次計時代碼。因此，我們將其放在函數(shù)定義中，而不是將其放在函數(shù)之外。

def func_a(stuff):
    before = datetime.datetime.now()
    do_important_things_1()
    do_important_things_2()
    do_important_things_3()
    after = datetime.datetime.now()
    print("Elapsed Time = {0}".format(after-before))

這種方法的好處是：

我們將代碼放在一個地方，所以如果我們想要更改它（例如，如果我們想將經(jīng)過的時間存儲在數(shù)據(jù)庫或日志中）那么我們只需要在一個地方而不是每一個函數(shù)調(diào)用中更改它

我們不需要記住每次調(diào)用func_a都要寫四行代碼而不是一行，這是非常好的

好的，但是只需要計算一個函數(shù)的時間是不現(xiàn)實的。如果你需要對一件事進(jìn)行計時，你很有可能需要至少對兩件事進(jìn)行計時。所以我們會選擇三個。

def func_a(stuff):
    before = datetime.datetime.now()
    do_important_things_1()
    do_important_things_2()
    do_important_things_3()
    after = datetime.datetime.now()
    print("Elapsed Time = {0}".format(after-before))

def func_b(stuff):
    before = datetime.datetime.now()
    do_important_things_4()
    do_important_things_5()
    do_important_things_6()
    after = datetime.datetime.now()
    print("Elapsed Time = {0}".format(after-before))

def func_c(stuff):
    before = datetime.datetime.now()
    do_important_things_7()
    do_important_things_8()
    do_important_things_9()
    after = datetime.datetime.now()
    print("Elapsed Time = {0}".format(after-before))

這看起來很糟糕。如果我們想要對8個函數(shù)進(jìn)行計時的時候怎么辦？然后我們決定將計時的信息存儲在日志文件中。然后我們決定建立一個更好的數(shù)據(jù)庫。我們這里需要的是將一種相同的代碼合并到func_a，func_b和func_c中的方法，這種方法不會讓我們到處復(fù)制粘貼代碼。

Python是一種非常特殊的語言，因為函數(shù)是第一類對象。這意味著一旦函數(shù)在作用域中被定義，它就可以傳遞給函數(shù)，賦值給變量，甚至從函數(shù)返回。這個簡單的事實是使python裝飾器成為可能的原因。查看下面的代碼，看看你是否可以猜出標(biāo)記為A，B，C和D的行會發(fā)生什么。

def get_function():
    print （"inside get_function"）                 
    def returned_function():                    
        print（"inside returned_function"）        
        return 1
    print（"outside returned_function"）
    return returned_function

returned_function()     # A                         
x = get_function()      # B                         
x                       # C                        
x()                     # D

A

這一行給出了一個NameError并聲明returned_function不存在。但我們只是定義了它，對吧？你在這里需要知道的是，它是在get_function的范圍內(nèi)定義的。也就是說，在get_function里面定義了它。它不是在get_function之外。如果這讓你感到困惑，那么你可以嘗試使用該locals()函數(shù)，并閱讀Python的范圍。

B

這行代碼打印出以下內(nèi)容：

inside get_function
outside returned_function

此時Python不執(zhí)行returned_function的任何內(nèi)容。

C

這一行輸出：

也就是說，get_function()返回的值x本身就是一個函數(shù)。

嘗試再次運行B和C行。請注意，每次重復(fù)此過程時，返回的returned_function地址都是不同。每次調(diào)用get_function都會生成新的returned function。

d

因為x是函數(shù)，所以就可以調(diào)用它。調(diào)用x就是調(diào)用returned_function的一個實例。這里輸出的是：

inside returned_function
1

也就是說，它打印字符串，并返回值1。

你現(xiàn)在仍然在看么？如此我們有了新的知識，那么我們?nèi)绾谓鉀Q我們的老問題？我建議我們創(chuàng)建一個函數(shù)，讓我們調(diào)用它并稱為time_this，它將接收另一個函數(shù)作為參數(shù)，并將參數(shù)函數(shù)封裝在某些計時代碼中。有點像：

def time_this(original_function):                            # 1
    def new_function(*args,**kwargs):                        # 2
        before = datetime.datetime.now()                     # 3
        x = original_function(*args,**kwargs)                # 4
        after = datetime.datetime.now()                      # 5
        print("Elapsed Time = {0}".format(after-before))     # 6
        return x                                             # 7
    return new_function()                                    # 8

我承認(rèn)它有點瘋狂，所以讓我們一行一行的看下去：

1這只是time_this的原型。time_this是一個函數(shù)就像任何其他函數(shù)一樣，并且只有一個參數(shù)。?2我們在內(nèi)部定義一個函數(shù)time_this。每當(dāng)time_this執(zhí)行時它都會創(chuàng)建一個新函數(shù)。?3計時代碼，就像之前一樣。?4我們調(diào)用原始函數(shù)并保留結(jié)果以供日后使用。?5,6剩余的計時代碼。?7new_function必須像原始函數(shù)一樣運行，因此返回存儲的結(jié)果。?8返回在time_this中創(chuàng)建的函數(shù)。

現(xiàn)在我們要確保我們的函數(shù)是計時的：

def func_a(stuff):
    do_important_things_1()
    do_important_things_2()
    do_important_things_3()
func_a = time_this(func_a)        # <---------

def func_b(stuff):
    do_important_things_4()
    do_important_things_5()
    do_important_things_6()
func_b = time_this(func_b)        # <---------

def func_c(stuff):
    do_important_things_7()
    do_important_things_8()
    do_important_things_9()
func_c = time_this(func_c)        # <---------

看看func_a，當(dāng)我們執(zhí)行時func_a = time_this(func_a)我們用time_this返回的函數(shù)替換func_a。所以我們用一個函數(shù)替換func_A該函數(shù)執(zhí)行一些計時操作（上面的第3行），將func a的結(jié)果存儲在一個名為x的變量中（第4行），執(zhí)行更多的計時操作（第5行和第6行），然后返回func_a返回的內(nèi)容。換句話說func_a，仍然以相同的方式調(diào)用并返回相同的東西，它也只是被計時了。是不是感覺很整潔？

我們所做的工作很好，而且非常棒，但是很難看，非常難讀懂。所以Python可愛的作者給了我們一種不同的，更漂亮的寫作方式：

@time_this
def func_a(stuff):
    do_important_things_1()
    do_important_things_2()
    do_important_things_3()

完全等同于：

def func_a(stuff):
    do_important_things_1()
    do_important_things_2()
    do_important_things_3()
func_a = time_this(func_a)

這通常被稱為語法糖。@沒有什么神奇的。這只是一個已達(dá)成一致的慣例。沿著這條路上的某個地方?jīng)Q定了。

裝飾器只是一個返回函數(shù)的函數(shù)。如果這些東西看起來非常的 - 那么請確保以下主題對你有意義然后再回到本教程：

Python函數(shù)

范圍

Python作為第一類對象（甚至可以查找lambda函數(shù)，它可能使它更容易理解）。

另一方面，如果你對更多的話題感興趣的話，你可能會發(fā)現(xiàn)：

如裝飾類：

python @add_class_functionality class MyClass: ...

具有更多參數(shù)的裝飾器， 例如：

python @requires_permission(name="edit") def save_changes(stuff): ...

下面就是我要介紹的高級裝飾器的主題。

下面這些旨在介紹裝飾器的一些更有趣的用法。具體來說，如何在類上使用裝飾器，以及如何將額外的參數(shù)傳遞給裝飾器函數(shù)。

裝飾器模式是一種面向?qū)ο蟮脑O(shè)計模式，其允許動態(tài)地將行為添加到現(xiàn)有的對象當(dāng)中。當(dāng)你裝飾對象時，你將以獨立于同類的其他實例方式擴展它的功能。

Python裝飾器不是裝飾器模式的實現(xiàn)。Python裝飾器在定義時向函數(shù)和方法添加功能，它們不用于在運行時添加功能。裝飾器模式本身可以在Python中實現(xiàn)，但由于Python是Duck-teped的，因此這是一件非常簡單的事情。

這是裝飾器可以做的一個非常基本的例子。我只是把它作為一個參考點。在繼續(xù)之前，請確保你完全理解這段代碼。

def time_this(original_function):      
    def new_function(*args,**kwargs):
        import datetime                 
        before = datetime.datetime.now()                     
        x = original_function(*args,**kwargs)                
        after = datetime.datetime.now()                      
        print （"Elapsed Time = {0}".format(after-before)）    
        return x                                             
    return new_function                                   

@time_this
def func_a(stuff):
    import time
    time.sleep(3)

func_a(1)

有時，除了裝飾的函數(shù)之外，裝飾器還可以使用參數(shù)。這種技術(shù)經(jīng)常用于函數(shù)注冊等事情。一個著名的例子是Pyramid Web應(yīng)用程序框架中的視圖配置。例如：

@view_config(route_name="home", renderer="templates/mytemplate.pt")
def my_view(request):
    return {"project": "hello decorators"}

假設(shè)我們有一個應(yīng)用程序，用戶可以登錄并與一個漂亮的gui（圖形用戶界面）進(jìn)行交互。用戶與gui的交互觸發(fā)事件，而這些事件導(dǎo)致Python函數(shù)被執(zhí)行。讓我們假設(shè)有很多用戶使用這個應(yīng)用程序，并且他們有許多不同的權(quán)限級別。執(zhí)行不同的功能需要不同的權(quán)限類型。例如，考慮以下功能：

#這些功能是存在的
def current_user_id():
    """
    此函數(shù)返回當(dāng)前登錄的用戶ID，如果沒有經(jīng)過身份驗證，則返回None 
    """

def get_permissions(iUserId):
    """
    返回給定用戶的權(quán)限字符串列表，例如 ["logged_in","administrator","premium_member"]
    """

#我們需要對這些函數(shù)進(jìn)行權(quán)限檢查

def delete_user(iUserId):
   """
   刪除具有給定ID的用戶，只有管理員權(quán)限才能訪問此函數(shù)
   """

def new_game():
    """
    任何已登錄的用戶都可以啟動一個新游戲
    """

def premium_checkpoint():
   """
   保存游戲進(jìn)程，只允許高級成員訪問
   """

實現(xiàn)這些權(quán)限的一種方法是創(chuàng)建多個裝飾器，例如：

def requires_admin(fn):
    def ret_fn(*args,**kwargs):
        lPermissions = get_permissions(current_user_id())
        if "administrator" in lPermissions:
            return fn(*args,**kwargs)
        else:
            raise Exception("Not allowed")
    return ret_fn

def requires_logged_in(fn):
    def ret_fn(*args,**kwargs):
        lPermissions = get_permissions(current_user_id())
        if "logged_in" in lPermissions:
            return fn(*args,**kwargs)
        else:
            raise Exception("Not allowed")
    return ret_fn

def requires_premium_member(fn):
    def ret_fn(*args,**kwargs):
        lPermissions = get_permissions(current_user_id())
        if "premium_member" in lPermissions:
            return fn(*args,**kwargs)
        else:
            raise Exception("Not allowed")
    return ret_fn

@requires_admin
def delete_user(iUserId):
   """
   刪除具有給定Id的用戶，只有具有管理員權(quán)限的用戶才能訪問此函數(shù)
   """

@requires_logged_in 
def new_game():
    """
    任何已登錄的用戶都可以啟動一個新游戲
    """

@requires_premium_member
def premium_checkpoint():
   """
   保存游戲進(jìn)程，只允許高級成員訪問
   """

但這太可怕了。它需要大量的復(fù)制粘貼，并且每個裝飾器需要不同的名稱，如果對權(quán)限的檢查方式進(jìn)行了任何更改，則必須更新每個裝飾器。有一個裝飾器可以完成這三個工作不是很好嗎？

為此，我們需要一個返回裝飾器的函數(shù)：

def requires_permission(sPermission):                            
    def decorator(fn):                                            
        def decorated(*args,**kwargs):                            
            lPermissions = get_permissions(current_user_id())     
            if sPermission in lPermissions:                       
                return fn(*args,**kwargs)                         
            raise Exception("permission denied")                  
        return decorated                                          
    return decorator       

def get_permissions(iUserId): #這樣裝飾器就不會拋出NameError
    return ["logged_in",]

def current_user_id():        #名稱錯誤也是如此
    return 1

#現(xiàn)在我們可以進(jìn)行裝飾了                                 

@requires_permission("administrator")
def delete_user(iUserId):
   """
   刪除具有給定Id的用戶，只有具有管理員權(quán)限的用戶才能訪問此函數(shù)
   """

@requires_permission("logged_in")
def new_game():
    """
    任何已登錄的用戶都可以啟動一個新游戲
    """

@requires_permission("premium_member")
def premium_checkpoint():
   """
   保存游戲進(jìn)程，只允許高級成員訪問
   """

嘗試調(diào)用delete_user，new_game和premium_checkpoint看看會發(fā)生什么。

premium_checkpoint和delete_user都在消息“權(quán)限被拒絕”的情況下引發(fā)異常，new_game執(zhí)行得很好（但沒有太多的作用）。

下面是裝飾器的一般形式，帶有參數(shù)和使用說明：

def outer_decorator(*outer_args,**outer_kwargs):                            
    def decorator(fn):                                            
        def decorated(*args,**kwargs):                            
            do_something(*outer_args,**outer_kwargs)                      
            return fn(*args,**kwargs)                         
        return decorated                                          
    return decorator       

@outer_decorator(1,2,3)
def foo(a,b,c):
    print （a）
    print （b）
    print （c）

foo()

這相當(dāng)于：

def decorator(fn):                                            
    def decorated(*args,**kwargs):                            
        do_something(1,2,3)                      
        return fn(*args,**kwargs)                         
    return decorated                                          
return decorator       

@decorator
def foo(a,b,c):
    print （a）
    print （b）
    print （c）

foo()

裝飾器不僅限于對函數(shù)進(jìn)行操作，它們也可以對類進(jìn)行操作。比方說，我們有一個類可以做很多非常重要的事情，我們想要把它所做的一切都進(jìn)行計時。然后我們可以使用time_this像以前一樣使用裝飾器：

class ImportantStuff(object):
    @time_this
    def do_stuff_1(self):
        ...
    @time_this
    def do_stuff_2(self):
        ...
    @time_this
    def do_stuff_3(self):
        ...

這樣就可以了。但是這個類中還有一些額外的代碼行。如果我們寫一些更多的類方法并忘記裝飾它們中的一個呢？如果我們決定不再為進(jìn)行計時怎么辦？這里肯定存在人為錯誤的空間。這樣編寫它會好得多：

@time_all_class_methods
class ImportantStuff:
    def do_stuff_1(self):
        ...
    def do_stuff_2(self):
        ...
    def do_stuff_3(self):
        ...

如你所知，該代碼相當(dāng)于：

class ImportantStuff:
    def do_stuff_1(self):
        ...
    def do_stuff_2(self):
        ...
    def do_stuff_3(self):
        ...

ImportantStuff = time_all_class_methods(ImportantStuff)

那么time_all_class_methods是如何工作的？ 首先，我們知道它需要將一個類作為參數(shù)，并返回一個類。我們也知道返回類的函數(shù)應(yīng)該與原始ImportantStuff類的函數(shù)相同。也就是說，我們?nèi)匀幌Ｍ胍瓿芍匾氖虑椋覀冃枰M(jìn)行計時。以下是我們將如何做到這一點：

def time_this(original_function):      
    print （"decorating"）                      
    def new_function(*args,**kwargs):
        print （"starting timer"）      
        import datetime                 
        before = datetime.datetime.now()                     
        x = original_function(*args,**kwargs)                
        after = datetime.datetime.now()                      
        print （"Elapsed Time = {0}".format(after-before))      
        return x                                             
    return new_function  

def time_all_class_methods(Cls):
    class NewCls(object):
        def __init__(self,*args,**kwargs):
            self.oInstance = Cls(*args,**kwargs)
        def __getattribute__(self,s):
            """
            每當(dāng)訪問NewCls對象的任何屬性時，都會調(diào)用這個函數(shù)。這個函數(shù)首先嘗試
            從NewCls獲取屬性。如果失敗，則嘗試從self獲取屬性。oInstance(一個
            修飾類的實例)。如果它設(shè)法從self獲取屬性。oInstance,
            屬性是一個實例方法，然后應(yīng)用" time_this "。
            """
            try:    
                x = super(NewCls,self).__getattribute__(s)
            except AttributeError:      
                pass
            else:
                return x
            x = self.oInstance.__getattribute__(s)
            if type(x) == type(self.__init__): # 這是一個實例方法
                return time_this(x)                 # 這等價于用time_this修飾方法
            else:
                return x
    return NewCls

#現(xiàn)在讓我們做一個虛擬類來測試它:

@time_all_class_methods
class Foo(object):
    def a(self):
        print ("entering a")
        import time
        time.sleep(3)
        print ("exiting a")

oF = Foo()
oF.a()

在裝飾器的高級用法中，我向你展示了使用Python裝飾器的一些技巧 - 我已經(jīng)向你展示了如何將參數(shù)傳遞給裝飾器，以及如何裝飾類。但這仍然只是冰山的一角。在各種奇怪的情況下，有大量的方法用于裝飾器。你甚至可以裝飾你的裝飾器（但如果你到達(dá)那一點，那么做一個全面的檢查可能是個好主意）。Python同時內(nèi)置了一些值得了解的裝飾器，例如裝飾器staticmethod及classmethod。

接下來要怎么做？除了我在這篇文章中向你展示的內(nèi)容外，通常不需要對裝飾器執(zhí)行任何更復(fù)雜的操作。如果你對更改類功能的更多方法感興趣，那么我建議閱讀有關(guān)繼承和一般OO設(shè)計原則的數(shù)據(jù)?；蛘?，如果你真的想學(xué)會他們，那么請閱讀元類（但同樣，處理這些東西幾乎不需要）。