本文例項講述了python 裝飾器功能與用法。分享給大家供大家參考，具體如下：

1、必備

#### 第一波 ####
def foo():
  print 'foo'
 
foo   #表示是函式
foo()  #表示執行foo函式
 
#### 第二波 ####
def foo():
  print 'foo'
 
foo = lambda x: x + 1
foo()  # 執行下面的lambda表示式，而不再是原來的foo函式，因為函式 foo 被重新定義了

2、需求來了

初創公司有N個業務部門，1個基礎平臺部門，基礎平臺負責提供底層的功能，如：資料庫操作、redis呼叫、監控API等功能。業務部門使用基礎功能時，只需呼叫基礎平臺提供的功能即可。如下：

############### 基礎平臺提供的功能如下 ###############
def f1():
  print 'f1'
 
def f2():
  print 'f2'
 
def f3():
  print 'f3'
 
def f4():
  print 'f4'
 
############### 業務部門A 呼叫基礎平臺提供的功能 ###############
f1()
f2()
f3()
f4()
 
############### 業務部門B 呼叫基礎平臺提供的功能 ###############
f1()
f2()
f3()
f4()

目前公司有條不紊的進行著，但是，以前基礎平臺的開發人員在寫程式碼時候沒有關注驗證相關的問題，即：基礎平臺的提供的功能可以被任何人使用。現在需要對基礎平臺的所有功能進行重構，為平臺提供的所有功能新增驗證機制，即：執行功能前，先進行驗證。

老大把工作交給 Low B，他是這麼做的：

跟每個業務部門交涉，每個業務部門自己寫程式碼，呼叫基礎平臺的功能之前先驗證。誒，這樣一來基礎平臺就不需要做任何修改了。

當天Low B 被開除了...

老大把工作交給 Low BB，他是這麼做的：

只對基礎平臺的程式碼進行重構，讓N業務部門無需做任何修改

############### 基礎平臺提供的功能如下 ############### 

def f1():
  # 驗證1
  # 驗證2
  # 驗證3
  print 'f1'

def f2():
  # 驗證1
  # 驗證2
  # 驗證3
  print 'f2'

def f3():
  # 驗證1
  # 驗證2
  # 驗證3
  print 'f3'

def f4():
  # 驗證1
  # 驗證2
  # 驗證3
  print 'f4'
############### 業務部門不變 ############### 
### 業務部門A 呼叫基礎平臺提供的功能### 

f1()
f2()
f3()
f4()

### 業務部門B 呼叫基礎平臺提供的功能 ### 

f1()
f2()
f3()
f4()

過了一週 Low BB 被開除了...

老大把工作交給 Low BBB，他是這麼做的：

只對基礎平臺的程式碼進行重構，其他業務部門無需做任何修改

############### 基礎平臺提供的功能如下 ############### 

def check_login():
  # 驗證1
  # 驗證2
  # 驗證3
  pass

def f1():
  
  check_login()

  print 'f1'

def f2():
  
  check_login()

  print 'f2'

def f3():
  
  check_login()

  print 'f3'

def f4():
  
  check_login()
  
  print 'f4'

老大看了下Low BBB 的實現，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：

老大說：

寫程式碼要遵循開發封閉原則，雖然在這個原則是用的面向物件開發，但是也適用於函數語言程式設計，簡單來說，它規定已經實現的功能程式碼不允許被修改，但可以被擴充套件，即：

封閉：已實現的功能程式碼塊
開放：對擴充套件開發

如果將開放封閉原則應用在上述需求中，那麼就不允許在函式 f1 、f2、f3、f4的內部進行修改程式碼，老闆就給了Low BBB一個實現方案：

def w1(func):
  def inner():
    # 驗證1
    # 驗證2
    # 驗證3
    return func()
  return inner
 
@w1
def f1():
  print 'f1'
@w1
def f2():
  print 'f2'
@w1
def f3():
  print 'f3'
@w1
def f4():
  print 'f4'

對於上述程式碼，也是僅僅對基礎平臺的程式碼進行修改，就可以實現在其他人呼叫函式 f1 f2 f3 f4 之前都進行【驗證】操作，並且其他業務部門無需做任何操作。

Low BBB心驚膽戰的問了下，這段程式碼的內部執行原理是什麼呢？

老大正要生氣，突然Low BBB的手機掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，交定了Low BBB這個朋友。詳細的開始講解了：

單獨以f1為例：

def w1(func):
  def inner():
    # 驗證1
    # 驗證2
    # 驗證3
    return func()
  return inner
@w1
def f1():
  print 'f1'

當寫完這段程式碼後（函式未被執行、未被執行、未被執行），python直譯器就會從上到下解釋程式碼，步驟如下：

def w1(func): ==>將w1函式載入到記憶體
@w1

沒錯，從表面上看直譯器僅僅會解釋這兩句程式碼，因為函式在沒有被呼叫之前其內部程式碼不會被執行。

從表面上看直譯器著實會執行這兩句，但是 @w1 這一句程式碼裡卻有大文章，@函式名 是python的一種語法糖。

如上例@w1內部會執行一下操作：

• 執行w1函式，並將 @w1 下面的函式作為w1函式的引數，即：@w1 等價於 w1(f1)
  所以，內部就會去執行：
  

    def inner:
      #驗證
      return f1()  # func是引數，此時 func 等於 f1
    return inner   # 返回的 inner，inner代表的是函式，非執行函式

• 其實就是將原來的 f1 函式塞進另外一個函式中
• 將執行完的 w1 函式返回值賦值給@w1下面的函式的函式名
  w1函式的返回值是：
  def inner:
  #驗證
  return 原來f1() # 此處的 f1 表示原來的f1函式
  然後，將此返回值再重新賦值給 f1，即：
  新f1 =def inner:
  #驗證
  return 原來f1()
  所以，以後業務部門想要執行 f1 函式時，就會執行 新f1 函式，在 新f1 函式內部先執行驗證，再執行原來的f1函式，然後將 原來f1 函式的返回值 返回給了業務呼叫者。
  如此一來， 即執行了驗證的功能，又執行了原來f1函式的內容，並將原f1函式返回值 返回給業務呼叫著

Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！

先把上述流程看懂，之後還會繼續更新...

3、問答時間

問題：被裝飾的函式如果有引數呢？

一個引數：

def w1(func):
  def inner(arg):
    # 驗證1
    # 驗證2
    # 驗證3
    return func(arg)
  return inner

@w1
def f1(arg):
  print 'f1'

兩個引數：

def w1(func):
  def inner(arg1,arg2):
    # 驗證1
    # 驗證2
    # 驗證3
    return func(arg1,arg2)
  return inner

@w1
def f1(arg1,arg2):
  print 'f1'

三個引數：

def w1(func):
  def inner(arg1,arg2,arg3):
    # 驗證1
    # 驗證2
    # 驗證3
    return func(arg1,arg3)
  return inner

@w1
def f1(arg1,arg3):
  print 'f1'

問題：可以裝飾具有處理n個引數的函式的裝飾器？

def w1(func):
  def inner(*args,**kwargs):
    # 驗證1
    # 驗證2
    # 驗證3
    return func(*args,**kwargs)
  return inner
 
@w1
def f1(arg1,arg3):
  print 'f1'

問題：一個函式可以被多個裝飾器裝飾嗎？

def w1(func):
  def inner(*args,**kwargs)
  return inner
 
def w2(func):
  def inner(*args,**kwargs)
  return inner
 
@w1
@w2
def f1(arg1,arg3):
  print 'f1'

問題：還有什麼更吊的裝飾器嗎？

#!/usr/bin/env python
#coding:utf-8
 
def Before(request,kargs):
  print 'before'
   
def After(request,kargs):
  print 'after'
 
 
def Filter(before_func,after_func):
  def outer(main_func):
    def wrapper(request,kargs):
       
      before_result = before_func(request,kargs)
      if(before_result != None):
        return before_result;
       
      main_result = main_func(request,kargs)
      if(main_result != None):
        return main_result;
       
      after_result = after_func(request,kargs)
      if(after_result != None):
        return after_result;
       
    return wrapper
  return outer
   
@Filter(Before,After)
def Index(request,kargs):
  print 'index'

4、functools.wraps

上述的裝飾器雖然已經完成了其應有的

功能，即：裝飾器內的函式代指了原函式，注意其只是代指而非相等，原函式的元資訊沒有被賦值到裝飾器函式內部。例如：函式的註釋資訊

無元資訊：

def outer(func):
  def inner(*args,**kwargs):
    print(inner.__doc__) # None
    return func()
  return inner

@outer
def function():
  """
  asdfasd
  :return:
  """
  print('func')

如果使用@functools.wraps裝飾裝飾器內的函式，那麼就會代指元資訊和函式。

含元資訊：

def outer(func):
  @functools.wraps(func)
  def inner(*args,**kwargs):
    print(inner.__doc__) # None
    return func()
  return inner

@outer
def function():
  """
  asdfasd
  :return:
  """
  print('func')

更多關於Python相關內容感興趣的讀者可檢視本站專題：《Python面向物件程式設計入門與進階教程》、《Python資料結構與演算法教程》、《Python函式使用技巧總結》、《Python字串操作技巧彙總》、《Python編碼操作技巧總結》及《Python入門與進階經典教程》

希望本文所述對大家Python程式設計有所幫助。