前提知识：
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
scream = shout
# Notice we don't use parentheses: we are not calling the function, we are
# putting the function "shout" into the variable "scream".
# It means you can then call "shout" from "scream":
print 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 shout
try:
print shout()
except NameError, e:
print e
#outputs: "name 'shout' is not defined"
print scream()
# outputs: 'Yes!'
2、Python函数里面可以定义函数：
def talk():
# You can define a function on the fly in "talk" ...
def whisper(word="yes"):
return word.lower()+"..."
# ... and use it right away!
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"*
#Python's functions are objects
3、一个函数可以返回另外一个函数：
def getTalk(kind="shout"):
# We define functions on the fly
def shout(word="yes"):
return word.capitalize()+"!"
def whisper(word="yes") :
return word.lower()+"...";
# Then we return one of them
if kind == "shout":
# We don't use "()", we are not calling the function,
# we are returning the function object
return shout
else:
return whisper
# How do you use this strange beast?
# Get the function and assign it to a variable
talk = getTalk()
# You can see that "talk" is here a function object:
print talk
#outputs :
# The object is the one returned by the function:
print talk()
#outputs : Yes!
# And you can even use it directly if you feel wild:
print getTalk("whisper")()
#outputs : yes...这意味着可以把函数当做参数传递给其他函数：
def doSomethingBefore(func):
print "I do something before then I call the function you gave me"
print func()
doSomethingBefore(scream)
#outputs:
#I do something before then I call the function you gave me
#Yes!
下面用几段代码来由浅入深地理解Python装饰器：
1、人工赋值的装饰器：
# A decorator is a function that expects ANOTHER function as parameter
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重新赋值，这样每次调用a_stand_alone_function()的时候就自带装饰器了：
a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#outputs:
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs
# And guess what? That’s EXACTLY what decorators do!
2、把上面这个例子用装饰器的语法重写如下：
@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
我们可以看到装饰器就是
another_stand_alone_function=my_shiny_new_decorator(another_stand_alone_function) 这句话简写
3、我们可以使用多个装饰器，他们之间是嵌套的顺序(从上到下)：
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(food="--ham--"):
print food
sandwich()
#outputs:
#''''''\>
# #tomatoes#
# --ham--
# ~salad~
#
装饰器顺序不同，程序运行的顺序也会不同，例如：
@ingredients
@bread
def strange_sandwich(food="--ham--"):
print food
strange_sandwich()
#outputs:
##tomatoes#
#''''''\>
# --ham--
#
# ~salad~
所以把握好多个装饰器运行的顺序是非常重要的。
(本文代码几个例子引用自stackoverflow上的一个回答：http://stackoverflow.com/questions/739654/how-can-i-make-a-chain-of-function-decorators-in-python/1594484#1594484)
)
