Python高階特性（2）：Closures、Decorators和functools

裝飾器(Decorators)

裝飾器是這樣一種設計模式：如果一個類希望新增其他類的一些功能，而不希望通過繼承或是直接修改原始碼實現，那麼可以使用裝飾器模式。簡單來說Python中的裝飾器就是指某些函式或其他可呼叫物件，以函式或類作為可選輸入引數，然後返回函式或類的形式。通過這個在Python2.6版本中被新加入的特性可以用來實現裝飾器設計模式。

順便提一句，在繼續閱讀之前，如果你對Python中的閉包(Closure)概念不清楚，請檢視本文結尾後的附錄，如果沒有閉包的相關概念，很難恰當的理解Python中的裝飾器。

在Python中，裝飾器被用於用@語法糖修辭的函式或類。現在讓我們用一個簡單的裝飾器例子來演示如何做一個函式呼叫日誌記錄器。在這個例子中，裝飾器將時間格式作為輸入引數，在呼叫被這個裝飾器裝飾的函式時打印出函式呼叫的時間。這個裝飾器當你需要手動比較兩個不同演算法或實現的效率時很有用。

def logged(time_format):
   def decorator(func):
      def decorated_func(*args, **kwargs):
         print &quot;- Running &#039;%s&#039; on %s &quot; % (
                                         func.__name__,
                                         time.strftime(time_format)
                              )
         start_time = time.time()
         result = func(*args, **kwargs)
         end_time = time.time()
         print &quot;- Finished &#039;%s&#039;, execution time = %0.3fs &quot; % (
                                         func.__name__,
                                         end_time - start_time
                              )

         return result
     decorated_func.__name__ = func.__name__
     return decorated_func
 return decorator

12345678910111213141516171819

def logged(time_format):def decorator(func):def decorated_func(*args,**kwargs):print"-Running'%s' on %s " % (func.__name__,time.strftime(time_format))start_time=time.time()result=func(*args,**kwargs

)end_time=time.time()print"-Finished'%s', execution time = %0.3fs " % (func.__name__,end_time-start_time)returnresultdecorated_func.__name__=func.__name__returndecorated_funcreturndecorator

來看一個例子，在這裡add1和add2函式被logged修飾，下面給出了一個輸出示例。請注意在這裡時間格式引數是儲存在被返回的裝飾器函式中(decorated_func)。這就是為什麼理解閉包對於理解裝飾器來說很重要的原因。同樣也請注意返回函式的名字是如何被替換為原函式名的，以防萬一如果它還要被使用到，這是為了防止混淆。Python預設可不會這麼做。

@logged(&quot;%b %d %Y - %H:%M:%S&quot;)
def add1(x, y):
    time.sleep(1)
    return x + y

@logged(&quot;%b %d %Y - %H:%M:%S&quot;)
def add2(x, y):
    time.sleep(2)
    return x + y

print add1(1, 2)
print add2(1, 2)

# Output:
- Running &#039;add1&#039; on Jul 24 2013 - 13:40:47
- Finished &#039;add1&#039;, execution time = 1.001s
3
- Running &#039;add2&#039; on Jul 24 2013 - 13:40:48
- Finished &#039;add2&#039;, execution time = 2.001s
3

1234567891011121314151617181920

@logged("%b%d%Y-%H:%M:%S")def add1(x,y):time.sleep(1)returnx+y@logged("%b%d%Y-%H:%M:%S")def add2(x,y):time.sleep(2)returnx+yprint add1(1,2)print add2(1,2)# Output:-Running'add1' on Jul 24 2013 - 13:40:47-Finished'add1', execution time = 1.001s3-Running'add2' on Jul 24 2013 - 13:40:48-Finished'add2', execution time = 2.001s3

如果你足夠細心，你可能會注意到我們對於返回函式的名字__name__有著特別的處理，但對其他的注入__doc__或是__module__則沒有如此。所以如果，在這個例子中add函式有一個doc字串的話，它就會被丟棄。那麼該如何處理呢？我們當然可以像處理__name__那樣對待所有的欄位，不過如果在每個裝飾器內都這麼做的話未免太繁冗了。這就是為何functools模組提供了一個名為wraps的裝飾器的原因，那正是為了處理這種情況。可能在理解裝飾器的過程中會被迷惑，不過當你把裝飾器看成是一個接收函式名作為輸入引數並且返回一個函式，這樣就很好理解了。我們將在下個例子中使用wraps裝飾器而不是手動去處理__name__或其他屬性。

下個例子會有點複雜，我們的任務是將一個函式呼叫的返回結果快取一段時間，輸入引數決定快取時間。傳遞給函式的輸入引數必須是可雜湊的物件，因為我們使用包含呼叫輸入引數的tuple作為第一個引數，第二個引數則為一個frozenset物件，它包含了關鍵詞項kwargs，並且作為cache key。每個函式都會有一個唯一的cache字典儲存在函式的閉包內。

【譯註】set和frozenset為Python的兩種內建集合，其中前者為可變物件(mutable)，其元素可以使用add()或remove()進行變更，而後者為不可變物件(imutable)並且是可雜湊的(hashable)，在建立之後元素不可變，他可以作為字典的key或是另一個集合的元素。

import time
from functools import wraps

def cached(timeout, logged=False):
    &quot;&quot;&quot;Decorator to cache the result of a function call.
    Cache expires after timeout seconds.
    &quot;&quot;&quot;
    def decorator(func):
        if logged:
            print &quot;-- Initializing cache for&quot;, func.__name__
        cache = {}

        @wraps(func)
        def decorated_function(*args, **kwargs):
            if logged:
                print &quot;-- Called function&quot;, func.__name__
            key = (args, frozenset(kwargs.items()))
            result = None
            if key in cache:
                if logged:
                    print &quot;-- Cache hit for&quot;, func.__name__, key

                (cache_hit, expiry) = cache[key]
                if time.time() - expiry &lt; timeout:
                    result = cache_hit
                elif logged:
                    print &quot;-- Cache expired for&quot;, func.__name__, key
            elif logged:
                print &quot;-- Cache miss for&quot;, func.__name__, key

            # No cache hit, or expired
            if result is None:
                result = func(*args, **kwargs)

            cache[key] = (result, time.time())
            return result

        return decorated_function

    return decorator

12345678910111213141516171819202122232425262728293031323334353637383940

import timefrom functools import wrapsdef cached(timeout,logged=False):"""Decorator tocache the result ofafunctioncall.Cache expires after timeout seconds."""def decorator(func):iflogged:print"--Initializing cache for",func.__name__cache={}@wraps(func)def decorated_function(*args,**kwargs):iflogged:print"--Called function",func.__name__key=(args,frozenset(kwargs.items()))result=Noneifkey incache:iflogged:print"--Cache hit for",func.__name__,key(cache_hit,expiry)=cache[key]iftime.time()-expiry<timeout:result=cache_hitelif logged:print"--Cache expired for",func.__name__,keyelif logged:print"--Cache miss for",func.__name__,key# No cache hit, or expiredifresult isNone:result=func(*args,**kwargs)cache[key]=(result,time.time())returnresultreturndecorated_functionreturndecorator

來看看它的用法。我們使用裝飾器裝飾一個很基本的斐波拉契數生成器。這個cache裝飾器將對程式碼使用備忘錄模式(Memoize Pattern)。請注意fib函式的閉包是如何存放cache字典、一個指向原fib函式的引用、logged引數的值以及timeout引數的最後值的。dump_closure將在文末定義。

&gt;&gt;&gt; @cached(10, True)
... def fib(n):
...     &quot;&quot;&quot;Returns the n&#039;th Fibonacci number.&quot;&quot;&quot;
...     if n == 0 or n == 1:
...         return 1
...     return fib(n - 1) + fib(n - 2)
...
-- Initializing cache for fib
&gt;&gt;&gt; dump_closure(fib)
1. Dumping function closure for fib:
-- cell 0  = {}
-- cell 1  = 
-- cell 2  = True
-- cell 3  = 10
&gt;&gt;&gt;
&gt;&gt;&gt; print &quot;Testing - F(4) = %d&quot; % fib(4)
-- Called function fib
-- Cache miss for fib ((4,), frozenset([]))
-- Called function fib
-- Cache miss for fib ((3,), frozenset([]))
-- Called function fib
-- Cache miss for fib ((2,), frozenset([]))
-- Called function fib
-- Cache miss for fib ((1,), frozenset([]))
-- Called function fib
-- Cache miss for fib ((0,), frozenset([]))
-- Called function fib
-- Cache hit for fib ((1,), frozenset([]))
-- Called function fib
-- Cache hit for fib ((2,), frozenset([]))
Testing - F(4) = 5

12345678910111213141516171819202122232425262728293031

>>>@cached(10,True)...def fib(n):..."""Returns then'th Fibonacci number."""...ifn==0orn==1:...return1...returnfib(n-1)+fib(n-2)...--Initializing cache forfib>>>dump_closure(fib)1.Dumping functionclosure forfib:--cell0={}--cell1=--cell2=True--cell3=10>>>>>>print"Testing-F(4)=%d"%fib(4)--Called functionfib--Cache miss forfib((4,),frozenset([]))--Called functionfib--Cache miss forfib((3,),frozenset([]))--Called functionfib--Cache miss forfib((2,),frozenset([]))--Called functionfib--Cache miss forfib((1,),frozenset([]))--Called functionfib--Cache miss forfib((0,),frozenset([]))--Called functionfib--Cache hit forfib((1,),frozenset([]))--Called functionfib--Cache hit forfib((2,),frozenset([]))Testing-F(4)=5

Class Decorators

在之前的小節中，我們看了一些函式裝飾器和一些使用的小技巧，接下來我們來看看類裝飾器。類裝飾器將一個class作為輸入引數(Python中的一種類型別物件)，並且返回一個修改過的class。

第一個例子是一個簡單的數學問題。當給定一個有序集合P，我們定義Pd為P的反序集合P(x,y) <-> Pd(x,y)，也就是說兩個有序集合的元素順序互為相反的，這在Python中該如何實現？假定一個類定義了__lt__以及__le__或其他方法來實現有序。那麼我們可以通過寫一個類裝飾器來替換這些方法。

def make_dual(relation):
    @wraps(relation, [&#039;__name__&#039;, &#039;__doc__&#039;])
    def dual(x, y):
        return relation(y, x)
    return dual

def dual_ordering(cls):
    &quot;&quot;&quot;Class decorator that reverses all the orderings&quot;&quot;&quot;
    for func in [&#039;__lt__&#039;, &#039;__gt__&#039;, &#039;__ge__&#039;, &#039;__le__&#039;]:
        if hasattr(cls, func):
            setattr(cls, func, make_dual(getattr(cls, func)))
    return cls

123456789101112

def make_dual(relation):@wraps(relation,['__name__', '__doc__'])def dual(x,y):returnrelation(y,x)returndualdef dual_ordering(cls):"""Classdecorator that reverses all the orderings"""forfunc in['__lt__', '__gt__', '__ge__', '__le__']:ifhasattr(cls,func):setattr(cls,func,make_dual(getattr(cls,func)))returncls

下面是將這個裝飾器用以str型別的例子，建立一個名為rstr的新類，使用反字典序(opposite lexicographic)為其順序。

Python

@dual_ordering
class rstr(str):
    pass

x = rstr("1")
y = rstr("2")

print x < y
print x <= y
print x > y
print x >= y

# Output:
False
False
True
True

12345678

Python高階特性（2）：Closures、Decorators和functools

裝飾器(Decorators)

Class Decorators

Python高階特性（2）：Closures、Decorators和functools

Python高階特性（1）：Iterators、Generators和itertools

python每日一類（2）：platform

python函數（2）：函數進階

Python開發環境（2）：啟動Eclipse時檢測到PYTHONPATH發生改變

Python基礎（2）：doc、文檔字符串docString、help()

Python設計模式（2）：創建型

python筆記----matplotlib（2）：條形圖、散點圖

C# 7.0 新特性（2）：本地方法

Python學習筆記（2）：生成隨機數

Python高階特性（3）: Classes和Metaclasses

SQL Server2016新特性（2）：時態表 Temporal Table

python高階特性（1）:切片

Python爬蟲實戰（2）：爬取京東商品列表

Python高階爬蟲（四）：動態載入頁面的解決方案與爬蟲代理

小白學 Python 資料分析（2）：Pandas （一）概述

《Linux學習並不難》Linux網絡命令（2）：ifconfig命令顯示和配置網絡接口

Python學習筆記（4）：容器、叠代對象、叠代器、生成器、生成器表達式

Qt 學習之路 2（42）：QListWidget、QTreeWidget 和 QTableWidget

Docker學習（2）：Docker映象介紹和容器的兩種建立方式

Python高階特性（2）：Closures、Decorators和functools

裝飾器(Decorators)

Class Decorators

相關推薦