看看留档看看装饰器是如何工作的。这是你要求的：

from functools import wraps
def makebold(fn):@wraps(fn)def wrapper(*args, **kwargs):return "<b>" + fn(*args, **kwargs) + "</b>"return wrapper
def makeitalic(fn):@wraps(fn)def wrapper(*args, **kwargs):return "<i>" + fn(*args, **kwargs) + "</i>"return wrapper
@makebold@makeitalicdef hello():return "hello world"
@makebold@makeitalicdef log(s):return s
print hello()        # returns "<b><i>hello world</i></b>"print hello.__name__ # with functools.wraps() this returns "hello"print log('hello')   # returns "<b><i>hello</i></b>"

Python装饰器为另一个函数添加额外的功能

斜体装饰师可能就像

def makeitalic(fn):def newFunc():return "<i>" + fn() + "</i>"return newFunc

请注意，函数是在函数内部定义的。它的基本作用是用新定义的函数替换函数。例如，我有这个类

class foo:def bar(self):print "hi"def foobar(self):print "hi again"

现在说，我希望这两个函数在完成之后和之前打印 "---" 。我可以在每个print语句之前和之后添加一个print "---" 。不过因为我不喜欢重复自己，我会做一个装修工

def addDashes(fn): # notice it takes a function as an argumentdef newFunction(self): # define a new functionprint "---"fn(self) # call the original functionprint "---"return newFunction# Return the newly defined function - it will "replace" the original

所以现在我可以把我的课改成

class foo:@addDashesdef bar(self):print "hi"
@addDashesdef foobar(self):print "hi again"

有关装饰器的更多信息，请查看http://www.ibm.com/developerworks/linux/library/l-cpdecor.html

或者，您可以编写一个工厂函数，该函数返回一个装饰器，该装饰器将装饰函数的返回值包装在传递给工厂函数的标记中。例如：

from functools import wraps
def wrap_in_tag(tag):def factory(func):@wraps(func)def decorator():return '<%(tag)s>%(rv)s</%(tag)s>' % ({'tag': tag, 'rv': func()})return decoratorreturn factory

这使您能够编写：

@wrap_in_tag('b')@wrap_in_tag('i')def say():return 'hello'

或

makebold = wrap_in_tag('b')makeitalic = wrap_in_tag('i')
@makebold@makeitalicdef say():return 'hello'

就我个人而言，我会写一些不同的装饰器：

from functools import wraps
def wrap_in_tag(tag):def factory(func):@wraps(func)def decorator(val):return func('<%(tag)s>%(val)s</%(tag)s>' %{'tag': tag, 'val': val})return decoratorreturn factory

这将产生：

@wrap_in_tag('b')@wrap_in_tag('i')def say(val):return valsay('hello')

不要忘记装饰器语法是其简写的结构：

say = wrap_in_tag('b')(wrap_in_tag('i')(say)))

装饰者只是语法糖。

这个

@decoratordef func():...

扩展到

def func():...func = decorator(func)

如果你不喜欢冗长的解释，请参阅Paolo Bergantino的回答。

装饰基础

Python的函数是对象

要理解装饰器，你必须首先理解函数是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 objectscream = 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 shouttry:print(shout())except NameError as e:print(e)#outputs: "name 'shout' is not defined"
print(scream())# outputs: 'Yes!'

记住这一点。我们很快会回到它。

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 as e:print(e)#outputs : "name 'whisper' is not defined"*#Python's functions are objects

函数引用

还在这儿？现在有趣的是…

你已经看到函数是对象。因此，函数：

• 可以分配给一个变量
• 可以在另一个函数中定义

这意味着一个函数可以#0另一个函数。

def getTalk(kind="shout"):
# We define functions on the flydef shout(word="yes"):return word.capitalize()+"!"
def whisper(word="yes") :return word.lower()+"..."
# Then we return one of themif kind == "shout":# We don't use "()", we are not calling the function,# we are returning the function objectreturn shoutelse:return whisper
# How do you use this strange beast?
# Get the function and assign it to a variabletalk = getTalk()
# You can see that "talk" is here a function object:print(talk)#outputs : <function shout at 0xb7ea817c>
# 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...

还有更多！

如果你可以return一个函数，你可以传递一个作为参数：

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!

好吧，你只需要了解装饰器所需的一切。你看，装饰器是“包装器”，这意味着他们让你在他们装饰的函数之前和之后执行代码不修改函数本身。

手工装饰

你如何手动完成：

# A decorator is a function that expects ANOTHER function as parameterdef 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 calledprint("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 calledprint("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_decorated。这很容易，只需用my_shiny_new_decorator返回的函数覆盖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
# That’s EXACTLY what decorators do!

装饰师揭秘

前面的示例，使用装饰器语法：

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

是的，就是这样，就是这么简单。@decorator只是一个快捷方式：

another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)

装饰器只是装饰设计模式的Python变体。Python中嵌入了几个经典的设计模式来简化开发（如迭代器）。

当然，你可以积累装饰器：

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~#<\______/>

使用Python装饰器语法：

@bread@ingredientsdef sandwich(food="--ham--"):print(food)
sandwich()#outputs:#</''''''\># #tomatoes## --ham--# ~salad~#<\______/>

您设置装饰器的顺序很重要：

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

现在回答这个问题…

作为结论，你可以很容易地看到如何回答这个问题：

# The decorator to make it bolddef makebold(fn):# The new function the decorator returnsdef wrapper():# Insertion of some code before and afterreturn "<b>" + fn() + "</b>"return wrapper
# The decorator to make it italicdef makeitalic(fn):# The new function the decorator returnsdef wrapper():# Insertion of some code before and afterreturn "<i>" + fn() + "</i>"return wrapper
@makebold@makeitalicdef say():return "hello"
print(say())#outputs: <b><i>hello</i></b>
# This is the exact equivalent todef say():return "hello"say = makebold(makeitalic(say))
print(say())#outputs: <b><i>hello</i></b>

你现在可以快乐地离开，或者多燃烧一下你的大脑，看看装饰器的高级用途。

把装饰师带到下一个层次

将参数传递给修饰函数

# It’s not black magic, you just have to let the wrapper# pass the argument:
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
# 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_argumentsdef 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）的引用。

这意味着你可以用同样的方式为方法构建装饰器！只要记住考虑self：

def method_friendly_decorator(method_to_decorate):def wrapper(self, lie):lie = lie - 3 # very friendly, decrease age even more :-)return method_to_decorate(self, lie)return wrapper    
    
class Lucy(object):    
def __init__(self):self.age = 32    
@method_friendly_decoratordef 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 argumentsdef 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_argumentsdef 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_argumentsdef 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_argumentsdef 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_argumentsdef sayYourAge(self, lie=-3): # You can now add a default valueprint("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 functionsdef 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_decoratordef 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: https://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-pythonprint("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 know about my arguments: Leslie Howard

如你所见，你可以像使用这个技巧的任何函数一样将参数传递给装饰器。如果你愿意，你甚至可以使用*args, **kwargs。但请记住装饰器被称为只有一次。就在Python导入脚本的时候。之后你不能动态设置参数。当你做“导入x”时，函数已经修饰好了，所以你不能改变一切

让我们练习：装饰装饰师

好的，作为奖励，我会给你一个片段，让任何装饰器普遍接受任何参数。毕竟，为了接受参数，我们使用另一个函数创建了我们的装饰器。

我们包装了装饰器。

我们最近还看到了其他包装函数吗？

哦，是的，设计师！

让我们玩得开心，为装饰者写一个装饰器：

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 argumentsdef 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_argsdef 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!

我知道，上一次你有这种感觉，是在听了一个人说：“在理解递归之前，你必须先理解递归”。但是现在，你对掌握这个感觉不好吗？

最佳实践：装饰者

• 装饰器是在Python 2.4中引入的，因此请确保您的代码将在>=2.4上运行。
• 装饰器会减慢函数调用。请记住这一点。
• 您不能取消装饰函数。（有是个方法可以创建可以删除的装饰器，但没有人使用它们。）所以一旦一个函数被装饰，它就会被装饰对于所有代码。
• 装饰器包装函数，这会使它们难以调试。（Python>=2.5更好；见下文。）

functools模块是在Python 2.5中引入的。它包括函数functools.wraps()，它将装饰函数的名称、模块和文档字符串复制到其包装器中。

（有趣的事实：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 messydef bar(func):def wrapper():print("bar")return func()return wrapper
@bardef 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
@bardef foo():print("foo")
print(foo.__name__)#outputs: foo

装饰师如何才能有用？

现在最大的问题是：我可以使用装饰器做什么？

看起来很酷很强大，但一个实际的例子会很棒。嗯，有1000种可能性。经典用法是从外部库扩展函数行为（你不能修改它），或者用于调试（你不想修改它，因为它是临时的）。

您可以使用它们以DRY的方式扩展多个函数，如下所示：

def benchmark(func):"""A decorator that prints the time a function takesto execute."""import timedef wrapper(*args, **kwargs):t = time.clock()res = func(*args, **kwargs)print("{0} {1}".format(func.__name__, time.clock()-t))return resreturn 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 resreturn 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 + 1res = func(*args, **kwargs)print("{0} has been used: {1}x".format(func.__name__, wrapper.count))return reswrapper.count = 0return wrapper
@counter@benchmark@loggingdef 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@loggingdef get_random_futurama_quote():from urllib import urlopenresult = urlopen("http://subfusion.net/cgi-bin/quote.pl?quote=futurama").read()try:value = result.split("<br><b><hr><br>")[1].split("<br><br><hr>")[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!

Python本身提供了几个装饰器：property、staticmethod等。

• Django使用装饰器来管理缓存和查看权限。
• 扭曲以伪造内联异步函数调用。

这真的是一个大操场。

当然，您也可以从装饰器函数返回lambda：

def makebold(f):return lambda: "<b>" + f() + "</b>"def makeitalic(f):return lambda: "<i>" + f() + "</i>"
@makebold@makeitalicdef say():return "Hello"
print say()

做同样的事情的另一种方式：

class bol(object):def __init__(self, f):self.f = fdef __call__(self):return "<b>{}</b>".format(self.f())
class ita(object):def __init__(self, f):self.f = fdef __call__(self):return "<i>{}</i>".format(self.f())
@bol@itadef sayhi():return 'hi'

或者更灵活地说：

class sty(object):def __init__(self, tag):self.tag = tagdef __call__(self, f):def newf():return "<{tag}>{res}</{tag}>".format(res=f(), tag=self.tag)return newf
@sty('b')@sty('i')def sayhi():return 'hi'

说到反例-如上所述，计数器将在使用装饰器的所有函数之间共享：

def counter(func):def wrapped(*args, **kws):print 'Called #%i' % wrapped.countwrapped.count += 1return func(*args, **kws)wrapped.count = 0return wrapped

这样，您的装饰器可以被重用于不同的函数（或用于多次装饰同一个函数：func_counter1 = counter(func); func_counter2 = counter(func)），并且计数器变量对每个函数都保持私有。

装饰器接受函数定义并创建一个执行此函数并转换结果的新函数。

@decodef do():...

相当于：

do = deco(do)

示例：

def deco(func):def inner(letter):return func(letter).upper()  #upperreturn inner

这个

@decodef do(number):return chr(number)  # number to letter

相当于这个

def do2(number):return chr(number)
do2 = deco(do2)

65<=>'a'

print(do(65))print(do2(65))>>> B>>> B

要理解装饰器，重要的是要注意，装饰器创建了一个新函数do，它是执行函数并转换结果的内部函数。

用不同数量的参数装饰函数：

def frame_tests(fn):def wrapper(*args):print "\nStart: %s" %(fn.__name__)fn(*args)print "End: %s\n" %(fn.__name__)return wrapper
@frame_testsdef test_fn1():print "This is only a test!"
@frame_testsdef test_fn2(s1):print "This is only a test! %s" %(s1)
@frame_testsdef test_fn3(s1, s2):print "This is only a test! %s %s" %(s1, s2)
if __name__ == "__main__":test_fn1()test_fn2('OK!')test_fn3('OK!', 'Just a test!')

结果：

Start: test_fn1This is only a test!End: test_fn1  
  
Start: test_fn2This is only a test! OK!End: test_fn2  
  
Start: test_fn3This is only a test! OK! Just a test!End: test_fn3

这是一个链接装饰器的简单示例。注意最后一行-它显示了幕后发生的事情。

##############################################################    decorators#############################################################
def bold(fn):def decorate():# surround with bold tags before calling original functionreturn "<b>" + fn() + "</b>"return decorate

def uk(fn):def decorate():# swap month and dayfields = fn().split('/')date = fields[1] + "/" + fields[0] + "/" + fields[2]return datereturn decorate
import datetimedef getDate():now = datetime.datetime.now()return "%d/%d/%d" % (now.day, now.month, now.year)
@bolddef getBoldDate():return getDate()
@ukdef getUkDate():return getDate()
@bold@ukdef getBoldUkDate():return getDate()

print getDate()print getBoldDate()print getUkDate()print getBoldUkDate()# what is happening under the coversprint bold(uk(getDate))()

输出如下所示：

17/6/2013<b>17/6/2013</b>6/17/2013<b>6/17/2013</b><b>6/17/2013</b>

#decorator.pydef makeHtmlTag(tag, *args, **kwds):def real_decorator(fn):css_class = " class='{0}'".format(kwds["css_class"]) \if "css_class" in kwds else ""def wrapped(*args, **kwds):return "<"+tag+css_class+">" + fn(*args, **kwds) + "</"+tag+">"return wrapped# return decorator dont call itreturn real_decorator
@makeHtmlTag(tag="b", css_class="bold_css")@makeHtmlTag(tag="i", css_class="italic_css")def hello():return "hello world"
print hello()

你也可以在课堂上写装饰器

#class.pyclass makeHtmlTagClass(object):def __init__(self, tag, css_class=""):self._tag = tagself._css_class = " class='{0}'".format(css_class) \if css_class != "" else ""
def __call__(self, fn):def wrapped(*args, **kwargs):return "<" + self._tag + self._css_class+">"  \+ fn(*args, **kwargs) + "</" + self._tag + ">"return wrapped
@makeHtmlTagClass(tag="b", css_class="bold_css")@makeHtmlTagClass(tag="i", css_class="italic_css")def hello(name):return "Hello, {}".format(name)
print hello("Your name")

你可以创建了两个单独的装饰器，它们可以做你想做的事情，如下所示。请注意，在wrapped()函数的声明中使用了*args, **kwargs，它支持具有多个参数的装饰函数（这对于示例say()函数来说并不是真正必要的，但为了通用而包含）。

出于类似的原因，functools.wraps装饰器用于将包装函数的元属性更改为被装饰函数的元属性。这使得错误消息和嵌入函数留档（func.__doc__）是装饰函数的，而不是wrapped()的。

from functools import wraps
def makebold(fn):@wraps(fn)def wrapped(*args, **kwargs):return "<b>" + fn(*args, **kwargs) + "</b>"return wrapped
def makeitalic(fn):@wraps(fn)def wrapped(*args, **kwargs):return "<i>" + fn(*args, **kwargs) + "</i>"return wrapped
@makebold@makeitalicdef say():return 'Hello'
print(say())  # -> <b><i>Hello</i></b>

改进

正如你所看到的，这两个装饰器中有很多重复的代码。鉴于这种相似性，最好做一个实际上是装饰工厂的泛型代码——换句话说，一个制作其他装饰器的装饰器函数。这样就会减少代码重复——并允许遵循DRY原则。

def html_deco(tag):def decorator(fn):@wraps(fn)def wrapped(*args, **kwargs):return '<%s>' % tag + fn(*args, **kwargs) + '</%s>' % tagreturn wrappedreturn decorator
@html_deco('b')@html_deco('i')def greet(whom=''):return 'Hello' + (' ' + whom) if whom else ''
print(greet('world'))  # -> <b><i>Hello world</i></b>

为了使代码更具可读性，您可以为工厂生成的装饰器分配一个更具描述性的名称：

makebold = html_deco('b')makeitalic = html_deco('i')
@makebold@makeitalicdef greet(whom=''):return 'Hello' + (' ' + whom) if whom else ''
print(greet('world'))  # -> <b><i>Hello world</i></b>

或者把它们组合成这样：

makebolditalic = lambda fn: makebold(makeitalic(fn))
@makebolditalicdef greet(whom=''):return 'Hello' + (' ' + whom) if whom else ''
print(greet('world'))  # -> <b><i>Hello world</i></b>

效率

虽然上面的示例完成了所有工作，但当同时应用多个装饰器时，生成的代码涉及相当多的开销，形式为无关的函数调用。这可能无关紧要，具体取决于确切的用法（例如，可能是I/O绑定）。

如果修饰函数的速度很重要，那么开销可以通过编写一个稍微不同的装饰器工厂函数来保持一个额外的函数调用，该工厂函数实现一次添加所有标签，因此它可以生成代码，避免为每个标签使用单独的装饰器所产生的附加函数调用。

这需要装饰器本身中的更多代码，但这仅在将其应用于函数定义时运行，而不是在调用它们本身时运行。这也适用于使用前面说明的lambda函数创建更具可读性的名称时。示例：

def multi_html_deco(*tags):start_tags, end_tags = [], []for tag in tags:start_tags.append('<%s>' % tag)end_tags.append('</%s>' % tag)start_tags = ''.join(start_tags)end_tags = ''.join(reversed(end_tags))
def decorator(fn):@wraps(fn)def wrapped(*args, **kwargs):return start_tags + fn(*args, **kwargs) + end_tagsreturn wrappedreturn decorator
makebolditalic = multi_html_deco('b', 'i')
@makebolditalicdef greet(whom=''):return 'Hello' + (' ' + whom) if whom else ''
print(greet('world'))  # -> <b><i>Hello world</i></b>

如何在Python中制作两个可以执行以下操作的装饰器？

调用时，您需要以下函数：

@makebold@makeitalicdef say():return "Hello"

返回：

<b><i>Hello</i></b>

简单的解决方案

为了最简单地做到这一点，让装饰器返回lambdas（匿名函数），关闭函数（闭包）并调用它：

def makeitalic(fn):return lambda: '<i>' + fn() + '</i>'
def makebold(fn):return lambda: '<b>' + fn() + '</b>'

现在根据需要使用它们：

@makebold@makeitalicdef say():return 'Hello'

现在：

>>> say()'<b><i>Hello</i></b>'

简单解决方案的问题

但我们似乎几乎失去了原来的功能。

>>> say<function <lambda> at 0x4ACFA070>

为了找到它，我们需要挖掘每个lambda的闭包，其中一个埋在另一个中：

>>> say.__closure__[0].cell_contents<function <lambda> at 0x4ACFA030>>>> say.__closure__[0].cell_contents.__closure__[0].cell_contents<function say at 0x4ACFA730>

因此，如果我们在这个函数上留档，或者希望能够装饰接受多个参数的函数，或者我们只是想知道我们在调试会话中看到的是什么函数，我们需要对包装器做更多的事情。

全功能解决方案-克服大多数这些问题

我们有标准库中functools模块中的装饰器wraps！

from functools import wraps
def makeitalic(fn):# must assign/update attributes from wrapped function to wrapper# __module__, __name__, __doc__, and __dict__ by default@wraps(fn) # explicitly give function whose attributes it is applyingdef wrapped(*args, **kwargs):return '<i>' + fn(*args, **kwargs) + '</i>'return wrapped
def makebold(fn):@wraps(fn)def wrapped(*args, **kwargs):return '<b>' + fn(*args, **kwargs) + '</b>'return wrapped

不幸的是，仍然有一些样板，但这是我们所能做到的最简单。

在Python 3中，默认情况下还会分配__qualname__和__annotations__。

所以现在：

@makebold@makeitalicdef say():"""This function returns a bolded, italicized 'hello'"""return 'Hello'

现在：

>>> say<function say at 0x14BB8F70>>>> help(say)Help on function say in module __main__:
say(*args, **kwargs)This function returns a bolded, italicized 'hello'

结论

所以我们看到wraps使得包装函数几乎可以做所有事情，除了告诉我们函数将什么作为参数。

还有其他模块可以尝试解决这个问题，但解决方案还没有在标准库中。

这个答案早已得到了回答，但我想我会分享我的装饰器类，它使编写新的装饰器变得简单而紧凑。

from abc import ABCMeta, abstractclassmethod
class Decorator(metaclass=ABCMeta):""" Acts as a base class for all decorators """
def __init__(self):self.method = None
def __call__(self, method):self.method = methodreturn self.call
@abstractclassmethoddef call(self, *args, **kwargs):return self.method(*args, **kwargs)

首先，我认为这使得装饰器的行为非常清晰，但它也使得非常简洁地定义新的装饰器变得容易。对于上面列出的例子，你可以将其解为：

class MakeBold(Decorator):def call():return "<b>" + self.method() + "</b>"
class MakeItalic(Decorator):def call():return "<i>" + self.method() + "</i>"
@MakeBold()@MakeItalic()def say():return "Hello"

您还可以使用它来执行更复杂的任务，例如自动使函数递归应用于迭代器中的所有参数的装饰器：

class ApplyRecursive(Decorator):def __init__(self, *types):super().__init__()if not len(types):types = (dict, list, tuple, set)self._types = types
def call(self, arg):if dict in self._types and isinstance(arg, dict):return {key: self.call(value) for key, value in arg.items()}
if set in self._types and isinstance(arg, set):return set(self.call(value) for value in arg)
if tuple in self._types and isinstance(arg, tuple):return tuple(self.call(value) for value in arg)
if list in self._types and isinstance(arg, list):return list(self.call(value) for value in arg)
return self.method(arg)

@ApplyRecursive(tuple, set, dict)def double(arg):return 2*arg
print(double(1))print(double({'a': 1, 'b': 2}))print(double({1, 2, 3}))print(double((1, 2, 3, 4)))print(double([1, 2, 3, 4, 5]))

哪些打印：

2{'a': 2, 'b': 4}{2, 4, 6}(2, 4, 6, 8)[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

请注意，此示例在装饰器的实例化中不包含list类型，因此在最终的print语句中，该方法应用于列表本身，而不是列表的元素。

Paolo Bergantino的回答具有仅使用stdlib的巨大优势，并且适用于这个没有装饰者参数和修饰函数参数的简单示例。

但是，如果您想处理更一般的情况，它有3个主要限制：

• 正如在几个答案中已经指出的那样，您不能轻易地将代码修改为添加可选的装饰器参数。例如，创建makestyle(style='bold')装饰器并非易事。
• 此外，使用@functools.wraps不保留签名创建的包装器，因此如果提供了错误的参数，它们将开始执行，并且可能会引发与通常的TypeError不同类型的错误。
• 最后，在使用@functools.wraps到根据其名称访问参数创建的包装器中非常困难。事实上，参数可以出现在*args、**kwargs中，也可能根本不出现（如果它是可选的）。

我写了#0来解决第一个问题，写了#1来解决另外两个问题。请注意，makefun利用了与著名的#3库相同的技巧。

这就是你如何创建一个带有参数的装饰器，返回真正的签名保存包装器：

from decopatch import function_decorator, DECORATEDfrom makefun import wraps
@function_decoratordef makestyle(st='b', fn=DECORATED):open_tag = "<%s>" % stclose_tag = "</%s>" % st
@wraps(fn)def wrapped(*args, **kwargs):return open_tag + fn(*args, **kwargs) + close_tag
return wrapped

decopatch为您提供了另外两种隐藏或显示各种python概念的开发样式，具体取决于您的偏好。最紧凑的样式如下：

from decopatch import function_decorator, WRAPPED, F_ARGS, F_KWARGS
@function_decoratordef makestyle(st='b', fn=WRAPPED, f_args=F_ARGS, f_kwargs=F_KWARGS):open_tag = "<%s>" % stclose_tag = "</%s>" % streturn open_tag + fn(*f_args, **f_kwargs) + close_tag

在这两种情况下，您都可以检查装饰器是否按预期工作：

@makestyle@makestyle('i')def hello(who):return "hello %s" % who
assert hello('world') == '<b><i>hello world</i></b>'

详情请参阅留档。

当您需要在装饰器中添加自定义参数时，我会添加一个案例，将其传递给最终函数，然后使用它。

装饰家们：

def jwt_or_redirect(fn):@wraps(fn)def decorator(*args, **kwargs):...return fn(*args, **kwargs)return decorator
def jwt_refresh(fn):@wraps(fn)def decorator(*args, **kwargs):...new_kwargs = {'refreshed_jwt': 'xxxxx-xxxxxx'}new_kwargs.update(kwargs)return fn(*args, **new_kwargs)return decorator

以及最终功能：

@app.route('/')@jwt_or_redirect@jwt_refreshdef home_page(*args, **kwargs):return kwargs['refreched_jwt']

用于绘制图像的嵌套装饰器的另一个示例：

import matplotlib.pylab as plt
def remove_axis(func):def inner(img, alpha):plt.axis('off')func(img, alpha)return inner
def plot_gray(func):def inner(img, alpha):plt.gray()func(img, alpha)return inner
@remove_axis@plot_graydef plot_image(img, alpha):plt.imshow(img, alpha=alpha)plt.show()

现在，让我们首先使用嵌套装饰器显示一个没有轴标签的彩色图像：

plot_image(plt.imread('lena_color.jpg'), 0.4)

接下来，让我们使用嵌套装饰器remove_axis和plot_gray显示一个没有轴标签的灰度图像（我们需要cmap='gray'，否则默认颜色映射为viridis，因此灰度图像默认不显示为黑白阴影，除非明确指定）

plot_image(plt.imread('lena_bw.jpg'), 0.8)

上述函数调用缩减为以下嵌套调用

remove_axis(plot_gray(plot_image))(img, alpha)

下面是make_bold()和make_italic()：

def make_bold(func):def core(*args, **kwargs):result = func(*args, **kwargs)return "<b>" + result + "</b>"return core
def make_italic(func):def core(*args, **kwargs):result = func(*args, **kwargs)return "<i>" + result + "</i>"return core

您可以将它们用作say()的装饰器，如下所示：

@make_bold@make_italicdef say():return "Hello"
print(say())

输出：

<b><i>Hello</i></b>

当然，您可以直接使用make_bold()和make_italic()而无需装饰器，如下所示：

def say():return "Hello"    
f1 = make_italic(say)f2 = make_bold(f1)result = f2()print(result)

简而言之：

def say():return "Hello"    
result = make_bold(make_italic(say))()print(result)

输出：

<b><i>Hello</i></b>