python裝飾器

裝飾器

本質上，裝飾器就是一個返回函數的高階函數，它可以讓其他函數在不需要做任何代碼變動的前提下增加額外功能，裝飾器的返回值也是一個函數對象。
概括的講，裝飾器的作用就是爲已經存在的對象添加額外的功能。比如：插入日誌、性能測試、事務處理、緩存、權限校驗等場景。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量與函數功能本身無關的雷同代碼並繼續重用。

def foo():
    print('i am foo')

現在有一個新的需求，希望可以記錄下函數的執行日誌，於是在代碼中添加日誌代碼：

def foo():
    print('i am foo')
    logging.info("foo is running")

bar()、bar2()也有類似的需求，怎麼做？再寫一個logging在bar函數裏？這樣就造成大量雷同的代碼，爲了減少重複寫代碼，我們可以這樣做，重新定義一個函數：專門處理日誌 ，日誌處理完之後再執行真正的業務代碼

def use_logging(func):
    logging.warn("%s is running" % func.__name__)
    func()

def bar():
    print('i am bar')

use_logging(bar)

邏輯上不難理解， 但是這樣的話，我們每次都要將一個函數作爲參數傳遞給use_logging函數。而且這種方式已經破壞了原有的代碼邏輯結構，之前執行業務邏輯時，執行運行bar()，但是現在不得不改成use_logging(bar)。那麼有沒有更好的方式的呢？當然有，答案就是裝飾器。

def use_logging(func):      # 不帶參數的裝飾器 第一個def 參數就是func，帶參數的裝飾器，第一個def參數是裝飾元素參數，第二個def參數纔是func,注意區分（都是套路）
#  裝飾器就是某種閉包，總是return一些函數
    def wrapper(*args, **kwargs):
        logging.warn("%s is running" % func.__name__)
        return func(*args, **kwargs)
    return wrapper

def bar():
    print('i am bar')

bar = use_logging(bar)
bar()

函數use_logging就是裝飾器，它把執行真正業務方法的func包裹在函數裏面，看起來像bar被use_logging裝飾了。在這個例子中，函數進入和退出時 ，被稱爲一個橫切面(Aspect)，這種編程方式被稱爲面向切面的編程(Aspect-Oriented Programming)。

@符號是裝飾器的語法糖，在定義函數的時候使用，避免再一次賦值操作

def use_logging(func):
# 不帶參數的裝飾器 第一個def 參數就是func，帶參數的裝飾器，第一個def參數是裝飾元素參數，第二個def參數纔是func,注意區分（都是套路）
    def wrapper(*args, **kwargs):
        logging.warn("%s is running" % func.__name__)
        return func(*args)
    return wrapper    # return幾回，最終回去的還是func

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

@use_logging
def bar():
    print("i am bar")

foo()
bar()          #  相當於省去`bar = use_logging(bar)`

如上所示，這樣我們就可以省去bar = use_logging(bar)這一句了，直接調用bar()即可得到想要的結果。如果我們有其他的類似函數，我們可以繼續調用裝飾器來修飾函數，而不用重複修改函數或者增加新的封裝。這樣，我們就提高了程序的可重複利用性，並增加了程序的可讀性。

帶參數的裝飾器

裝飾器還有更大的靈活性，例如帶參數的裝飾器：在上面的裝飾器調用中，比如@use_logging，該裝飾器唯一的參數就是執行業務的函數。裝飾器的語法允許我們在調用時，提供其它參數，比如@decorator(a)。這樣，就爲裝飾器的編寫和使用提供了更大的靈活性。

# -*- coding:utf-8 -*-
import logging

def use_logging(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == 'warn':
                logging.warn('%s is running'% func.__name__)
            return func(*args)
        return wrapper
    return decorator

@use_logging(level="warn")
def foo(name="foo"):
    print("i am %s" % name)

@use_logging(level="error")
def bar(name="bar"):
    print("i am %s" % name)

foo()
bar()          #  相當於省去`bar = use_logging(bar)`

上面的use_logging是允許帶參數的裝飾器。它實際上是對原有裝飾器的一個函數封裝，並返回一個裝飾器。我們可以將它理解爲一個含有參數的閉包。當我們使用@use_logging(level="warn")調用的時候，Python能夠發現這一層的封裝，並把參數傳遞到裝飾器的環境中。

類裝飾器

再來看看類裝飾器，相比函數裝飾器，類裝飾器具有靈活度大、高內聚、封裝性等優點。使用類裝飾器還可以依靠類內部的call方法，當使用@形式將裝飾器附加到函數上時，就會調用此方法。

In [19]: class Foo(object):
    ...:     def __init__(self,func):
    ...:         self._func = func
    ...:     def __call__(self):      # 內置的特殊函數
    ...:         print('class decorator running')
    ...:         self._func()
    ...:         print('class decorator ending')
    ...:

In [20]: @Foo
    ...: def bar():
    ...:     print('bar')
    ...:

In [21]: bar()
class decorator running
bar
class decorator ending
functools.wraps

使用裝飾器極大地複用了代碼，但是他有一個缺點就是原函數的元信息不見了，比如函數的docstring、name、參數列表，先看例子：
裝飾器

def logged(func):
    def with_logging(*args, **kwargs):
        print func.__name__ + " was called"
        return func(*args, **kwargs)
    return with_logging

函數

@logged
def f(x):
   """does some math"""
   return x + x * x

該函數完成等價於：

def f(x):
    """does some math"""
    return x + x * x
f = logged(f)

不難發現，函數f被with_logging取代了，當然它的docstring，name就是變成了with_logging函數的信息了。

print f.__name__    # prints 'with_logging'
print f.__doc__     # prints None

這個問題就比較嚴重的，好在我們有functools.wraps，wraps本身也是一個裝飾器，它能把原函數的元信息拷貝到裝飾器函數中，這使得裝飾器函數也有和原函數一樣的元信息了。

from functools import wraps
def logged(func):
    @wraps(func)      #  引入wraps,其他代碼不動，即解決問題
    def with_logging(*args, **kwargs):
        print func.__name__ + " was called"
        return func(*args, **kwargs)
    return with_logging

@logged
def f(x):
    """does some math"""
    return x + x * x

print f.__name__  # prints 'f'
print f.__doc__   # prints 'does some math'

魔法函數__call__

所有的函數都是可調用對象。一個類實例也可以變成一個可調用對象，只需要實現一個特殊方法call()。

我們把 Person 類變成一個可調用對象：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print 'My name is %s...' % self.name
        print 'My friend is %s...' % friend

現在可以對 Person 實例直接調用：

>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...

單看p('Tim')你無法確定p是一個函數還是一個類實例，所以，在Python中，函數也是對象，對象和函數的區別並不顯著。

裝飾器的順序

@a
@b
@c
def f ():

等效於

f = a(b(c(f)))

內置裝飾器

@classmethod

類方法的第一個參數是一個類，是將類本身作爲操作的方法。類方法被哪個類調用，就傳入哪個類作爲第一個參數進行操作。

class Car(object):
    car = "audi"

    @classmethod
    def value(self, category): # 可定義多個參數，但第一個參數爲類本身
        print "%s car of %s" % (category, self.car)

class BMW(Car):
    car = "BMW"

class Benz(Car):
    car = "Benz"

print "通過實例調用"
baoma = BMW()
baoma.value("Normal") # 由於第一個參數爲類本身，調用時傳入的參數對應的時category

print "通過類名直接調用"
Benz.value("SUV")

輸出結果：

通過實例調用
Normal car of BMW
通過類名直接調用
SUV car of Benz

@staticmathod

將類中的方法裝飾爲靜態方法，即類不需要創建實例的情況下，可以通過類名直接引用，到達將函數功能與實例解綁的效果。

# coding: utf-8
class TestClass:
    name = "test"

    def __init__(self, name):
        self.name = name

    @staticmethod
    def fun(self, x, y):
        return  x + y

cls = TestClass("felix")
print "通過實例引用方法"
print cls.fun(None, 2, 3) # 參數個數必須與定義中的個數保持一致，否則報錯

print "類名直接引用靜態方法"
print TestClass.fun(None, 2, 3) # 參數個數必須與定義中的個數保持一致，否則報錯

輸出結果：

通過實例引用方法
5
類名直接引用靜態方法
5

@property

作用:把類中一個方法變成屬性調用。

class TestClass:
    name = "test"

    def __init__(self, name):
        self.name = name

    @property
    def sayHello(self):
        print "hello", self.name

cls = TestClass("felix")
print "通過實例引用屬性"
print cls.name
print "像引用屬性一樣調用@property修飾的方法"
cls.sayHello

輸出結果：

通過實例引用屬性
felix
像引用屬性一樣調用@property修飾的方法
hello felix