來源：麥叔編程

作者：麥叔

之前發(fā)過兩篇裝飾器的文章，當時為了博取眼球，標題取得虛頭巴腦?，F在把兩篇合并在一起，重新發(fā)在『Python終結者』系列中，方便大家學習。

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

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

就算一周學透一個重要知識點，不久之后，你就會成為很厲害的存在！加油??！

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

它經常使用在很多地方，比如Web開發(fā)，日志處理，性能搜集，權限控制等。

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

實戰(zhàn)入門

拋出問題

看這段代碼：

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

step1()
step2()
step3()

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

笨辦法解決

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

• 第一行記錄開始時間
• 執(zhí)行完業(yè)務邏輯記錄結束時間
• 結束時間減去開始時間，算出函數執(zhí)行用時

下面的例子只在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): '''統(tǒng)計函數運行時間的裝飾器''' 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函數的理解。函數：

可以作為參數傳遞

可以作為返回值

也可以定義在函數內部

然后，我們不再直接調用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): '''統(tǒng)計函數運行時間的裝飾器''' 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): '''統(tǒng)計函數運行時間的裝飾器''' 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): '''統(tǒng)計函數運行時間的裝飾器''' 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): '''統(tǒng)計函數運行時間的裝飾器''' 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學習者了。但還不夠，后面還有：

• 類裝飾器(上面都是函數裝飾器)
• 多裝飾器串聯(lián)
• 帶參數的裝飾器（不同于上面的帶參數的函數）
• 帶狀態(tài)的裝飾器
• 用類封裝裝飾器
• 裝飾器常用情況舉例

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

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

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

你一定用過裝飾器Decorator

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

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

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

來看一個代碼例子：

class Circle: #半徑用下劃線開頭，表示私有變量 def __init__(self, radius): self._radius = radius #用property裝飾器創(chuàng)建虛擬的半徑屬性 @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裝飾器創(chuàng)建虛擬的面積屬性 @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) #靜態(tài)方法 @staticmethod def pi(): return 3.1415926535 

再來創(chuàng)建兩個裝飾器練練手

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

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

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

代碼調試裝飾器

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

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

來看看代碼：

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))

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

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

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

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

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

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

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. 在注釋“調用后操作”的地方寫自己想寫的代碼。

帶參數的裝飾器

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

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

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

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

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

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 #執(zhí)行此行會停頓2秒 add(1, 3)

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

• 先是slow，接受秒數作為參數
• slow里面創(chuàng)建了decorator_slow函數，這個就是和原來一樣的裝飾器函數
• wrapper_slow里面又創(chuàng)建了wrapper_slow函數。

其實后面兩層就是和之前一樣的，唯一的區(qū)別是外面又加了一層。

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

這是因為：

1. 當Python發(fā)現slow(2)這個裝飾器自帶了參數時，它就不再傳入當前函數作為參數，直接調用slow。這是Python解釋器規(guī)定的。
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('跑步有利于身體健康，來一圈') #這里會重復執(zhí)行3次 run()

這個裝飾和slow裝飾器一樣坑人，它會多次重復執(zhí)行一個方法，并且可以動態(tài)指定要重復幾次。

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

類裝飾器

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

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

比如網站程序有一個類統(tǒng)計網站的訪問人數，這個類只能有一個實例。如果每次訪問都創(chuàng)建一個新的實例，那人數就永遠是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類名前面，而不是方法的前面，會發(fā)生什么呢？運行上面的代碼，會發(fā)現這樣的結果：

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

這說明只有在創(chuàng)建Counter實例的時候，才會sleep一秒，調用visit函數的時候，不會sleep。

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

用裝飾器實現單例模式

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

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

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

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

def singleton(cls): '''創(chuàng)建一個單例模式''' 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 

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

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

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

single_wrapper.instance = None

在創(chuàng)建完函數后，又給函數添加了一個屬性，用來保存實例，開始為None，就是沒有實例。

再來分析一下代碼邏輯：

1. 先判斷是否有實例，如果沒有就創(chuàng)建一個。反過來，已經有了就不用創(chuàng)建。
2. 返回實例。

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

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

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

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

帶狀態(tài)的裝飾器

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

我們再來看一個例子。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屬性，來記錄函數調用的次數，它也是一個有狀態(tài)的裝飾器。

多個裝飾器嵌套

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

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

來看這個例子：

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。它的執(zhí)行過程就相當于：