本文實例講述了Python裝飾器用法。分享給大家供大家參考，具體如下：

寫裝飾器

裝飾器只不過是一種函數(shù)，接收被裝飾的可調(diào)用對象作為它的唯一參數(shù)，然后返回一個可調(diào)用對象（就像前面的簡單例子）
注意重要的一點，當裝飾器被應用到被裝飾函數(shù)上時，裝飾器代碼本身就會運行，而不是當被裝飾函數(shù)被調(diào)用時.理解這個很關鍵，接下來的幾個例子的講解過程也會變得很清楚

第一個例子: 函數(shù)注冊

看下面簡單的函數(shù)注冊：

registry = []
def register(decorated):
 registry.append(decorated)
 return decorated

注冊器方法是一個簡單的裝飾器。它追加位置參數(shù)，也就是被裝飾函數(shù)到registry變量中，然后不做改變地返回被裝飾方法。任何接受register裝飾器的方法會把它自己追加到registry變量上。

@register
def foo():
 return 3
@register
def bar():
 return 5

如果你訪問了registry，可以很容易地在上面迭代并執(zhí)行里面的函數(shù)。

answers = []
for func in registry:
  answers.append(func())

answers 列表現(xiàn)在回包含 [3, 5]. 這是因為函數(shù)已按次序執(zhí)行,并且它們的返回值被追加到 answers中.

對于現(xiàn)有的函數(shù)注冊，有幾類簡單的應用，例如添加“鉤子（hooks）”到代碼中，這樣的話自定義的功能在條件事件之前或之后運行。 下面的Registry類能夠處理這種情況：

class Registry(object):
 def __init__(self):
  self._functions = []
 def register(self, decorated):
  self._functions.append(decorated)
  return decorated
 def run_all(self, *args, **kwargs):
   return_values = []
   for func in self._functions:
    return_values.append(func(*args, **kwargs))
   return return_values

這個類里的register方法讓然像之前一樣按同樣方法工作。用一個綁定（bound）的方法作為裝飾器完全沒問題。它接收self作為第一參數(shù)（像任何綁定方法一樣），并且需要一個額外的位置參數(shù)，那就是被裝飾函數(shù)，通過創(chuàng)建幾個不同的 registry實例，你可以擁有一些完全分開的注冊器。使用相同函數(shù)并且，用超過一個注冊器注冊它也是可行的，像下面展示的一樣 :

a = Registry()
b = Registry()
@a.register
def foo(x=3):
 return x
@b.register
def bar(x=5):
 return x
@a.register
@b.register
def baz(x=7):
 return x

運行兩個注冊器的run_alll方法,得到如下結果：

a.run_all() # [3, 7]
b.run_all() # [5, 7]

注意，run_all 方法能夠使用參數(shù)，當它們運行時會把參數(shù)傳給內(nèi)部函數(shù)

a.run_all(x=4) # [4, 4]

運行時包裝代碼

以上這些裝飾器都很簡單，因為被裝飾方法被傳遞后未經(jīng)更改。然而，有些時候當被裝飾方法執(zhí)行時,你想要運行額外的功能。你通過返回一個添加了相關功能并且在它執(zhí)行過程中調(diào)用被裝飾方法的不同的可調(diào)用對象來實現(xiàn)。

簡單的類型檢查

這有一個簡單的裝飾器，確保函數(shù)接收到的每一個參數(shù)都是整數(shù)，否則進行報告：

def requires_ints(decorated):
 def inner(*args, **kwargs):
  #獲取任何可能被發(fā)送的關鍵值參數(shù)
  kwarg_values = [i for i in kwargs.values()]
  #在發(fā)送給被裝飾方法的每個值上面進行迭代，確保每一個都是整數(shù)；
  #如果不是拋 TypeError 
  for arg in list(args) + kwarg_values:
   if not isinstance(arg, int):
    raise TypeError('%s only accepts integers as  
       arguments.' % decorated.__name__)        
    #運行被裝飾方法，返回結果
   return decorated(*args, **kwargs)
 return inner

發(fā)生了什么?

裝飾器是 requires_ints. 它接受一個參數(shù)，即被裝飾的可調(diào)用對象。這個裝飾器做的唯一事情是返回一個新的可調(diào)用對象，一個內(nèi)部的本地函數(shù)。這個函數(shù)替代了被裝飾的可調(diào)用對象。你可以看到它如何發(fā)揮作用，聲明一個函數(shù)并且用requires_ints來裝飾

@requires_ints
def foo(x, y):
"""Return the sum of x and y."""
 return x + y

注意如果你運行 help(foo)獲取的:

Help on function inner in module __main__:
inner(*args, **kwargs)
(END)

inner 函數(shù)已被指派了名字foo，而不是初始的，已定義了的函數(shù)。如果你運行 foo(3, 5), inner 函數(shù)會用這些參數(shù)來運行，inner函數(shù)進行類型檢查，然后運行被裝飾函數(shù)，因為inner函數(shù)調(diào)用它，使用decorated(*args, **kwargs)，返回8.沒有這個調(diào)用，被裝飾方法會被忽略。

保留helpPreserving the help

一般不想讓裝飾器破壞你的函數(shù)的docstring或者操縱help輸出。

因為裝飾器是用來添加通用的和可重用功能的工具，他們有必要更泛化些。

并且，通常來說如果有人使用一個函數(shù)試圖在上面運行help，他想要的是關于函數(shù)內(nèi)臟（guts）的信息，而不是外殼(shell)的信息。解決這個問題的方法實際上應用到了 … 仍然是裝飾器. Python 實現(xiàn)了一個叫做 @functools.wraps 的裝飾器，它復制一個函數(shù)的內(nèi)部元素到另一個函數(shù)。它把一個函數(shù)的重要的內(nèi)省元素（introspection elements）復制給另一個函數(shù)。

這是同一個@requires_ints 裝飾器, 但添加了@functools.wraps的使用：

import functools
def requires_ints(decorated):
 @functools.wraps(decorated)
 def inner(*args, **kwargs):
  #獲取可能已作為鍵值參數(shù)發(fā)送的任何值
  kwarg_values = [i for i in kwargs.values()]
  #迭代發(fā)送給被裝飾函數(shù)的每個值, 并
  #確保每個參數(shù)都是整數(shù)，否則拋TypeError
  for arg in args + kwarg_values:
   if not isinstance(i, int):
    raise TypeError('%s only accepts integers as 
     arguments.' %decorated.__name__)
  #運行被裝飾函數(shù)然后返回結果
  return decorated(*args, **kwargs)
 return inner

裝飾器本身幾乎沒有改變，除了第二行給inner函數(shù)使用了@functools.wraps裝飾器。你現(xiàn)在必須導入functools（在標準庫中）。你也會注意到些額外語法。這個裝飾器實際上使用了一個參數(shù)（稍后會有更多）。

現(xiàn)在你可以應用這個裝飾器給相同的函數(shù)，像下面這樣：

@requires_ints
def foo(x, y):
"""Return the sum of x and y."""
 return x + y

現(xiàn)在當你運行help(foo)的結果：

Help on function foo in module __main__:
foo(x, y)
Return the sum of x and y.
(END)

你看到了 foo的docstring ，同時還有它的方法簽名，然而在蓋頭（hood）下面,@requires_ints裝飾器仍然被應用,并且 inner函數(shù)仍然正常運行 。取決于你使用的python版本，運行結果可能稍有不同，尤其當忽略函數(shù)簽名時。前面的輸出源自Python 3.4。然而在python 2，提供的函數(shù)簽名仍然有點隱秘（因此，是*args和**kwargs而不是x和y）

用戶認證

這個模式（即在運行被裝飾方法前進行過濾驗證）的通常使用場景是用戶認證?？紤]一個需要user作為它的第一個參數(shù)的方法，user應該是User和AnonymousUser類的實例:

class User(object):
"""A representation of a user in our application."""
 def __init__(self, username, email):
  self.username = username
  self.email = email
class AnonymousUser(User):
"""An anonymous user; a stand-in for an actual user that nonetheless
is not an actual user.
"""
 def __init__(self):
  self.username = None
  self.email = None
 def __nonzero__(self):
  return False

裝飾器在此成為隔離用戶驗證的樣板代碼的有力工具。@requires_user裝飾器可以很輕松地認證你獲得了一個User對象并且不是匿名user

import functools
def requires_user(func):
 @functools.wraps(func)
 def inner(user, *args, **kwargs):
  """Verify that the user is truthy; if so, run the 
  decorated method,
  and if not, raise ValueError.
  """
  # Ensure that user is truthy, and of the correct type.
  # The "truthy"check will fail on anonymous users, since the
  # AnonymousUser subclass has a ‘__nonzero__‘ method that
  # returns False.
  if user and isinstance(user, User):
   return func(user, *args, **kwargs)
  else:
   raise ValueError('A valid user is required to run 
    this.')
 return inner

這個裝飾器應用了一個通用的，需要樣板化的驗證—-用戶是否登錄進系統(tǒng)的驗證。當你把它作為裝飾器導入，它可重用且易于管理，它應用至函數(shù)上也清晰明了。注意這個裝飾器只會正確地包裝一個函數(shù)或者靜態(tài)方法，如果包裝一個類的綁定方法就會失敗，這是因為裝飾器忽視了發(fā)送self作為第一個參數(shù)到綁定方法的需要。

格式化輸出

除了過濾一個函數(shù)的輸入，裝飾器的另一個用處是過濾一個函數(shù)的輸出。當你用Python工作時，只要可能就希望使用Python本地對象。然而通常想要一個序列化的輸出格式（例如，JSON）
在每個相關函數(shù)的結尾手動轉(zhuǎn)換成JSON會顯得很笨（也不是個好主意）。
理想的你應該使用Python數(shù)據(jù)結構直到需要序列化，但在序列化前仍然可能有其他重復代碼。
裝飾器為這個問題提供了一個出色的，輕便的解決方案。考慮下面的裝飾器，它采用python輸出，并序列化結果為JSON

import functools
import json
def json_output(decorated):
 """Run the decorated function, serialize the result of 
 that function
 to JSON, and return the JSON string.
 """
 @functools.wraps(decorated)
 def inner(*args, **kwargs):
  result = decorated(*args, **kwargs)
  return json.dumps(result)
 return inner

給一個 簡單函數(shù)應用@json_output 裝飾器 :

@json_output
def do_nothing():
 return {'status': 'done'}

在Python shell中運行這個函數(shù):

>>> do_nothing()
'{"status": "done"}'

結果是一個包含JSON的字符串，而不是一個字典。

這個裝飾器的優(yōu)美在于它的簡潔。把這個裝飾器應用到一個函數(shù)，本來返回python字典，列表或者其它對象的函數(shù)現(xiàn)在會返回它的JSON序列化的版本。你可能會問這有什么價值？畢竟你加了一行裝飾器，實質(zhì)上只移除了一行調(diào)用json.dumps的代碼。

然而，由于應用的需求會擴展，還是考慮一下?lián)碛写搜b飾器的價值。

例如，某種異常需要被捕獲，并以特定的格式化的json輸出，而不是讓異常上浮產(chǎn)生堆棧跟蹤，該怎么做？因為有裝飾器，這個功能很容易添加。

import functools
import json
class JSONOutputError(Exception):
 def __init__(self, message):
  self._message = message
 def __str__(self):
  return self._message
def json_output(decorated):
 """Run the decorated function, serialize the result of  
 that function
 to JSON, and return the JSON string.
 """
 @functools.wraps(decorated)
 def inner(*args, **kwargs):
  try:
   result = decorated(*args, **kwargs)
  except JSONOutputError as ex:
   result = {
   'status': 'error',
   'message': str(ex),
   }
  return json.dumps(result)
 return inner

通過使用錯誤處理增強@json_output裝飾器，你已經(jīng)把該功能添加給了應用了這個裝飾器的任何函數(shù)。

這是讓裝飾器如此有價值的部分原因。對于代碼輕便化，可重用化而言，它們是非常有用的工具。

現(xiàn)在，如果一個用@json_output裝飾的函數(shù)拋出了JSONOutputError異常,就會有特別的錯誤處理：

@json_output
def error():
 raise JSONOutputError('This function is erratic.')

運行error 函數(shù)：

>>> error()
'{"status": "error", "message": "This function is erratic."}'

注意，只有JSONOutputError異常類（或它的子類）會獲得這種特別的錯誤處理。任何其它異常會正常通過，并產(chǎn)生堆棧跟蹤。

實質(zhì)上，裝飾器是避免重復你自己的工具，并且它們的部分價值在于給未來的維護提供鉤子（hooks）。這些不用裝飾器也可以實現(xiàn)，考慮要求用戶登錄進系統(tǒng)的例子，寫一個函數(shù)并把它放在需要這項功能的函數(shù)的入口處就行了。裝飾器首先是一種語法糖（syntactic sugar）。然而是一種很有價值的語法糖。畢竟，相較于寫，代碼更多時候用來讀，而且你可以一眼定位到裝飾器的位置。

日志記錄Logging

執(zhí)行時包裝代碼的最后一個例子是一個通用的日志記錄函數(shù)。 考慮下面引起函數(shù)調(diào)用的裝飾器, 運行時間,
結果會被記錄:

import functools
import logging
import time
def logged(method):
 """Cause the decorated method to be run and its results  
 logged, along
 with some other diagnostic information.
 """
 @functools.wraps(method)
 def inner(*args, **kwargs): 
  #Record our start time.
  start = time.time()
  #Run the decorated method.
  return_value = method(*args, **kwargs)
  #Record our completion time, and calculate the delta.
  end = time.time()
  delta = end - start
  #Log the method call and the result.
  logger = logging.getLogger('decorator.logged')
  logger.warn('Called method %s at %.02f; execution time  
   %.02f seconds; result %r.' %
   (method.__name__, start, delta, return_value))    
   #Return the methods original return value.
  return return_value
 return inner

當應用到一個函數(shù)上后，這個裝飾器正常地運行那個函數(shù)，但函數(shù)調(diào)用結束后會使用Python logging模塊記錄信息。

>>> import time
>>> @logged… def sleep_and_return(return_value):
... time.sleep(2)
... return return_value…
>>>
>>> sleep_and_return(42)
Called method sleep_and_return at 1424462194.70;
execution time 2.00 seconds; result 42.
42

不像先前的例子，這個裝飾器不顯式地更改函數(shù)調(diào)用. 不存在你應用這個裝飾器后獲得的結果與沒有被裝飾的函數(shù)的結果不一樣的情況。這個裝飾器做了些幕后工作，但并不改變實際結果。
值得注意的是， @json_output 和 @logged 裝飾器都提供 inner 函數(shù) ，這個函數(shù)簡單地以最小的偵測采用和傳遞可變參數(shù)和關鍵字參數(shù)。

這是一種重要的模式。一種它尤其重要的方式是，許多裝飾器可能被用來裝飾純粹的函數(shù)和類的方法。記住，在Python中，類中聲明的方法會獲得一個額外位置參數(shù)，即廣為人知的self。當裝飾器在使用時，它不會改變 (這就是為什么先前的requires_user裝飾器在類的綁定方法上不起作用）

例如@json_result被用來裝飾一個類的方法，inner函數(shù)被調(diào)用，它接收一個類的實例作為第一個參數(shù)。實際上這沒有問題。在這種情況下，這個參數(shù)就是args[0]，它被傳送給被裝飾方法。

裝飾器參數(shù)

到目前為止列出的所有裝飾器都沒有任何參數(shù)。作為討論過的內(nèi)容，有一個暗含的參數(shù)–被裝飾的方法。然而，有時讓裝飾器自身使用一些它需要的信息去裝飾相關方法會有用處。

一個參數(shù)傳給一個裝飾器和一個參數(shù)傳給一個正在調(diào)用的方法之間的不同是，當一個函數(shù)被聲明并被裝飾，傳給裝飾器的參數(shù)會被立刻處理。相反，傳給函數(shù)的參數(shù)在函數(shù)調(diào)用時被處理。通過@functools.wraps的多次使用，你已經(jīng)看到了一個參數(shù)傳給裝飾器的例子。它使用一個參數(shù)—-被包裝的方法，方法的help和docstring等類似的東西應該被保留。然而，裝飾器有內(nèi)含的調(diào)用簽名。他們使用一個位置參數(shù)–被裝飾的方法。所以，這是怎么工作的？答案說來就復雜了。

回想運行時包裝代碼的基本裝飾器 ，他們在局部范圍聲明了一個 inner 方法 然后返回它. 這就是由裝飾器返回的可調(diào)用對象. 它被指派了被調(diào)用函數(shù)的名字. 使用參數(shù)的裝飾器多添加一個包裝層，這是因為，使用參數(shù)的裝飾器不再是一個實際的裝飾器。它是一個返回裝飾器的函數(shù)，是一個使用一個參數(shù)（被裝飾的方法）的函數(shù)。然后裝飾函數(shù)并返回一個可調(diào)用對象。聽起來混亂，考慮下面的例子，在這里，裝飾器@json_output的功能被增強了，要求縮進和排序：

import json
class JSONOutputError(Exception):
 def __init__(self, message):
  self._message = message
 def __str__(self):
  return self._message
def json_output(indent=None, sort_keys=False):
 """Run the decorated function, serialize the result of 
 that function
 to JSON, and return the JSON string.
 """
 def actual_decorator(decorated):
  @functools.wraps(decorated)
  def inner(*args, **kwargs):
   try:
     result = decorated(*args, **kwargs)
   except JSONOutputError as ex:
     result = {
     'status': 'error',
     'message': str(ex),
     }
   return json.dumps(result, indent=indent,   
    sort_keys=sort_keys)
   return inner
 return actual_decorator

那么，發(fā)生了什么，為什么這回起作用？這是一個函數(shù)，json_output，接收兩個參數(shù)(indent 和 sort_keys). 它返回另一個函數(shù), 叫 actual_decorator, 這是 (如同名字表名的) 要作為裝飾器使用的. 這是一個典型的裝飾器—一個接收可調(diào)用對象(被裝飾的)做參數(shù)的可調(diào)用對象，并且返回一個可調(diào)用對象(inner).

注意函數(shù)已經(jīng)有所改變來容納indent和sort_keys參數(shù)。

inner 函數(shù)是最終使用 indent 和 sort_keys 參數(shù)的. 這沒有問題，因為Python的塊作用域規(guī)則允許這樣。使用不同的indent和sort_keys來調(diào)用也不成問題，因為inner是本地函數(shù)（每次裝飾器被使用都會返回一個不同的副本）應用 json_output 函數(shù):

@json_output(indent=4)
def do_nothing():
 return {'status': 'done'}

現(xiàn)在運行do_nothing ， 會產(chǎn)生一個帶縮進的JSON:

>>> do_nothing()
'{\n   "status": "done"\n}'

這是怎么起作用的?

但是，等一等. 如果json_output 不是一個裝飾器, 而是一個返回裝飾器的函數(shù)，為什么它使用起來看著像是一個裝飾器？在這里，Python解釋器做了什么來讓它工作的？更多的解釋已經(jīng)就緒。在這的關鍵是操作順序。

特別地，函數(shù)調(diào)用(json_output(indent=4)) 先于裝飾器應用語法(@)被處理 。因此，函數(shù)調(diào)用的結果會應用給裝飾器。

發(fā)生的第一件事情是解釋器尋找 json_output 函數(shù)調(diào)用，然后解析這個調(diào)用：

@json_output(indent=4)
def do_nothing():
 return {'status': 'done'}

json_output 函數(shù)所要做的一切就是定義另一個函數(shù)， actual_decorator, 然后返回它. 這個函數(shù)的結果會提供給@，像下面這樣:

@actual_decorator
def do_nothing():
 return {'status': 'done'}

現(xiàn)在， actual_decorator 在運行. 它聲明另一個本地函數(shù), inner, 并返回它. 像先前討論過的,這個函數(shù)會被指派名字 do_nothing, 被裝飾方法的名字. 當do_nothing被調(diào)用, inner 函數(shù)就會被調(diào)用, 運行被裝飾方法, JSON使用合適縮進 調(diào)用dumps 處理結果

調(diào)用簽名很重要

當你引進了你的新的，更改過后的json_output函數(shù)，你實際引進了一個反向不兼容（backward-incompatible ）的改變，意識到這點很重要。

為什么？因為現(xiàn)在期待一個額外的函數(shù)調(diào)用。如果你想要舊的json_output的行為，不需要任何可用的參數(shù)的值，你仍然必須調(diào)用這個方法
換句話說，你必須像下面這樣做：

@json_output()
def do_nothing():
 return {'status': 'done'}

注意圓括號. 它們有影響，因為它們指出了函數(shù)正在被調(diào)用（即便沒有參數(shù)），然后結果應用給@.
前面的代碼不等價于下面：

@json_output
def do_nothing():
 return {'status': 'done'}

這呈現(xiàn)出兩個問題。有點讓人迷惑，如果你習慣于看到不帶簽名的裝飾器的應用，提供一個空簽名的需要就違背直覺。

第二，如果舊的裝飾器在你的應用中已經(jīng)存在，你必須返回并編輯所有它們的現(xiàn)有的調(diào)用。如果可能的話，你應該避免反向不減容（backward-incompatible）改變。
完美的情況下，下面三種不同的使用方式，裝飾器都會工作

@json_output
@json_output()
@json_output(indent=4)

讓裝飾器基于接收到的參數(shù)來改變它的行為是可能的。記住，裝飾器只是一個函數(shù)，擁有任何其它函數(shù)所擁有的所有靈活性，包括對它獲取到的輸入做出需要做出的響應。

考慮這個對 json_output的更加靈活的迭代:

import functools
import json
class JSONOutputError(Exception):
 def __init__(self, message):
  self._message = message
 def __str__(self):
  return self._message
def json_output(decorated_=None, indent=None, sort_keys=False):
 """Run the decorated function, serialize the result of that function
 to JSON, and return the JSON string.
 """
 # Did we get both a decorated method and keyword arguments?
 # That should not happen.
 if decorated_ and (indent or sort_keys):
  raise RuntimeError('Unexpected arguments.')
 # Define the actual decorator function.
 def actual_decorator(func):
  @functools.wraps(func)
  def inner(*args, **kwargs):
   try:
    result = func(*args, **kwargs)
   except JSONOutputError as ex:
    result = {
    'status': 'error',
    'message': str(ex),
    }
   return json.dumps(result, indent=indent,  
    sort_keys=sort_keys)
  return inner
 #Return either the actual decorator, or the result of applying
 #the actual decorator, depending on what arguments we got.
 if decorated_:
  return actual_decorator(decorated_)
 else:
  return actual_decorator

在目前是不是正作為裝飾器使用這一方面，這個函數(shù)正努力變得智能。

首先，它確保它不會以出乎意料的方式被調(diào)用

你永遠不要期待接收被裝飾方法同時關鍵值參數(shù)，因為裝飾器被調(diào)用時總是以被裝飾方法作為唯一參數(shù)。

第二，它定義了actual_decorator函數(shù)，這是要被返回和應用的實際裝飾器。它定義了inner 函數(shù)，它時從裝飾器中返回的最終函數(shù)。

最終, 它返回合適結果，這基于它被如何調(diào)用：

如果 設置了decorated_ , 它會被作為純粹的裝飾器調(diào)用, 沒有方法簽名，然后它的響應應用給最終裝飾器并返回inner函數(shù) . 再次注意使用參數(shù)的裝飾器如何實際地運作。首先, actual_decorator(decorated_)被調(diào)用，解析。然后它的結果（必須是一個可調(diào)用對象，因為這是一個裝飾器）被調(diào)用，inner被提供作為唯一的參數(shù)。

如果decorated_沒被設置，就會使用關鍵字參數(shù)調(diào)用，這個函數(shù)必須返回一個實際的裝飾器，它接收被裝飾方法，并返回inner。因此，這個函數(shù)返回actual_decorator
然后這會被python解釋器作為實際裝飾器（最終返回inner）

為何這個技術有價值？它讓你能夠先先前使用過的一樣管理你的裝飾器的功能。意味著你不用去更新已經(jīng)應用了裝飾器的每個地方，但仍然獲得了在你需要時添加參數(shù)的靈活性。

更多關于Python相關內(nèi)容感興趣的讀者可查看本站專題：《Python數(shù)據(jù)結構與算法教程》、《Python加密解密算法與技巧總結》、《Python編碼操作技巧總結》、《Python函數(shù)使用技巧總結》、《Python字符串操作技巧匯總》及《Python入門與進階經(jīng)典教程》

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

最新評論