装饰器

在stackoverflow上看到一篇讲python中decorator的回答，实在是受益匪浅，决定将其翻译成中文，分享给大家。

原文链接如下How to make a chain of function decorators in Python?

函数是对象

在python中，函数是对象。
以一个简单的函数为例。

def shout(word=\"yes\"):
    return word.capitalize()+\"!\"

print(shout())

会输出

Yes!

作为对象，是可以赋值给另外一个变量的。

scream = shout
print(scream())

输出和上面是一样的。

更有意思的是，python中的函数是可以定义在另外一个函数内部的。

def talk():
    def whisper(word=\"yes\"):
        return word.lower()+\"...\"
    print(whisper())

talk()

输出

yes...

函数引用

通过上面的例子可以看到，函数是对象，所以

1. 可以被赋值给另外一个变量
2. 可以在另外一个函数中被定义。

这也就意味着，一个函数可以将另外一个函数作为返回值。

def getTalk(kind=\"shout\"):
    def shout(word=\"yes\"):
        return word.capitalize()+\"!\"
    def whisper(word=\"yes\"):
        return word.lower()+\"...\"
    if kind == \"shout\":
        return shout
    else:
        return whisper

talk = getTalk()
print talk    # 输出 
print talk()  # 输出 Yes!
print getTalk(\"whisper\")()  # 输出yes...

如果能够返回一个函数，也可以将一个函数作为参数传入，复用上面的scream函数

def doSomethingBefore(func):
    print(\"I do something before then I call the function you gave me\")
    print(func)

doSomethingBefore(scream)

输出

I do something before then I call the function you gave me
Yes!

现在应该能够理解装饰器了吧，装饰器实际上就是对函数进行了包装，它能够在不改变函数的前提下，在这个函数被执行之前或者执行之后执行一段代码。

手写装饰器

# 装饰器将一个另外的函数作为参数传入
def my_shiny_new_decorator(a_function_to_decorate):
    # 定义一个wrapper
    def the_wrapper_around_the_original_function():
        # 在传入的函数被执行前执行
        print(\"Before the function runs\")
        a_function_to_decorate()
        # 在传入的函数被执行后执行
        print(\"After the function runs\")
    return the_wrapper_around_the_original_function

def a_stand_alone_function():
    print(\"I am a stand alone function, don\'t you dare modify me\")

a_stand_alone_function()
# 输出:  I am a stand alone function, don\'t you dare modify me
a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
# 输出 
# Before the function runs
# I am a stand alone function, don\'t you dare modify me
# After the function runs

也许你想要每次调用a_stand_alone_function时，
a_stand_alone_function_decorated就会被调用，这很简单，只需要用a_stand_alone_function_decorated返回的函数覆盖之前的a_stand_alone_function就可以了。

使用装饰器

@my_shiny_new_decorator
def another_stand_alone_function():
    print(\"Leave me alone\")

another_stand_alone_function() 
# 输出
#Before the function runs
#Leave me alone
#After the function runs

是的，就是这么简单。 @decorator就是下面代码的简写

another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)

装饰器就是Decorator patternpython式实现。

像下面的代码

def bread(func):
    def wrapper():
        print(\"\")
        func()
        print(\"<\\______/>\")
    return wrapper

def ingredients(func):
   def wrapper():
        print(\"#tomatoes#\")
        func()
        print(\"~salad~\")
    return wrapper

def sandwich(food=\"--ham--\"):
    print(food)

sandwich()
#outputs: --ham--
sandwich = bread(ingredients(sandwich))
sandwich()

就可以写成

@bread
@ingredients
def sandwich(food=\"--ham--\"):
    print(food)

sandwich()
#outputs:
#
# #tomatoes#
# --ham--
# ~salad~
#<\\______/>

装饰器的顺序很重要，如果改变上面的顺序，函数的行为就被改变了

@ingredients
@bread
def sandwich(food=\"--ham--\"):
    print(food)
strange_sandwich()

#outputs:
##tomatoes#
#
# --ham--
#<\\______/>
# ~salad~

还是一个装饰器的例子

# The decorator to make it bold
def makebold(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return \"\" + fn() + \"\"
    return wrapper

# The decorator to make it italic
def makeitalic(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return \"\" + fn() + \"\"
    return wrapper

@makebold
@makeitalic
def say():
    return \"hello\"
print(say())
#outputs: hello
# 等同于下面的函数 
def say():
    return \"hello\"
say = makebold(makeitalic(say))
print(say())
#outputs: hello

装饰器更高级的应用

向被装饰的函数传递参数

def a_decorator_passing_arguments(function_to_decorate):
    def a_wrapper_accepting_arguments(arg1, arg2):
        print(\"I got args! Look: {0}, {1}\".format(arg1, arg2))
        function_to_decorate(arg1, arg2)
    return a_wrapper_accepting_arguments
# 因为最终被调用是被装饰器返回的函数，即wrapper，
# 所以将参数传递给wrapper会将这些参数传递给被装饰的函数

@a_decorator_passing_arguments
def print_full_name(first_name, last_name):
    print(\"My name is {0} {1}\".format(first_name, last_name))
print_full_name(\"Peter\", \"Venkman\")
# outputs:
#I got args! Look: Peter Venkman
#My name is Peter Venkman

装饰方法

python中方法和函数是一样的。唯一不同的是，方法期望传入的第一个参数是当前的对象(self)。
也就是说装饰方法和装饰函数没有差异，只需要在装饰方法的时候将第一个参数考虑进去就行

def method_friendly_decorator(method_to_decorate):
    def wrapper(self, lie):
        lie = lie - 3
        return method_to_decorate(self, lie)
    return wrapper

class Lucy(object):
    def __init__(self):
        self.age = 32

    @method_friendly_decorator
    def sayYourAge(self, lie):
        print(\"I am {0}, what did you think?\".format(self.age + lie))

l = Lucy()
l.sayYourAge(-3)
#outputs: I am 26, what did you think?

如果试图些一个通用的装饰器，可以用*args, **kwargs

def a_decorator_passing_arbitrary_arguments(function_to_decorate):
    # The wrapper accepts any arguments
    def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):
        print(\"Do I have args?:\")
        print(args)
        print(kwargs)
        # Then you unpack the arguments, here *args, **kwargs
        # If you are not familiar with unpacking, check:        # http://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/
        function_to_decorate(*args, **kwargs)
    return a_wrapper_accepting_arbitrary_arguments

@a_decorator_passing_arbitrary_arguments
def function_with_no_argument():
    print(\"Python is cool, no argument here.\")

function_with_no_argument()
#outputs
#Do I have args?:
#()#{}#Python is cool, no argument here.

@a_decorator_passing_arbitrary_arguments
def function_with_arguments(a, b, c):
    print(a, b, c)

function_with_arguments(1,2,3)
#outputs
#Do I have args?:
#(1, 2, 3)#{}
#1 2 3 @a_decorator_passing_arbitrary_arguments
def function_with_named_arguments(a, b, c, platypus=\"Why not ?\"):
    print(\"Do {0}, {1} and {2} like platypus? {3}\".format(a, b, c, platypus))

function_with_named_arguments(\"Bill\", \"Linus\", \"Steve\", platypus=\"Indeed!\")
#outputs
#Do I have args ? :
#(\'Bill\', \'Linus\', \'Steve\')
#{\'platypus\': \'Indeed!\'}
#Do Bill, Linus and Steve like platypus? Indeed!

class Mary(object):
    def __init__(self): 
       self.age = 31
    @a_decorator_passing_arbitrary_arguments
    def sayYourAge(self, lie=-3):
 # You can now add a default value
        print(\"I am {0}, what did you think?\".format(self.age + lie))

m = Mary()
m.sayYourAge()
#outputs
# Do I have args?:
#(<__main__.Mary object at 0xb7d303ac>,)
#{}
#I am 28, what did you think?

向装饰器传递参数

那么问题来了，怎么向装饰器传递参数呢？
这有点让人挠头，因为装饰器必须接受一个函数作为参数。
因此可以直接向装饰器传递参数。

回想一下之前的代码

# Decorators are ORDINARY functions
def my_decorator(func):
    print(\"I am an ordinary function\")
    def wrapper():
        print(\"I am function returned by the decorator\")
        func()
    return wrapper
# Therefore, you can call it without any \"@\"

def lazy_function():
    print(\"zzzzzzzz\")

decorated_function = my_decorator(lazy_function)
#outputs: I am an ordinary function
# It outputs \"I am an ordinary function\", because that’s just what you do:# calling a function. Nothing magic.

@my_decorator
def lazy_function():
    print(\"zzzzzzzz\")

#outputs: I am an ordinary function

这两个是一样的。my_decorator被调用了。
当写下@my_decorator时，python会调用被标注为my_decorator的函数

def decorator_maker():
    print(\"I make decorators! I am executed only once: \"
          \"when you make me create a decorator.\")

    def my_decorator(func):
        print(\"I am a decorator! I am executed only when you decorate a function.\")
        def wrapped():
            print(\"I am the wrapper around the decorated function. \"                  \"I am called when you call the decorated function. \"
                  \"As the wrapper, I return the RESULT of the decorated function.\")
            return func()

        print(\"As the decorator, I return the wrapped function.\")
        return wrapped
    print(\"As a decorator maker, I return a decorator\")
    return my_decorator

# Let’s create a decorator. It’s just a new function after all.
new_decorator = decorator_maker()       
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
# Then we decorate the function

def decorated_function():
    print(\"I am the decorated function.\")

decorated_function = new_decorator(decorated_function)
#outputs:
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function
# Let’s call the function:

decorated_function()
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.

将代码中的中间变量去掉试试。

def decorated_function():
    print(\"I am the decorated function.\")

decorated_function = decorator_maker()(decorated_function)

#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function.
# Finally:

decorated_function()    
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.

再简化一次代码

@decorator_maker()
def decorated_function():
    print(\"I am the decorated function.\")

#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function.
#Eventually: 

decorated_function()   
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.

回到之前的问题，如果我们能够随时生成装饰器，我们也能向那个生成的装饰器传递参数。

def decorator_maker_with_arguments(decorator_arg1, decorator_arg2):
    print(\"I make decorators! And I accept arguments: {0}, {1}\".format(decorator_arg1, decorator_arg2))
    def my_decorator(func):
        # The ability to pass arguments here is a gift from closures.
        # If you are not comfortable with closures, you can assume it’s ok,
        # or read: http://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-python
        print(\"I am the decorator. Somehow you passed me arguments: {0}, {1}\".format(decorator_arg1, decorator_arg2))
        # Don\'t confuse decorator arguments and function arguments!
        def wrapped(function_arg1, function_arg2) :
            print(\"I am the wrapper around the decorated function.\\n\"
                  \"I can access all the variables\\n\"
                  \"\\t- from the decorator: {0} {1}\\n\"
                  \"\\t- from the function call: {2} {3}\\n\"
                  \"Then I can pass them to the decorated function\"
                  .format(decorator_arg1, decorator_arg2,                          function_arg1, function_arg2))
            return func(function_arg1, function_arg2)
        return wrapped
    return my_decorator

@decorator_maker_with_arguments(\"Leonard\", \"Sheldon\")
def decorated_function_with_arguments(function_arg1, function_arg2):
    print(\"I am the decorated function and only knows about my arguments: {0}\"
           \" {1}\".format(function_arg1, function_arg2))

decorated_function_with_arguments(\"Rajesh\", \"Howard\")
#outputs:
#I make decorators! And I accept arguments: Leonard Sheldon
#I am the decorator. Somehow you passed me arguments: Leonard Sheldon
#I am the wrapper around the decorated function. 
#I can access all the variables 
#   - from the decorator: Leonard Sheldon 
#   - from the function call: Rajesh Howard 
#Then I can pass them to the decorated function
#I am the decorated function and only knows about my arguments: Rajesh Howard

下面这个就是带参数的装饰器

c1 = \"Penny\"
c2 = \"Leslie\"

@decorator_maker_with_arguments(\"Leonard\", c1)
def decorated_function_with_arguments(function_arg1, function_arg2):
    print(\"I am the decorated function and only knows about my arguments:\"
           \" {0} {1}\".format(function_arg1, function_arg2))

decorated_function_with_arguments(c2, \"Howard\")
#outputs:
#I make decorators! And I accept arguments: Leonard Penny
#I am the decorator. Somehow you passed me arguments: Leonard Penny
#I am the wrapper around the decorated function. 
#I can access all the variables 
#   - from the decorator: Leonard Penny 
#   - from the function call: Leslie Howard 
#Then I can pass them to the decorated function
#I am the decorated function and only knows about my arguments: Leslie Howard

用上面的方法可以向装饰器传递参数，也可以用 *args, **kwargs这样的参数形式。
但是要记住，这样的动态方法只能被使用一次，就是导入这个脚本的时候，后面不能再动态使用。

装饰一个装饰器

看下面的装饰器

def decorator_with_args(decorator_to_enhance):
    \"\"\" 
    This function is supposed to be used as a decorator.
    It must decorate an other function, that is intended to be used as a decorator.
    Take a cup of coffee.
    It will allow any decorator to accept an arbitrary number of arguments,
    saving you the headache to remember how to do that every time. 
   \"\"\"
    # We use the same trick we did to pass arguments
    def decorator_maker(*args, **kwargs):
        # We create on the fly a decorator that accepts only a function
        # but keeps the passed arguments from the maker.
        def decorator_wrapper(func):
            # We return the result of the original decorator, which, after all,
             # IS JUST AN ORDINARY FUNCTION (which returns a function).
            # Only pitfall: the decorator must have this specific signature or it won\'t work:
            return decorator_to_enhance(func, *args, **kwargs)
        return decorator_wrapper
    return decorator_maker

他应该这样使用

# You create the function you will use as a decorator. And stick a decorator on it :-)# Don\'t forget, the signature is \"decorator(func, *args, **kwargs)\"
@decorator_with_args 
def decorated_decorator(func, *args, **kwargs):
     def wrapper(function_arg1, function_arg2):
        print(\"Decorated with {0} {1}\".format(args, kwargs))
        return func(function_arg1, function_arg2)
    return wrapper# Then you decorate the functions you wish with your brand new decorated decorator.

@decorated_decorator(42, 404, 1024)
def decorated_function(function_arg1, function_arg2):
    print(\"Hello {0} {1}\".format(function_arg1, function_arg2))

decorated_function(\"Universe and\", \"everything\")
#outputs:
#Decorated with (42, 404, 1024) {}
#Hello Universe and everything
# Whoooot!

最佳实践

1. 装饰器在python2.4后被引入，使用的时候确认版本支持。
2. 使用装饰器会增加函数调用的时间。
3. 被装饰的函数不能取消装饰
4. 装饰器使得代码更加难以调试

注意，使用装饰器会会有一些副作用，被装饰的函数其实已经是另外一个函数了。
为了消除这个副作用，可以使用functools.wraps这个方法。看下面的例子。

# For debugging, the stacktrace prints you the function __name__
def foo():
    print(\"foo\")

print(foo.__name__)
#outputs: foo
# With a decorator, it gets messy    

def bar(func):
    def wrapper():
        print(\"bar\")
        return func()
    return wrapper

@bar
def foo():
    print(\"foo\")
print(foo.__name__)
#outputs: wrapper
# \"functools\" can help for that

import functools
def bar(func):
    # We say that \"wrapper\", is wrapping \"func\"
    # and the magic begins
    @functools.wraps(func)
    def wrapper():
        print(\"bar\")
        return func()
    return wrapper

@bar
def foo():
    print(\"foo\")
print(foo.__name__)
#outputs: foo

实际使用

装饰器可以在很多场景下使用。
比如倒入某个外部库的时候，可以使用装饰器扩展库中函数的行为。
或者在debug的时候使用。

def benchmark(func):
    \"\"\"
    A decorator that prints the time a function takes    to execute.
    \"\"\"
    import time
    def wrapper(*args, **kwargs):
        t = time.clock()
        res = func(*args, **kwargs)
        print(\"{0} {1}\".format(func.__name__, time.clock()-t))
        return res
    return wrapper

def logging(func):
    \"\"\"
    A decorator that logs the activity of the script.    (it actually just prints it, but it could be logging!)
    \"\"\"
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        print(\"{0} {1} {2}\".format(func.__name__, args, kwargs))
        return res
    return wrapper

def counter(func):
    \"\"\"
    A decorator that counts and prints the number of times a function has been executed
    \"\"\"
    def wrapper(*args, **kwargs):
        wrapper.count = wrapper.count + 1
        res = func(*args, **kwargs)
        print(\"{0} has been used: {1}x\".format(func.__name__, wrapper.count))
        return res
    wrapper.count = 0
    return wrapper

@counter
@benchmark
@logging
def reverse_string(string):
    return str(reversed(string))
print(reverse_string(\"Able was I ere I saw Elba\"))
print(reverse_string(\"A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!\"))
#outputs:
#reverse_string (\'Able was I ere I saw Elba\',) {}
#wrapper 0.0
#wrapper has been used: 1x
#ablE was I ere I saw elbA
#reverse_string (\'A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!\',) {}
#wrapper 0.0
#wrapper has been used: 2x
#!amanaP :lanac a ,noep a ,stah eros ,raj a ,hsac ,oloR a ,tur a ,mapS ,snip ,eperc a ,)lemac a ro( niaga gab ananab a ,gat a ,nat a ,gab ananab a ,gag a ,inoracam ,elacrep ,epins ,spam ,arutaroloc a ,shajar ,soreh ,atsap ,eonac a ,nalp a ,nam A

使用装饰器可以少写很多重复的代码

@counter
@benchmark
@logging
def get_random_futurama_quote():
    from urllib import urlopen
    result = urlopen(\"http://subfusion.net/cgi-bin/quote.pl?quote=futurama\").read()
    try:
        value = result.split(\"

\")[1].split(\"

\")[0]
        return value.strip()
    except:
        return \"No, I\'m ... doesn\'t!\"

print(get_random_futurama_quote())
print(get_random_futurama_quote())
#outputs:
#get_random_futurama_quote () {}
#wrapper 0.02
#wrapper has been used: 1x
#The laws of science be a harsh mistress.
#get_random_futurama_quote () {}
#wrapper 0.01
#wrapper has been used: 2x
#Curse you, merciful Poseidon!