Python 函數(shù)裝飾器詳解

更新時間：2021年10月19日 14:28:53 作者：RUNOOB

這篇文章主要介紹了Python函數(shù)裝飾器,結(jié)合實例形式詳細(xì)分析了Python裝飾器的原理、功能、分類、常見操作技巧與使用注意事項,需要的朋友可以參考下

裝飾器(Decorators)是 Python 的一個重要部分。簡單地說：他們是修改其他函數(shù)的功能的函數(shù)。他們有助于讓我們的代碼更簡短，也更Pythonic（Python范兒）。大多數(shù)初學(xué)者不知道在哪兒使用它們，所以我將要分享下，哪些區(qū)域里裝飾器可以讓你的代碼更簡潔。首先，讓我們討論下如何寫你自己的裝飾器。

這可能是最難掌握的概念之一。我們會每次只討論一個步驟，這樣你能完全理解它。

一切皆對象

首先我們來理解下 Python 中的函數(shù):

def hi(name="yasoob"):
    return "hi " + name
print(hi())
# output: 'hi yasoob'
# 我們甚至可以將一個函數(shù)賦值給一個變量，比如
greet = hi
# 我們這里沒有在使用小括號，因為我們并不是在調(diào)用hi函數(shù)
# 而是在將它放在greet變量里頭。我們嘗試運(yùn)行下這個
print(greet())
# output: 'hi yasoob'
# 如果我們刪掉舊的hi函數(shù)，看看會發(fā)生什么！
del hi
print(hi())
#outputs: NameError
print(greet())
#outputs: 'hi yasoob'

在函數(shù)中定義函數(shù)

剛才那些就是函數(shù)的基本知識了。我們來讓你的知識更進(jìn)一步。在 Python 中我們可以在一個函數(shù)中定義另一個函數(shù)：

def hi(name="yasoob"):
    print("now you are inside the hi() function")
    def greet():
        return "now you are in the greet() function"
    def welcome():
        return "now you are in the welcome() function"
    print(greet())
    print(welcome())
    print("now you are back in the hi() function")
hi()
#output:now you are inside the hi() function
#       now you are in the greet() function
#       now you are in the welcome() function
#       now you are back in the hi() function
# 上面展示了無論何時你調(diào)用hi(), greet()和welcome()將會同時被調(diào)用。
# 然后greet()和welcome()函數(shù)在hi()函數(shù)之外是不能訪問的，比如：
greet()
#outputs: NameError: name 'greet' is not defined

那現(xiàn)在我們知道了可以在函數(shù)中定義另外的函數(shù)。也就是說：我們可以創(chuàng)建嵌套的函數(shù)?，F(xiàn)在你需要再多學(xué)一點(diǎn)，就是函數(shù)也能返回函數(shù)。

從函數(shù)中返回函數(shù)

其實并不需要在一個函數(shù)里去執(zhí)行另一個函數(shù)，我們也可以將其作為輸出返回出來：

def hi(name="yasoob"):
    def greet():
        return "now you are in the greet() function"
    def welcome():
        return "now you are in the welcome() function"
    if name == "yasoob":
        return greet
    else:
        return welcome
a = hi()
print(a)
#outputs: <function greet at 0x7f2143c01500>
#上面清晰地展示了`a`現(xiàn)在指向到hi()函數(shù)中的greet()函數(shù)
#現(xiàn)在試試這個
print(a())
#outputs: now you are in the greet() function

再次看看這個代碼。在 if/else 語句中我們返回 greet 和 welcome，而不是 greet() 和 welcome()。為什么那樣？這是因為當(dāng)你把一對小括號放在后面，這個函數(shù)就會執(zhí)行；然而如果你不放括號在它后面，那它可以被到處傳遞，并且可以賦值給別的變量而不去執(zhí)行它。你明白了嗎？讓我再稍微多解釋點(diǎn)細(xì)節(jié)。

當(dāng)我們寫下 a = hi()，hi() 會被執(zhí)行，而由于 name 參數(shù)默認(rèn)是 yasoob，所以函數(shù) greet 被返回了。如果我們把語句改為 a = hi(name = "ali")，那么 welcome 函數(shù)將被返回。我們還可以打印出 hi()()，這會輸出 now you are in the greet() function。

將函數(shù)作為參數(shù)傳給另一個函數(shù)

def hi():
    return "hi yasoob!"
def doSomethingBeforeHi(func):
    print("I am doing some boring work before executing hi()")
    print(func())
doSomethingBeforeHi(hi)
#outputs:I am doing some boring work before executing hi()
#        hi yasoob!

現(xiàn)在你已經(jīng)具備所有必需知識，來進(jìn)一步學(xué)習(xí)裝飾器真正是什么了。裝飾器讓你在一個函數(shù)的前后去執(zhí)行代碼。

你的第一個裝飾器

在上一個例子里，其實我們已經(jīng)創(chuàng)建了一個裝飾器！現(xiàn)在我們修改下上一個裝飾器，并編寫一個稍微更有用點(diǎn)的程序：

def a_new_decorator(a_func):
    def wrapTheFunction():
        print("I am doing some boring work before executing a_func()")
        a_func()
        print("I am doing some boring work after executing a_func()")
    return wrapTheFunction
def a_function_requiring_decoration():
    print("I am the function which needs some decoration to remove my foul smell")
a_function_requiring_decoration()
#outputs: "I am the function which needs some decoration to remove my foul smell"
a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
#now a_function_requiring_decoration is wrapped by wrapTheFunction()
a_function_requiring_decoration()
#outputs:I am doing some boring work before executing a_func()
#        I am the function which needs some decoration to remove my foul smell
#        I am doing some boring work after executing a_func()

你看明白了嗎？我們剛剛應(yīng)用了之前學(xué)習(xí)到的原理。這正是 python 中裝飾器做的事情！它們封裝一個函數(shù)，并且用這樣或者那樣的方式來修改它的行為?，F(xiàn)在你也許疑惑，我們在代碼里并沒有使用 @ 符號？那只是一個簡短的方式來生成一個被裝飾的函數(shù)。這里是我們?nèi)绾问褂?@ 來運(yùn)行之前的代碼：

@a_new_decorator
def a_function_requiring_decoration():
    """Hey you! Decorate me!"""
    print("I am the function which needs some decoration to "
          "remove my foul smell")
a_function_requiring_decoration()
#outputs: I am doing some boring work before executing a_func()
#         I am the function which needs some decoration to remove my foul smell
#         I am doing some boring work after executing a_func()
#the @a_new_decorator is just a short way of saying:
a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

希望你現(xiàn)在對 Python 裝飾器的工作原理有一個基本的理解。如果我們運(yùn)行如下代碼會存在一個問題：

print(a_function_requiring_decoration.__name__)
# Output: wrapTheFunction

這并不是我們想要的！Ouput輸出應(yīng)該是"a_function_requiring_decoration"。這里的函數(shù)被warpTheFunction替代了。它重寫了我們函數(shù)的名字和注釋文檔(docstring)。幸運(yùn)的是Python提供給我們一個簡單的函數(shù)來解決這個問題，那就是functools.wraps。我們修改上一個例子來使用functools.wraps：

from functools import wraps
def a_new_decorator(a_func):
    @wraps(a_func)
    def wrapTheFunction():
        print("I am doing some boring work before executing a_func()")
        a_func()
        print("I am doing some boring work after executing a_func()")
    return wrapTheFunction
@a_new_decorator
def a_function_requiring_decoration():
    """Hey yo! Decorate me!"""
    print("I am the function which needs some decoration to "
          "remove my foul smell")
print(a_function_requiring_decoration.__name__)
# Output: a_function_requiring_decoration

現(xiàn)在好多了。我們接下來學(xué)習(xí)裝飾器的一些常用場景。

藍(lán)本規(guī)范:

from functools import wraps
def decorator_name(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if not can_run:
            return "Function will not run"
        return f(*args, **kwargs)
    return decorated
@decorator_name
def func():
    return("Function is running")
can_run = True
print(func())
# Output: Function is running
can_run = False
print(func())
# Output: Function will not run

注意：@wraps接受一個函數(shù)來進(jìn)行裝飾，并加入了復(fù)制函數(shù)名稱、注釋文檔、參數(shù)列表等等的功能。這可以讓我們在裝飾器里面訪問在裝飾之前的函數(shù)的屬性。

使用場景

現(xiàn)在我們來看一下裝飾器在哪些地方特別耀眼，以及使用它可以讓一些事情管理起來變得更簡單。

授權(quán)(Authorization)

裝飾器能有助于檢查某個人是否被授權(quán)去使用一個web應(yīng)用的端點(diǎn)(endpoint)。它們被大量使用于Flask和Django web框架中。這里是一個例子來使用基于裝飾器的授權(quán)：

from functools import wraps
def requires_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            authenticate()
        return f(*args, **kwargs)
    return decorated

日志(Logging)

日志是裝飾器運(yùn)用的另一個亮點(diǎn)。這是個例子：

from functools import wraps
def logit(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)
    return with_logging
@logit
def addition_func(x):
   """Do some math."""
   return x + x
result = addition_func(4)
# Output: addition_func was called

我敢肯定你已經(jīng)在思考裝飾器的一個其他聰明用法了。

帶參數(shù)的裝飾器

來想想這個問題，難道@wraps不也是個裝飾器嗎？但是，它接收一個參數(shù)，就像任何普通的函數(shù)能做的那樣。那么，為什么我們不也那樣做呢？這是因為，當(dāng)你使用@my_decorator語法時，你是在應(yīng)用一個以單個函數(shù)作為參數(shù)的一個包裹函數(shù)。記住，Python里每個東西都是一個對象，而且這包括函數(shù)！記住了這些，我們可以編寫一下能返回一個包裹函數(shù)的函數(shù)。

在函數(shù)中嵌入裝飾器

我們回到日志的例子，并創(chuàng)建一個包裹函數(shù)，能讓我們指定一個用于輸出的日志文件:

from functools import wraps
def logit(logfile='out.log'):
    def logging_decorator(func):
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + " was called"
            print(log_string)
            # 打開logfile，并寫入內(nèi)容
            with open(logfile, 'a') as opened_file:
                # 現(xiàn)在將日志打到指定的logfile
                opened_file.write(log_string + '\n')
            return func(*args, **kwargs)
        return wrapped_function
    return logging_decorator
@logit()
def myfunc1():
    pass
myfunc1()
# Output: myfunc1 was called
# 現(xiàn)在一個叫做 out.log 的文件出現(xiàn)了，里面的內(nèi)容就是上面的字符串
@logit(logfile='func2.log')
def myfunc2():
    pass
myfunc2()
# Output: myfunc2 was called
# 現(xiàn)在一個叫做 func2.log 的文件出現(xiàn)了，里面的內(nèi)容就是上面的字符串

裝飾器類

現(xiàn)在我們有了能用于正式環(huán)境的logit裝飾器，但當(dāng)我們的應(yīng)用的某些部分還比較脆弱時，異常也許是需要更緊急關(guān)注的事情。比方說有時你只想打日志到一個文件。而有時你想把引起你注意的問題發(fā)送到一個email，同時也保留日志，留個記錄。這是一個使用繼承的場景，但目前為止我們只看到過用來構(gòu)建裝飾器的函數(shù)。

幸運(yùn)的是，類也可以用來構(gòu)建裝飾器。那我們現(xiàn)在以一個類而不是一個函數(shù)的方式，來重新構(gòu)建logit。

from functools import wraps
class logit(object):
    def __init__(self, logfile='out.log'):
        self.logfile = logfile
    def __call__(self, func):
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + " was called"
            print(log_string)
            # 打開logfile并寫入
            with open(self.logfile, 'a') as opened_file:
                # 現(xiàn)在將日志打到指定的文件
                opened_file.write(log_string + '\n')
            # 現(xiàn)在，發(fā)送一個通知
            self.notify()
            return func(*args, **kwargs)
        return wrapped_function
    def notify(self):
        # logit只打日志，不做別的
        pass

這個實現(xiàn)有一個附加優(yōu)勢，在于比嵌套函數(shù)的方式更加整潔，而且包裹一個函數(shù)還是使用跟以前一樣的語法：

@logit()
def myfunc1():
    pass

現(xiàn)在，我們給 logit 創(chuàng)建子類，來添加 email 的功能(雖然 email 這個話題不會在這里展開)。

class email_logit(logit):
    '''
    一個logit的實現(xiàn)版本，可以在函數(shù)調(diào)用時發(fā)送email給管理員
    '''
    def __init__(self, email='admin@myproject.com', *args, **kwargs):
        self.email = email
        super(email_logit, self).__init__(*args, **kwargs)
    def notify(self):
        # 發(fā)送一封email到self.email
        # 這里就不做實現(xiàn)了
        pass

從現(xiàn)在起，@email_logit 將會和 @logit 產(chǎn)生同樣的效果，但是在打日志的基礎(chǔ)上，還會多發(fā)送一封郵件給管理員。