Python 終結者裝飾器，也叫 Decorator

前不久，我面試過一個要求月薪 30k + 的程序員，還有一個浙大畢業的新人，兩個人都自稱最熟悉的編程語言是 Python，但沒有一個人知道裝飾器。看完這篇文章，至少你在這方面超越了他們。

看透這篇文章，你至少超過了 80% 的 Python 學習者。

就算一週學透一個重要知識點，不久之後，你就會成爲很厲害的存在！加油！！

對於 Python 學習者，一旦過了入門階段，你幾乎一定會用到 Python 的裝飾器。

它經常使用在很多地方，比如 Web 開發，日誌處理，性能蒐集，權限控制等。

還有一個極其重要的地方，那就是面試的時候。對，裝飾器是面試中最常見的問題之一！

實戰入門

拋出問題

看這段代碼：

def step1():
 print('step1.......')

def step2():
 print('step2......')

def step3():
 print('step3......')

step1()
step2()
step3()

代碼中定義了 3 個函數，然後分別調用這 3 個函數。假設，我們發現代碼運行很慢，我們想知道每個函數運行分別花了多少時間。

笨辦法解決

我們可以在每個函數中添加計時的代碼：

• 第一行記錄開始時間

• 執行完業務邏輯記錄結束時間

• 結束時間減去開始時間，算出函數執行用時

下面的例子只在 step1 中添加了相關代碼作爲示例，你可以自行給 step2 和 step3 添加相關代碼。

import time
def step1():
 start = time.time()
 print('step1.......')
 end = time.time()
 used = end - start 
 print(used)

def step2():
 print('step2......')

def step3():
 print('step3......')

step1()
step2()
step3()

這個方法可行！但用你的腳指頭想想也會覺得，這個方法很繁瑣，很笨拙，很危險！

這裏只有 3 個函數，如果有 30 個函數，那不是要死人啦。萬一修改的時候不小心，把原來的函數給改壞了，面子都丟光了，就要被人 BS 了！

一定有一個更好的解決方法！

用裝飾器解決

更好的解決方法是使用裝飾器。

裝飾器並沒有什麼高深的語法，它就是一個實現了給現有函數添加裝飾功能的函數，僅此而已！

import time

def timer(func):
 '''統計函數運行時間的裝飾器'''
 def wrapper():
  start = time.time()
  func()
  end = time.time()
  used = end - start
  print(f'{func.__name__} used {used}')
 return wrapper


def step1():
 print('step1.......')

def step2():
 print('step2......')

def step3():
 print('step3......')

timed_step1 = timer(step1)
timed_step2 = timer(step2)
timed_step3 = timer(step3)
timed_step1()
timed_step2()
timed_step3()

上面的 timer 函數就是個裝飾器。

1. 它的參數是需要被裝飾的函數

2. 返回值是新定義的一個包裝了原有函數的函數。

3. 新定義的函數先記錄開始時間，調用被裝飾的函數，然後再計算用了多少時間。

簡單說就是把原來的函數給包了起來，在不改變原函數代碼的情況下，在外面起到了裝飾作用，這就是傳說中的裝飾器。它其實就是個普通的函數。

如果你覺得有點懵逼，需要加強一些對 Python 函數的理解。函數：

1. 可以作爲參數傳遞

2. 可以作爲返回值

3. 也可以定義在函數內部

要深入瞭解函數，請關注我的公衆號：麥叔編程。

然後，我們不再直接調用 step1, 而是：

1. 先調用 timer 函數，生成一個包裝了 step1 的新的函數 timed_step1.

2. 剩下的就是調用這個新的函數 time_step1()，它會幫我們記錄時間。

timed_step1 = timer(step1)
timed_step1()

簡潔點，也可以這樣寫:

timer(step1)()
timer(step2)()
timer(step3)()

這樣可以在不修改原有函數代碼的情況下，給函數添加了裝飾性的新功能。

但是仍然需要修改調用函數的地方，看起來還不夠簡潔。有沒有更好的辦法呢？當然是有的！

裝飾器語法糖衣

我們可以在被裝飾的函數前使用 @符號指定裝飾器。這樣就不用修改調用的地方了，這個世界清淨了。下面的代碼和上一段代碼功能一樣。在運行程序的時候，Python 解釋器會根據 @標註自動生成裝飾器函數，並調用裝飾器函數。

import time

def timer(func):
 '''統計函數運行時間的裝飾器'''
 def wrapper():
  start = time.time()
  func()
  end = time.time()
  used = end - start
  print(f'{func.__name__} used {used}')
 return wrapper

@timer
def step1():
 print('step1.......')

@timer
def step2():
 print('step2......')

@timer
def step3():
 print('step3......')

step1()
step2()
step3()

到了這裏，裝飾器的核心概念就講完了。

剩下的基本都是在不同場合下的應用。如果你是大忙人，不想學的太深，可以蒐藏本文章，以後再回來看。

但是記得點在看。據說點了得都變帥了，也找到了好工作，或者升職加薪了。

進階用法

上面是一個最簡單的例子，被裝飾的函數既沒有參數，也沒有返回值。下面來看有參數和返回值的情況。

帶參數的函數

我們把 step1 修改一下，傳入一個參數，表示要走幾步。

import time

def timer(func):
 '''統計函數運行時間的裝飾器'''
 def wrapper():
  start = time.time()
  func()
  end = time.time()
  used = end - start
  print(f'{func.__name__} used {used}')
 return wrapper

@timer
def step1(num):
 print(f'我走了#{num}步')

step1(5)

再去運行，就報錯了：

TypeError: wrapper() takes 0 positional arguments but 1 was given

這是因爲，表面上我們寫的是 step1(5)，實際上 Python 是先調用 wrapper() 函數。這個函數不接受參數，所以報錯了。

爲了解決這個問題，我們只要給 wrapper 加上參數就可以。

import time

def timer(func):
 '''統計函數運行時間的裝飾器'''
 def wrapper(*args, **kwargs):
  start = time.time()
  func(*args, **kwargs)
  end = time.time()
  used = end - start
  print(f'{func.__name__} used {used}')
 return wrapper

1. wrapper 使用了通配符，*args 代表所有的位置參數，**kwargs 代表所有的關鍵詞參數。這樣就可以應對任何參數情況。

2. wrapper 調用被裝飾的函數的時候，只要原封不動的把參數再傳遞進去就可以了。

如果對關鍵詞參數和位置參數不明白，可以在 B 站搜索 "麥叔 參數"，學習相關視頻。

函數返回值

如果被裝飾的函數 func 有返回值，wrapper 也只需把 func 的返回值返回就可以了。

import time

def timer(func):
 '''統計函數運行時間的裝飾器'''
 def wrapper(*args, **kwargs):
  start = time.time()
  ret_value = func(*args, **kwargs)
  end = time.time()
  used = end - start
  print(f'{func.__name__} used {used}')
  return ret_value
 return wrapper

@timer
def add(num1, num2):
 return num1 + num2

sum = add(5, 8)
print(sum)

這裏我新加了一個 add 函數，計算兩個數之和。

在 wrapper 函數中，我們先保存了 func 的返回值到 ret_value，然後在 wrapper 的最後返回這個值就可以了。

到這裏，你又進了一步，你可以擊敗 88.64% 的 Python 學習者了。但還不夠，後面還有：

• 類裝飾器 (上面都是函數裝飾器)

• 多裝飾器串聯

• 帶參數的裝飾器（不同於上面的帶參數的函數）

• 帶狀態的裝飾器

• 用類封裝裝飾器

• 裝飾器常用情況舉例

有位同學看完前面的內容，覺得自己掌握的很好了，就去面試。

結果被面試官一個 “如何在 Python 中實現單例模式” 的問題給當場問倒了。

氣得他上去就是兩個耳刮子，不過不是打面試官，是打自己，恨自己沒有等讀透整篇再去面試。所以大家都耐心讀完。

你一定用過裝飾器 Decorator

其實 Decorator 就在我們身邊，只是我們可能不知道它們是裝飾器。我來說幾個：@classmethod @staticmethod @property

有沒有一種 "我靠" 的衝動？！

對，這些很重要的語法，不過是裝飾器的應用而已。

來看一個代碼例子：

class Circle:
    #半徑用下劃線開頭，表示私有變量
    def __init__(self, radius):
        self._radius = radius

    #用property裝飾器創建虛擬的半徑屬性
    @property
    def radius(self):
        return self._radius

    #用setter裝飾器給半徑屬性添加賦值操作
    @radius.setter
    def radius(self, value):
        if value >= 0:
            self._radius = value
        else:
            raise ValueError("Radius must be positive")

    #用property裝飾器創建虛擬的面積屬性
    @property
    def area(self):
        return self.pi() * self.radius**2

    def cylinder_volume(self, height):
        return self.area * height

    #類方法
    @classmethod
    def unit_circle(cls):
        return cls(1)

    #靜態方法
    @staticmethod
    def pi():
        return 3.1415926535

再來創建兩個裝飾器練練手

你不要以爲你已經掌握了裝飾器，你只是聽懂了。

從聽懂到能動手寫出來，再到被面試的時候，可以流暢的說出來，那還差着二十萬八千里呢！

一定得多動手！所以抓緊時間，馬上再來創建兩個裝飾器。

代碼調試裝飾器

現在我們來創建一個裝飾器：它會打印函數的參數，以及返回值。

如果你有實際項目經驗，你一定會知道這個很有用。這不就是自動打印日誌嘛！是程序員找臭蟲的必備良藥啊。

來看看代碼：

def debug(func):
    def wrapper_debug(*args, **kwargs):
        print(f'{func.__name__}:{args}, {kwargs}')
        ret_val = func(*args, **kwargs)
        print(f'return: {ret_val}')
        return ret_val
    return wrapper_debug

@debug
def add(a, b):
    return a + b

add(1, 3)
add(2, 3)
add(4, 3)

在 wrapper_debug 函數中，我們先打印所有的參數，再調用原函數，最後先打印返回值，再返回返回值。這裏並沒有新的語法知識，就是爲了練手。

裝 B 神奇 - 讓程序跑慢點

曾經我還年輕，看到一個大神的代碼裏面有這麼一行：

sleep(random(1,5))

因爲有了這行代碼，程序運行的時候挺慢的。我就問大神，爲什麼要這樣。大神語重心長的跟我說：

你還年輕！我把這個程序交付給客戶，客戶會覺得有點慢，但還能忍。

忍不住了，會來找我優化性能。我一個手指頭就把性能優化上去了，客戶一定對我五體投地。而且我們公司的尾款也給我們了。

年輕人，多學着點！這就是閱歷，閱歷！

可惜我學了這麼多年，也沒學會這種閱歷。

不過有時候，因爲各種原因，我們確實需要讓程序變慢一點。裝飾器就排上了用場：

import time 

def slow(func):
    def wrapper_slow(*args, **kwargs):
        print(f'{func.__name__} sleeping 1 second')
        time.sleep(1)
        ret_val = func(*args, **kwargs)
        return ret_val
    return wrapper_slow


@slow
def add(a, b):
    return a + b

add(1, 3)

運行一下，你就會很有成就感！確實慢！

上面那個真實的段子，我勸大家和我一樣，一直都學不會。日久見人心，坑人的事情不能幹。

裝飾器模板

經過前面幾個例子，我們可以總結出一個裝飾器的模板。

按照這個模板，可以輕鬆寫出裝飾器：

def decorator(func):
    def wrapper_decorator(*args, **kwargs):
        #調用前操作
        ret_val = func(*args, **kwargs)
        #調用後操作
        return ret_val
    return wrapper_decorator

按照這個模板：

1. 修改裝飾器的名字，把 decorator 替換爲具體的名字。

2. 在註釋 “調用前操作” 的地方寫自己想寫的代碼

3. 在註釋 “調用後操作” 的地方寫自己想寫的代碼。

帶參數的裝飾器

上面那兩個都是普通的裝飾器的應用，我們不能繼續自 High 下去了。我們得學習新知識了。

上面那個 slow 的裝飾器，如果能夠傳入到底要 sleep 幾秒就好了，現在是固定的 1 秒，這個不香。

注意區分，這裏的參數是指裝飾器的參數。和前面提到的函數自身的參數是不同的。

我想讓它多慢就多慢，然後我們再頃刻間扭轉乾坤，這樣客戶就更爲我神魂顛倒了。

要讓裝飾器接受參數，需要在普通裝飾器的外面再套上一層：

import time 

def slow(seconds):
    def decorator_slow(func):
        def wrapper_slow(*args, **kwargs):
            print(f'{func.__name__} sleeping {seconds} second')
            time.sleep(seconds)
            ret_val = func(*args, **kwargs)
            return ret_val
        return wrapper_slow
    return decorator_slow


#添加裝飾器的時候可以傳入要放慢幾秒的參數。@slow(2)def add(a, b):
    return a + b

#執行此行會停頓2秒
add(1, 3)

以前的裝飾器，是函數里面有一個內部函數（2 層函數），現在這個有了 3 層函數：

• 先是 slow，接受秒數作爲參數

• slow 裏面創建了 decorator_slow 函數，這個就是和原來一樣的裝飾器函數

• wrapper_slow 裏面又創建了 wrapper_slow 函數。

其實後面兩層就是和之前一樣的，唯一的區別是外面又加了一層。

爲什麼會這樣呢？爲什麼最外面一層不需要傳入 func 參數呢？

這是因爲：

1. 當 Python 發現 slow(2) 這個裝飾器自帶了參數時，它就不再傳入當前函數作爲參數，直接調用 slow。這是 Python 解釋器規定的。

2. slow 返回了一個函數，這時候 Python 會再把當前函數傳入進去，這時候就成爲一個普通的裝飾器了。

這就是說最外面一層的功能就是爲了處理裝飾器的參數的。

如果你一下子不能理解，先把代碼敲出來，你就理解了。正所謂：熟讀唐詩三百首，不會吟詩也會吟！

再來看一個裝飾器帶參數的例子：

def repeat(nums=3):
    def decorator_repeat(func):
        def wrapper_repeat(*args, **kwargs):
            for _ in range(nums):
                func(*args, **kwargs)
        return wrapper_repeat
    return decorator_repeat

@repeat(3)
def run():
    print('跑步有利於身體健康，來一圈')

#這裏會重複執行3次
run()

這個裝飾和 slow 裝飾器一樣坑人，它會多次重複執行一個方法，並且可以動態指定要重複幾次。

細細品味一下這個 3 層的函數，它是如何實現帶參數的裝飾器的。這兩個例子都懂了，你就走在吊打面試官的路上了。

類裝飾器

還記得前面給自己兩個耳光的同學嗎？如果他現在去面試，還是給自己兩個耳光，還是不知道如何實現單例模式。

單例模式，是指一個類只能創建一個實例，是最常見的設計模式之一。

比如網站程序有一個類統計網站的訪問人數，這個類只能有一個實例。如果每次訪問都創建一個新的實例，那人數就永遠是 1 了。

在 Python 中可以用裝飾器實現單例模式。

前面的裝飾器都是用來裝飾函數的，或者用來裝飾類方法的，比如我們寫的 slow, debug, timer; Python 自帶的 staticmethod, classmethod 等。

那如果把裝飾器放到類名前面會怎樣呢？來看這段代碼：

from slow import slow 

@slow
class Counter():
    def __init__(self):
        self._count = 0
    
    def visit(self):
        self._count += 1
        print(f'visiting: {self._count}')

c1 = Counter()
c1.visit()
c1.visit()

c2 = Counter()
c2.visit()
c2.visit()

這個類名叫 Counter()，顧名思義就是用來做計數的。它有一個內部變量叫做_count，每次調用 Counter 的 visit() 方法，計數就會加 1.

第一行，我們引入了前面寫的 slow 裝飾器，是那個普通的不帶參數的 slow。裝飾器就是個函數，當然可以被 import 進來。

這次 @slow 放在 Counter 類名前面，而不是方法的前面，會發生什麼呢？運行上面的代碼，會發現這樣的結果：

Counter sleeping 1 second
visiting: 1
visiting: 2
Counter sleeping 1 second
visiting: 1
visiting: 2

這說明只有在創建 Counter 實例的時候，纔會 sleep 一秒，調用 visit 函數的時候，不會 sleep。

所以，類裝飾器實際上裝飾的是類的初始化方法。只有初始化的時候會裝飾一次。

用裝飾器實現單例模式

上面的運行結果很讓人失望，如果去面試，還是會給自己兩個耳刮子的。

作爲一個計數器，應該計數是不斷疊加的。

可是上面的代碼，創建了兩個計數器，自己記錄自己的。扯淡啊！

我們現在就用類裝飾器改造它:

def singleton(cls):
 '''創建一個單例模式'''
 def single_wrapper(*args, **kwargs):
    if not single_wrapper.instance:
       single_wrapper.instance = cls(*args, **kwargs)
    return single_wrapper.instance
    single_wrapper.instance = None
 return single_wrapper

@singleton
class Counter():
    def __init__(self):
        self._count = 0

    def visit(self):
        self._count += 1
        print(f'visiting: {self._count}')


c1 = Counter()
c1.visit()
c1.visit()

c2 = Counter()
c2.visit()
c2.visit()

先來運行一下：

visiting: 1
visiting: 2
visiting: 3
visiting: 4

結果很滿意，雖然創建了兩個 Counter，計數是記錄在一起的。這主要得益於這個新的裝飾器：

def singleton(cls):
 '''創建一個單例模式'''
 def single_wrapper(*args, **kwargs):
    #如果沒有實例，則創建實例
  if not single_wrapper.instance:
   single_wrapper.instance = cls(*args, **kwargs)
  #返回原來的實例，或者新的實例
    return single_wrapper.instance
  #給新創建的函數添加一個屬性保存實例
 single_wrapper.instance = None
 return single_wrapper

它和其他的裝飾器基本一樣，它的不同之處在於這一行：

single_wrapper.instance = None

在創建完函數後，又給函數添加了一個屬性，用來保存實例，開始爲 None，就是沒有實例。

再來分析一下代碼邏輯：

1. 先判斷是否有實例，如果沒有就創建一個。反過來，已經有了就不用創建。

2. 返回實例。

把這個裝飾器加到類上的時候，就相當於加到了初始化方法。

當我們創建 Counter 的時候，被這個裝飾器截胡，它會返回一個已經創建好的實例。如果沒有實例，它會創建一個。

也就是說，不管調用 Counter() 多少次，最終就只有一個實例。這就是實現了單例模式。

如果有點不懂，再看一遍，爲的是在面試官面前揚眉吐氣。

帶狀態的裝飾器

上面的例子中，我們看到裝飾器自己保存了一個實例，你要的時候它就給你這一個，所以才實現了單例模式。這種就叫做帶狀態的裝飾器。

我們再來看一個例子。count 裝飾器會記錄一個函數被調用的次數：

def count(func):
    def wrapper_count():
        wrapper_count.count += 1
        print(f'{func.__name__}：第{wrapper_count.count}次調用')
        func()
    wrapper_count.count = 0
    return wrapper_count

@count
def run():
    print('跑步有利於身體健康，來一圈')

run()
run()
run()

運行結果：

run：第1次調用
跑步有利於身體健康，來一圈
run：第2次調用
跑步有利於身體健康，來一圈
run：第3次調用
跑步有利於身體健康，來一圈

關鍵點就在於這一行：

wrapper_count.count = 0

給 wrapper_count 函數添加了 count 屬性，來記錄函數調用的次數，它也是一個有狀態的裝飾器。

多個裝飾器嵌套

一個函數只能有一個裝飾器嗎？

裝飾器的本質就是先調用裝飾器，裝飾器再調用函數。既然這樣，那麼多調用幾層也無妨吧。

來看這個例子：

import time
from slow import slow

def timer(func):
 def wrapper():
    start_time = time.perf_counter()
    func()
    end_time = time.perf_counter()
    used_time = end_time - start_time
    print(f'{func.__name__} used {used_time}')
 return wrapper

@slow
@timer
def run():
    print('跑步有利於身體健康，來一圈')

run()

這個例子中，run 函數用了兩個裝飾器，slow 和 timer。它的執行過程就相當於：

slow(time(run()))

從上到下調用，先是調用 slow，然後 slow 去調用 timer，然後 timer 去調用 run，所以執行結果是：

run sleeping 1 second
跑步有利於身體健康，來一圈
wrapper_slow used 1.0026384350000002

Python 裝飾器寶藏庫

差不多了，理解透這些原理，你就算不給面試官兩個耳刮子，至少也不用給自己了。相關問題就算不是對答如流，也能輕鬆應對吧。

裝飾器太重要了，有很多大神寫了各種各樣的裝飾器，Python 官方文檔爲了一份裝飾器列表，在搜索引擎搜：PythonDecoratorLibrary。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/7R7QsV5BflBk01-F8WMcBw