前提知识：

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)