Python Decorator Python之美--Decorator深刻詳解(一)

時間  2019-12-13
標籤 python decorator 之美 深刻 詳解 欄目 Python 简体版
原文   原文鏈接

因爲沒時間編寫，就把幾張寫的不錯的文章摘錄整合到一塊兒。原文地址：Python Decorator　python decorator心得體會   可愛的 Python: Decorator 簡化元編程css

Python之美--Decorator深刻詳解(一)   Python Decorators（二）：Decorator參數   Python Decorator初體驗html

　　Python的修飾器的英文名叫Decorator，當你看到這個英文名的時候，你可能會把其跟Design Pattern裏的Decorator搞混了，其實這是徹底不一樣的兩個東西。在認識裝飾器以前，咱們先來點感性認識，看一個Python修飾器的Hello World的代碼。python

下面是代碼：文件名：hello.py
def hello(fn):
    def wrapper():
        print "hello, %s" % fn.__name__
        fn()
        print "goodby, %s" % fn.__name__
    return wrapper
 
@hello
def foo():
    print "i am foo"
 
foo()

 當你運行代碼，你會看到以下輸出：mysql

[chenaho@chenhao-air]$ python hello.py
hello, foo
i am foo
goodby, foo

 你能夠看到以下的東西：
　　1）函數foo前面有個@hello的「註解」，hello就是咱們前面定義的函數hello；
　　2）在hello函數中，其須要一個fn的參數（這就用來作回調的函數）；
　　3）hello函數中返回了一個inner函數wrapper，這個wrapper函數回調了傳進來的fn，並在回調先後加了兩條語句。算法

Decorator 的本質sql

　　對於Python的這個@註解語法糖- Syntactic Sugar 來講，當你在用某個@decorator來修飾某個函數func時，以下所示:shell

@decorator
def func():
    pass

其解釋器會解釋成下面這樣的語句：編程

func = decorator(func)

 　　瞭然，這不就是把一個函數當參數傳到另外一個函數中，而後再回調嗎？是的，可是，咱們須要注意，那裏還有一個賦值語句，把decorator這個函數的返回值賦值回了原來的func。 根據《函數式編程》中的first class functions中的定義的，你能夠把函數當成變量來使用，因此，decorator必需得返回了一個函數出來給func，這就是所謂的higher order function 高階函數，否則，後面當func()調用的時候就會出錯。 就咱們上面那個hello.py裏的例子來講，promise

@hello
def foo():
    print "i am foo"

 被解釋成了：緩存

foo = hello(foo)

 是的，這是一條語句，並且還被執行了。你若是不信的話，你能夠寫這樣的程序來試試看：

def fuck(fn):
    print "fuck %s!" % fn.__name__[::-1].upper()
 
@fuck
def wfg():
    pass

 沒了，就上面這段代碼，沒有調用wfg()的語句，你會發現， fuck函數被調用了，並且還很NB地輸出了咱們每一個人的心聲！

　　再回到咱們hello.py的那個例子，咱們能夠看到，hello(foo)返回了wrapper()函數，因此，foo其實變成了wrapper的一個變量，然後面的foo()執行其實變成了wrapper()。知道這點本質，當你看到有多個decorator或是帶參數的decorator，你也就不會懼怕了。

好比：多個decorator：

@decorator_one
@decorator_two
def func():
    pass

 至關於：

func = decorator_one(decorator_two(func))

 好比：帶參數的decorator：

@decorator(arg1, arg2)
def func():
    pass

 至關於：

func = decorator(arg1,arg2)(func)

 這意味着decorator(arg1, arg2)這個函數須要返回一個「真正的decorator」。

帶參數及多個Decrorator

咱們來看一個有點意義的例子：

def makeHtmlTag(tag, *args, **kwds):
    def real_decorator(fn):
        css_class = " class='{0}'".format(kwds["css_class"]) if "css_class" in kwds else ""
        def wrapped(*args, **kwds):
            return "<"+tag+css_class+">" + fn(*args, **kwds) + "</"+tag+">"
        return wrapped
    return real_decorator
 
@makeHtmlTag(tag="b", css_class="bold_css")
@makeHtmlTag(tag="i", css_class="italic_css")
def hello():
    return "hello world"
 
print hello()
 
# 輸出：
# <b class='bold_css'><i class='italic_css'>hello world</i></b>

 在上面這個例子中，咱們能夠看到：makeHtmlTag有兩個參數。因此，爲了讓 hello = makeHtmlTag(arg1, arg2)(hello) 成功，makeHtmlTag 必需返回一個decorator（這就是爲何咱們在makeHtmlTag中加入了real_decorator()的緣由），這樣一來，咱們就能夠進入到 decorator 的邏輯中去了—— decorator得返回一個wrapper，wrapper裏回調hello。看似那個makeHtmlTag() 寫得層層疊疊，可是，已經瞭解了本質的咱們以爲寫得很天然。

初識Decorator

　　Decorator，修飾符，是在Python2.4中增長的功能，也是pythoner實現元編程的最新方式，同時它也是最簡單的元編程方式。爲何是「最簡單」呢？是的，其實在Decorator以前就已經
有classmethod()和staticmethod()內置函數，但他們的缺陷是會致使函數名的重複使用(能夠看看David Mertz的Charming Python: Decorators make magic easy )，
如下是摘自他本人的原文：

class C:
    def foo(cls, y):
        print "classmethod", cls, y
    foo = classmethod(foo)

　　是的，classmethod作的只是函數轉換，可是它卻讓foo這個名字另外出現了2次。記得有一句話是：人類因懶惰而進步。Decorator的誕生，讓foo少出現2次。

class C:
    @classmethod
    def foo(cls, y):
        print "classmethod", cls, y

　　讀者也許已經想到Decorator在python中是怎麼處理的了(若是還沒頭緒的，強烈建議先去看看limodou寫的Decorator學習筆記 )。下面我列出4種用法。

單個 Decorator，不帶參數

　　設想一個情景，你平時去買衣服的時候，跟售貨員是怎麼對話的呢？售貨員會先向你問好，而後你會試穿某件你喜好的衣服。

def salesgirl(method):
    def serve(*args):
        print "Salesgirl:Hello, what do you want?", method.__name__
        method(*args)
    return serve
   
@salesgirl
def try_this_shirt(size):
    if size < 35:
        print "I: %d inches is to small to me" %(size)
    else:
        print "I:%d inches is just enough" %(size)
try_this_shirt(38) 

結果是：

Salesgirl:Hello, what do you want? try_this_shirt
I:38 inches is just enough

　　這只是一個太簡單的例子，以致一些「細節」沒有處理好，你試穿完了好歹也告訴salesgirl到底要不要買啊。。。這樣try_this_shirt方法須要改爲帶返回值 
(假設是bool類型,True就是要買，False就是不想買)，那麼salesgirl中的serve也應該帶返回值，而且返回值就是 method(*args)。

修改後的salesgirl  

def salesgirl(method):
    def serve(*args):
        print "Salesgirl:Hello, what do you want?", method.__name__
        return method(*args)
    return serve
   
@salesgirl
def try_this_shirt(size):
    if size < 35:
        print "I: %d inches is to small to me" %(size)
        return False
    else:
        print "I:%d inches is just enough" %(size)
        return True
result = try_this_shirt(38)
print "Mum:do you want to buy this?", result

結果是：

Salesgirl:Hello, what do you want? try_this_shirt
I:38 inches is just enough
Mum:do you want to buy this? True

    如今咱們的salesgirl還不算合格，她只會給客人打招呼，可是客人要是買衣服了，也不會給他報價；客人不買的話，也應該推薦其餘款式！

會報價的salesgirl:

def salesgirl(method):
    def serve(*args):
        print "Salesgirl:Hello, what do you want?", method.__name__
        result = method(*args)
        if result:
            print "Salesgirl: This shirt is 50$."
        else:
            print "Salesgirl: Well, how about trying another style?"
        return result
    return serve
   
@salesgirl
def try_this_shirt(size):
    if size < 35:
        print "I: %d inches is to small to me" %(size)
        return False
    else:
        print "I:%d inches is just enough" %(size)
        return True
result = try_this_shirt(38)
print "Mum:do you want to buy this?", result

結果是：

Salesgirl:Hello, what do you want? try_this_shirt
I:38 inches is just enough
Salesgirl: This shirt is 50$.
Mum:do you want to buy this? True

這樣的salesgirl總算是合格了，但離出色還很遠，稱職的salesgirl是應該對熟客讓利，老用戶總得有點好處吧？

單個 Decorator，帶參數
　　會報價而且帶折扣的salesgirl：
def salesgirl(discount):
    def expense(method):
        def serve(*args):
            print "Salesgirl:Hello, what do you want?", method.__name__
            result = method(*args)
            if result:
                print "Salesgirl: This shirt is 50$.As an old user, we promised to discount at %d%%" %(discount)
            else:
                print "Salesgirl: Well, how about trying another style?"
            return result
        return serve
    return expense
   
@salesgirl(50)
def try_this_shirt(size):
    if size < 35:
        print "I: %d inches is to small to me" %(size)
        return False
    else:
        print "I:%d inches is just enough" %(size)
        return True
result = try_this_shirt(38)
print "Mum:do you want to buy this?", result
 
結果是：

Salesgirl:Hello, what do you want? try_this_shirt
I:38 inches is just enough
Salesgirl: This shirt is 50$.As an old user, we promised to discount at 50%
Mum:do you want to buy this? True

　　這裏定義的salesgirl是會給客戶50%的折扣，由於salesgirl描述符是帶參數，而參數就是折扣。若是你是第一次看到這個 salesgirl，
會被她裏面嵌套的2個方法而感到意外，不要緊，當你習慣了Decorator以後，一切都變得很親切啦

　　你看，Python的Decorator就是這麼簡單，沒有什麼複雜的東西，你也不須要了解過多的東西，使用起來就是那麼天然、體貼，可是你以爲上面那個帶參數的Decorator的函數嵌套太多了，你受不了。好吧，沒事，咱們看看下面的方法。

class式的 Decorator(重點)

一、首先，先得說一下，decorator的class方式，仍是看個示例：

class myDecorator(object):
 
    def __init__(self, fn):
        print "inside myDecorator.__init__()"
        self.fn = fn
 
    def __call__(self):
        self.fn()
        print "inside myDecorator.__call__()"
 
@myDecorator
def aFunction():
    print "inside aFunction()"
 
print "Finished decorating aFunction()"
 
aFunction()
 
# 輸出：
# inside myDecorator.__init__()
# Finished decorating aFunction()
# inside aFunction()
# inside myDecorator.__call__()

 上面這個示例展現了，用類的方式聲明一個decorator。咱們能夠看到這個類中有兩個成員：
　　1）一個是__init__()，這個方法是在咱們給某個函數decorator時被調用，因此，須要有一個fn的參數，也就是被decorator的函數。
　　2）一個是__call__()，這個方法是在咱們調用被decorator函數時被調用的。
上面輸出能夠看到整個程序的執行順序。這看上去要比「函數式」的方式更易讀一些。

二、下面，咱們來看看用類的方式來重寫上面的html.py的代碼：html.py

class makeHtmlTagClass(object):
 
    def __init__(self, tag, css_class=""):
        self._tag = tag
        self._css_class = " class='{0}'".format(css_class) \
                                       if css_class !="" else ""
 
    def __call__(self, fn):
        def wrapped(*args, **kwargs):
            return "<" + self._tag + self._css_class+">"  \
                       + fn(*args, **kwargs) + "</" + self._tag + ">"
        return wrapped
 
@makeHtmlTagClass(tag="b", css_class="bold_css")
@makeHtmlTagClass(tag="i", css_class="italic_css")
def hello(name):
    return "Hello, {}".format(name)
 
print hello("Hao Chen")

 上面這段代碼中，咱們須要注意這幾點：
　　1）若是decorator有參數的話，__init__() 成員就不能傳入fn了，而fn是在__call__的時候傳入的。
　　2）這段代碼還展現了 wrapped(*args, **kwargs) 這種方式來傳遞被decorator函數的參數。（其中：args是一個參數列表，kwargs是參數dict，具體的細節，請參考Python的文檔或是StackOverflow的這個問題，這裏就不展開了）

三、用Decorator設置函數的調用參數，你有三種方法能夠幹這個事：

第一種，經過 **kwargs，這種方法decorator會在kwargs中注入參數。

def decorate_A(function):
    def wrap_function(*args, **kwargs):
        kwargs['str'] = 'Hello!'
        return function(*args, **kwargs)
    return wrap_function
 
@decorate_A
def print_message_A(*args, **kwargs):
    print(kwargs['str'])
 
print_message_A()

 第二種，約定好參數，直接修改參數

def decorate_B(function):
    def wrap_function(*args, **kwargs):
        str = 'Hello!'
        return function(str, *args, **kwargs)
    return wrap_function
 
@decorate_B
def print_message_B(str, *args, **kwargs):
    print(str)
 
print_message_B()

 第三種，經過 *args 注入

def decorate_C(function):
    def wrap_function(*args, **kwargs):
        str = 'Hello!'
        #args.insert(1, str)
        args = args +(str,)
        return function(*args, **kwargs)
    return wrap_function
 
class Printer:
    @decorate_C
    def print_message(self, str, *args, **kwargs):
        print(str)
 
p = Printer()
p.print_message()

 Decorator的反作用

　　到這裏，我相信你應該瞭解了整個Python的decorator的原理了。相信你也會發現，被decorator的函數其實已是另一個函數了，對於最前面那個hello.py的例子來講，若是你查詢一下foo.__name__的話，你會發現其輸出的是「wrapper」，而不是咱們指望的「foo」，這會給咱們的程序埋一些坑。因此，Python的functool包中提供了一個叫wrap的decorator來消除這樣的反作用。下面是咱們新版本的hello.py。

文件名：hello.py
from functools import wraps
def hello(fn):
    @wraps(fn)
    def wrapper():
        print "hello, %s" % fn.__name__
        fn()
        print "goodby, %s" % fn.__name__
    return wrapper
 
@hello
def foo():
    '''foo help doc'''
    print "i am foo"
    pass
 
foo()
print foo.__name__ #輸出 foo
print foo.__doc__  #輸出 foo help doc

 固然，即便是你用了functools的wraps，也不能徹底消除這樣的反作用。來看下面這個示例：

from inspect import getmembers, getargspec
from functools import wraps
 
def wraps_decorator(f):
    @wraps(f)
    def wraps_wrapper(*args, **kwargs):
        return f(*args, **kwargs)
    return wraps_wrapper
 
class SomeClass(object):
    @wraps_decorator
    def method(self, x, y):
        pass
 
obj = SomeClass()
for name, func in getmembers(obj, predicate=inspect.ismethod):
    print "Member Name: %s" % name
    print "Func Name: %s" % func.func_name
    print "Args: %s" % getargspec(func)[0]
 
# 輸出：
# Member Name: method
# Func Name: method
# Args: []

 你會發現，即便是你你用了functools的wraps，你在用getargspec時，參數也不見了。要修正這一問，咱們還得用Python的反射來解決，下面是相關的代碼：

def get_true_argspec(method):
    argspec = inspect.getargspec(method)
    args = argspec[0]
    if args and args[0] == 'self':
        return argspec
    if hasattr(method, '__func__'):
        method = method.__func__
    if not hasattr(method, 'func_closure') or method.func_closure is None:
        raise Exception("No closure for method.")
 
    method = method.func_closure[0].cell_contents
    return get_true_argspec(method)

 固然，我相信大多數人的程序都不會去getargspec。因此，用functools的wraps應該夠用了。一些decorator的示例。好了，如今咱們來看一下各類decorator的例子：給函數調用作緩存。這個例實在是太經典了，整個網上都用這個例子作decorator的經典範例，由於太經典了，因此，我這篇文章也不能免俗。

from functools import wraps
def memo(fn):
    cache = {}
    miss = object()
 
    @wraps(fn)
    def wrapper(*args):
        result = cache.get(args, miss)
        if result is miss:
            result = fn(*args)
            cache[args] = result
        return result
 
    return wrapper
 
@memo
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

　　上面這個例子中，是一個斐波拉契數例的遞歸算法。咱們知道，這個遞歸是至關沒有效率的，由於會重複調用。好比：咱們要計算fib(5)，因而其分解成fib(4) + fib(3)，而fib(4)分解成fib(3)+fib(2)，fib(3)又分解成fib(2)+fib(1)…… 你可看到，基本上來講，fib(3), fib(2), fib(1)在整個遞歸過程當中被調用了兩次。而咱們用decorator，在調用函數前查詢一下緩存，若是沒有才調用了，有了就從緩存中返回值。一會兒，這個遞歸從二叉樹式的遞歸成了線性的遞歸。

Profiler的例子

　　這個例子沒什麼高深的，就是實用一些。

import cProfile, pstats, StringIO
 
def profiler(func):
    def wrapper(*args, **kwargs):
        datafn = func.__name__ + ".profile" # Name the data file
        prof = cProfile.Profile()
        retval = prof.runcall(func, *args, **kwargs)
        #prof.dump_stats(datafn)
        s = StringIO.StringIO()
        sortby = 'cumulative'
        ps = pstats.Stats(prof, stream=s).sort_stats(sortby)
        ps.print_stats()
        print s.getvalue()
        return retval
 
    return wrapper

 註冊回調函數

下面這個示例展現了經過URL的路由來調用相關注冊的函數示例：

class MyApp():
    def __init__(self):
        self.func_map = {}
 
    def register(self, name):
        def func_wrapper(func):
            self.func_map[name] = func
            return func
        return func_wrapper
 
    def call_method(self, name=None):
        func = self.func_map.get(name, None)
        if func is None:
            raise Exception("No function registered against - " + str(name))
        return func()
 
app = MyApp()
 
@app.register('/')
def main_page_func():
    return "This is the main page."
 
@app.register('/next_page')
def next_page_func():
    return "This is the next page."
 
print app.call_method('/')
print app.call_method('/next_page')

 注意：
　　1）上面這個示例中，用類的實例來作decorator。
　　2）decorator類中沒有__call__()，可是wrapper返回了原函數。因此，原函數沒有發生任何變化。

給函數打日誌
下面這個示例演示了一個logger的decorator，這個decorator輸出了函數名，參數，返回值，和運行時間。

from functools import wraps
def logger(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        ts = time.time()
        result = fn(*args, **kwargs)
        te = time.time()
        print "function      = {0}".format(fn.__name__)
        print "    arguments = {0} {1}".format(args, kwargs)
        print "    return    = {0}".format(result)
        print "    time      = %.6f sec" % (te-ts)
        return result
    return wrapper
 
@logger
def multipy(x, y):
    return x * y
 
@logger
def sum_num(n):
    s = 0
    for i in xrange(n+1):
        s += i
    return s
 
print multipy(2, 10)
print sum_num(100)
print sum_num(10000000)

 上面那個打日誌仍是有點粗糙，讓咱們看一個更好一點的（帶log level參數的）：

import inspect
def get_line_number():
    return inspect.currentframe().f_back.f_back.f_lineno
 
def logger(loglevel):
    def log_decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            ts = time.time()
            result = fn(*args, **kwargs)
            te = time.time()
            print "function   = " + fn.__name__,
            print "    arguments = {0} {1}".format(args, kwargs)
            print "    return    = {0}".format(result)
            print "    time      = %.6f sec" % (te-ts)
            if (loglevel == 'debug'):
                print "    called_from_line : " + str(get_line_number())
            return result
        return wrapper
    return log_decorator

 可是，上面這個帶log level參數的有兩具很差的地方，
　　1） loglevel不是debug的時候，仍是要計算函數調用的時間。
　　2） 不一樣level的要寫在一塊兒，不易讀。

咱們再接着改進：

mport inspect
 
def advance_logger(loglevel):
 
    def get_line_number():
        return inspect.currentframe().f_back.f_back.f_lineno
 
    def _basic_log(fn, result, *args, **kwargs):
        print "function   = " + fn.__name__,
        print "    arguments = {0} {1}".format(args, kwargs)
        print "    return    = {0}".format(result)
 
    def info_log_decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            result = fn(*args, **kwargs)
            _basic_log(fn, result, args, kwargs)
        return wrapper
 
    def debug_log_decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            ts = time.time()
            result = fn(*args, **kwargs)
            te = time.time()
            _basic_log(fn, result, args, kwargs)
            print "    time      = %.6f sec" % (te-ts)
            print "    called_from_line : " + str(get_line_number())
        return wrapper
 
    if loglevel is "debug":
        return debug_log_decorator
    else:
        return info_log_decorator

 你能夠看到兩點，
　　1）咱們分了兩個log level，一個是info的，一個是debug的，而後咱們在外尾根據不一樣的參數返回不一樣的decorator。
　　2）咱們把info和debug中的相同的代碼抽到了一個叫_basic_log的函數裏，DRY原則。

一個MySQL的Decorator
　　下面這個decorator是我在工做中用到的代碼，我簡化了一下，把DB鏈接池的代碼去掉了，這樣能簡單點，方便閱讀。

import umysql
from functools import wraps
 
class Configuraion:
    def __init__(self, env):
        if env == "Prod":
            self.host    = "coolshell.cn"
            self.port    = 3306
            self.db      = "coolshell"
            self.user    = "coolshell"
            self.passwd  = "fuckgfw"
        elif env == "Test":
            self.host   = 'localhost'
            self.port   = 3300
            self.user   = 'coolshell'
            self.db     = 'coolshell'
            self.passwd = 'fuckgfw'
 
def mysql(sql):
 
    _conf = Configuraion(env="Prod")
 
    def on_sql_error(err):
        print err
        sys.exit(-1)
 
    def handle_sql_result(rs):
        if rs.rows > 0:
            fieldnames = [f[0] for f in rs.fields]
            return [dict(zip(fieldnames, r)) for r in rs.rows]
        else:
            return []
 
    def decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            mysqlconn = umysql.Connection()
            mysqlconn.settimeout(5)
            mysqlconn.connect(_conf.host, _conf.port, _conf.user, \
                              _conf.passwd, _conf.db, True, 'utf8')
            try:
                rs = mysqlconn.query(sql, {})
            except umysql.Error as e:
                on_sql_error(e)
 
            data = handle_sql_result(rs)
            kwargs["data"] = data
            result = fn(*args, **kwargs)
            mysqlconn.close()
            return result
        return wrapper
 
    return decorator
 
@mysql(sql = "select * from coolshell" )
def get_coolshell(data):
    ... ...
    ... ..

 線程異步

下面量個很是簡單的異步執行的decorator，注意，異步處理並不簡單，下面只是一個示例。

from threading import Thread
from functools import wraps
 
def async(func):
    @wraps(func)
    def async_func(*args, **kwargs):
        func_hl = Thread(target = func, args = args, kwargs = kwargs)
        func_hl.start()
        return func_hl
 
    return async_func
 
if __name__ == '__main__':
    from time import sleep
 
    @async
    def print_somedata():
        print 'starting print_somedata'
        sleep(2)
        print 'print_somedata: 2 sec passed'
        sleep(2)
        print 'print_somedata: 2 sec passed'
        sleep(2)
        print 'finished print_somedata'
 
    def main():
        print_somedata()
        print 'back in main'
        print_somedata()
        print 'back in main'
 
    main()
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程