2. Python decorate

1. 装饰器：基础

python 中一切皆是对象，这里需要强调 函数是对象。为了更好地理解函数也是对象，下面结合代码片段来说明这一点。

def shout(word="yes"):    return word.capitalize() + "!"print shout()# outputs: Yes!"""As an object, you can assign the function to a variable like any other object.Notice we don't use parentheses: we are not calling the function,we are putting the function "shout" into the variable "scream"."""scream = shoutprint scream()# outputs: Yes!"""More than that, it means you can remove the old name 'shout',and the function will still be accessible from 'scream'."""del shouttry:    print shout()except NameError, e:    print e    # outputs: name 'shout' is not definedprint scream()# outputs: 'Yes!'

因为函数是对象，所以 python 中函数还有一个有趣的特性：函数可以被定义在另一个函数中。下面来看下具体的例子

def talk():    # You can define a function on the fly in "talk"    def whisper(word="yes"):        return word.lower()+"..."    print whisper()"""You call "talk", that defines "whisper" EVERY TIME you call it,then "whisper" is called in "talk"."""talk()# outputs: yes...# But "whisper" DOES NOT EXIST outside "talk".try:    print whisper()except NameError, e:    print e    # outputs : name 'whisper' is not defined

2 函数引用

前面已经知道了函数是对象。那么：
1. 可以被赋值给另一个变量
2. 可以被定义在另一个函数里

这也意味着，一个函数可以返回另一个函数，下面来看一个简单的例子

def shout(word="yes"):    return word.capitalize() + "!"print shout()# outputs: Yes!"""As an object, you can assign the function to a variable like any other object.Notice we don't use parentheses: we are not calling the function,we are putting the function "shout" into the variable "scream"."""scream = shoutprint scream()# outputs: Yes!"""More than that, it means you can remove the old name 'shout',and the function will still be accessible from 'scream'."""del shouttry:    print shout()except NameError, e:    print e    # outputs: name 'shout' is not definedprint scream()# outputs: 'Yes!'

我们来进一步挖掘一下函数的特性，既然可以返回函数，那么我们也可以把函数作为参数传递

def whisper(word="yes"):    return word.lower() + "..."def do_something_before(func):    print "I do something before."    print "Now the function you gave me:\n", func()do_something_before(whisper)"""outputsI do something before.Now the function you gave me:yes..."""

现在，了解装饰器所需要的所有要点我们已经掌握了，通过上面的例子，我们还可以看出装饰器其实就是封装器，可以让我们在不修改原函数的基础上，在执行原函数的前后执行别的代码。

3 手工装饰器

下面我们手工实现一个简单的装饰器

def my_shiny_new_decorator(a_function_to_decorate):    """    Inside, the decorator defines a function on the fly: the wrapper.    This function is going to be wrapped around the original function    so it can execute code before and after it.    """    def the_wrapper_around_the_original_function():        """        Put here the code you want to be executed BEFORE the original        function is called        """        print "Before the function runs"        # Call the function here (using parentheses)        a_function_to_decorate()        """        Put here the code you want to be executed AFTER the original        function is called        """        print "After the function runs"    """    At this point, "a_function_to_decorate" HAS NEVER BEEN EXECUTED.    We return the wrapper function we have just created.    The wrapper contains the function and the code to execute before    and after. It’s ready to use!    """    return the_wrapper_around_the_original_function# Now imagine you create a function you don't want to ever touch again.def a_stand_alone_function():    print "I am a stand alone function, don't you dare modify me"a_stand_alone_function()# outputs: I am a stand alone function, don't you dare modify me"""Well, you can decorate it to extend its behavior.Just pass it to the decorator, it will wrap it dynamically inany code you want and return you a new function ready to be used:"""a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)a_stand_alone_function_decorated()"""outputs:Before the function runsI am a stand alone function, don't you dare modify meAfter the function runs"""

现在，如何我们想每次调用 a_stand_alone_function 的时候，实际上调用的是封装后的函数 a_stand_alone_function_decorated，那么只需要用 a_stand_alone_function去覆盖my_shiny_new_decorator 返回的函数即可。也就是：

a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)

4 装饰器阐述

对于前面的例子，如果用装饰器语法，可以添加如下：

@my_shiny_new_decoratordef another_stand_alone_function():    print "Leave me alone"another_stand_alone_function()"""outputs:Before the function runsLeave me aloneAfter the function runs"""

以上就是装饰器语法。这里的 @my_shiny_new_decorator 是 another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function) 的简写。

装饰器只是装饰器设计模式的 python 实现，python 还存在其他几个经典的涉及模式，以方便开发，例如迭代器 iterators。

当然了，我们也可以嵌套装饰器

def bread(func):    def wrapper():        print "</''''''\>"        func()        print "<\______/>"    return wrapperdef ingredients(func):    def wrapper():        print "#tomatoes#"        func()        print "~salad~"    return wrapperdef sandwich(food="--ham--"):    print foodsandwich()# outputs: --ham--sandwich = bread(ingredients(sandwich))sandwich()"""outputs:</''''''\> #tomatoes# --ham-- ~salad~<\______/>"""

用 python 的装饰器语法，如下：

@bread@ingredientsdef sandwich_2(food="--ham_2--"):    print foodsandwich_2()

5 装饰器高级用法

5.1 给装饰器函数传递函数

当我们调用装饰器返回的函数时，其实是在调用封装函数，给封装函数传递参数也就同样的给被装饰函数传递了参数。

def a_decorator_passing_arguments(function_to_decorate):    def a_wrapper_accepting_arguments(arg1, arg2):        print "I got args! Look:", arg1, arg2        function_to_decorate(arg1, arg2)    return a_wrapper_accepting_arguments"""Since when you are calling the function returned by the decorator, you arecalling the wrapper, passing arguments to the wrapper will let it pass them tothe decorated function"""@a_decorator_passing_argumentsdef print_full_name(first_name, last_name):    print "My name is", first_name, last_nameprint_full_name("Peter", "Venkman")"""outputs:I got args! Look: Peter VenkmanMy name is Peter Venkman"""

5.2 装饰方法

python 中函数和方法几乎一样，处理方法中第一个参数是指向当前对象的引用(self)。这意味着我们可以为方法创建装饰器，只是要记得考虑 self。

def method_friendly_decorator(method_to_decorate):    def wrapper(self, lie):        lie = lie - 3        return method_to_decorate(self, lie)    return wrapperclass Lucy(object):    def __init__(self):        self.age = 32    @method_friendly_decorator    def sayYourAge(self, lie):        print "I am %s, what did you think?" % (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