手工装饰器

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

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 in 
any 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 runs 
I am a stand alone function, don't you dare modify me 
After the function runs 
""" 

a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)

@my_shiny_new_decorator 
def another_stand_alone_function(): 
    print "Leave me alone" 
 
another_stand_alone_function() 
"""outputs: 
Before the function runs 
Leave me alone 
After the function runs 
""" 

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() 
"""outputs: 
</''''''/> 
 #tomatoes# 
 --ham-- 
 ~salad~ 
</______/> 
""" 

@bread 
@ingredients 
def sandwich_2(food="--ham_2--"): 
    print food 
 
sandwich_2() 

@ingredients 
@bread 
def strange_sandwich(food="--ham--"): 
    print food 
 
strange_sandwich() 
"""outputs: 
#tomatoes# 
</''''''/> 
 --ham-- 
</______/> 
 ~salad~ 
""" 

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 are 
calling the wrapper, passing arguments to the wrapper will let it pass them to 
the decorated function 
""" 
 
 
@a_decorator_passing_arguments 
def print_full_name(first_name, last_name): 
    print "My name is", first_name, last_name 
 
 
print_full_name("Peter", "Venkman") 
"""outputs: 
I got args! Look: Peter Venkman 
My name is Peter Venkman 
""" 

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 %s, what did you think?" % (self.age + lie) 
 
l = Lucy() 
l.sayYourAge(-3) 
# outputs: I am 26, what did you think? 

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 

# For debugging, the stacktrace prints you the function __name__ 
def foo(): 
    print "foo" 
 
print foo.__name__ 
# outputs: foo 
 
 
def bar(func): 
    def wrapper(): 
        print "bar" 
        return func() 
    return wrapper 
 
 
@bar 
def foo(): 
    print "foo" 
 
print foo.__name__ 
# outputs: wrapper 
 
 
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 

from functools import wraps 
 
def cache(func): 
    caches = {} 
 
    @wraps(func) 
    def wrap(*args): 
        if args not in caches: 
            caches[args] = func(*args) 
 
        return caches[args] 
    return wrap 
 
 
@cache 
def fib_cache(n): 
    assert n > 0, 'invalid n' 
    if n < 3: 
        return 1 
    else: 
        return fib_cache(n - 1) + fib_cache(n - 2)