logo标签列表

如何创建函数装饰器并将它们链接在一起？

pythonfunctiondecoratorpython-decoratorschain
3146

我该如何在Python中创建两个装饰器以实现以下功能？

@make_bold
@make_italic
def say():
   return "Hello"

调用 say() 应该返回：

"<b><i>Hello</i></b>"
1
参见：Python中“at”（@）符号有什么作用？ - Karl Knechtel
22个回答
4766

如果你不想阅读冗长的解释，可以参考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 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 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

函数引用

好的，还在这里？现在是有趣的部分...

您已经看到了函数是对象。因此，函数:

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

这意味着一个函数可以返回另一个函数。

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 : <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...

还有更多！

如果你可以返回一个函数，那么你也可以将其作为参数传递：

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 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_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_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

是的，就是这样简单。 @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
@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~

现在，来回答这个问题...

总结而言，你可以轻松看出如何回答这个问题：

# The decorator to make it bold
def makebold(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return "<b>" + fn() + "</b>"
    return wrapper

# The decorator to make it italic
def makeitalic(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return "<i>" + fn() + "</i>"
    return wrapper

@makebold
@makeitalic
def say():
    return "hello"

print(say())
#outputs: <b><i>hello</i></b>

# This is the exact equivalent to 
def 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_arguments
def 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_decorator
    def 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 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

@a_decorator_passing_arbitrary_arguments
def 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_arguments
def 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_arguments
def 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_arguments
    def sayYourAge(self, lie=-3): # You can now add a default value
        print("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 functions
def 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_decorator
def 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://dev59.com/8HVD5IYBdhLWcg3wVKAb
        print("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导入脚本时调用一次。您不能在之后动态设置参数。当您执行"import 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 arguments
    def 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_args 
def 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 开始改善；请参见下文。）

Python 2.5 引入了 functools 模块。它包括函数 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 messy    
def bar(func):
    def wrapper():
        print("bar")
        return func()
    return wrapper

@bar
def 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

@bar
def foo():
    print("foo")

print(foo.__name__)
#outputs: foo

装饰器有什么用处？

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

装饰器看起来很酷，也很强大，但是实际应用的例子会更好。其实有很多种可能性。常见的用途是从外部库扩展函数的行为（无法修改该库），或用于调试（因为这是临时的，你不想修改它）。

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

def benchmark(func):
    """
    A decorator that prints the time a function takes
    to execute.
    """
    import time
    def wrapper(*args, **kwargs):
        t = time.clock()
        res = func(*args, **kwargs)
        print("{0} {1}".format(func.__name__, time.clock()-t))
        return res
    return 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 res
    return 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 + 1
        res = func(*args, **kwargs)
        print("{0} has been used: {1}x".format(func.__name__, wrapper.count))
        return res
    wrapper.count = 0
    return wrapper

@counter
@benchmark
@logging
def 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

当然，使用修饰器的好处是你可以在几乎任何东西上立即使用它们，而不必重写代码。DRY，我说过：

@counter
@benchmark
@logging
def get_random_futurama_quote():
    from urllib import urlopen
    result = 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使用装饰器来管理缓存和视图权限。
  • Twisted用于模拟内联异步函数调用。

这真的是一个巨大的游乐场。

26
“你不能取消一个函数的装饰。”- 尽管通常是正确的，但可以通过访问由装饰器返回的闭包（即通过其 __closure__ 属性）来提取原始未经装饰的函数。一个例子在 这个答案 中有记录，其中涵盖了如何在有限的情况下向较低级别注入装饰器函数的可能性。 - metatoaster
13
虽然这是一个很好的答案，但我认为在某些方面它有点误导。Python的@decorator语法最常用于将函数替换为包装器闭包（如答案所述）。但它也可以用来用其他东西替换函数。例如，内置的property、classmethod和staticmethod装饰器用一个描述符来替换函数。装饰器还可以对函数进行一些操作，例如将其保存在某种注册表中的引用，然后将其不经过任何包装器的修改返回。 - Blckknght
唯一缺少的是如何测试已创建为装饰器的函数（如果有意义的话）。 - thoroc
2
functools.wraps 在包装函数上设置了属性 __wrapped__，以便检索原始的被包装函数。这比查看闭合变量更可靠。 - merwok
继Blckknght所说的，装饰器不仅可以返回其他东西，它还可以返回任何对象。 - Mous
有没有一种方法可以在堆叠装饰器时保留有关已装饰函数的参数信息，以便inspect.getfullargspec(decoratee)能够产生有用的结果？ - t3chb0t
3088

查看文档以了解装饰器的工作原理。以下是您所要求的内容：

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
@makeitalic
def hello():
    return "hello world"

@makebold
@makeitalic
def 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>"
273
考虑使用 functools.wraps 或者更好的 PyPI 装饰器模块: 它们可以保留一些重要元数据（例如 __name__，并且关于 decorator 包，函数签名）。 - Marius Gedminas
35
装饰函数可带参数，若未指定则会丢失，需要在答案中添加*args和**kwargs。 - Blusky
4
虽然这个答案具有仅使用标准库的巨大优势，并且适用于此简单示例，其中没有“装饰器”参数或“装饰函数”参数，但它具有3个主要限制：（1）不支持可选装饰器参数的简单支持 （2）不保留签名（3）没有从 *args，**kwargs中提取命名参数的简单方法。解决这三个问题的简单方法是使用 decopatch，如 这里 所述。您还可以像 Marius Gedminas 提到的那样使用 decorator 来解决第2和第3点。 - smarie
159

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

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 decorator
    return factory

这使你可以编写：

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

或者

makebold = wrap_in_tag('b')
makeitalic = wrap_in_tag('i')

@makebold
@makeitalic
def 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 decorator
    return factory

这将产生：

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

不要忘记装饰器语法是一种简写的构造方式：

say = wrap_in_tag('b')(wrap_in_tag('i')(say)))
8
我认为尽可能避免使用多个装饰器更好。如果我需要编写一个工厂函数，我会用 *kwargs 来编写它，例如 def wrap_in_tag(*kwargs) 然后使用 @wrap_in_tag('b','i') - guneysus
145

装饰器只是语法糖。

这个

@decorator
def func():
    ...

扩展为

def func():
    ...
func = decorator(func)
3
这太优雅、简洁又易于理解了。给你一万个赞，奥卡姆先生。 - eric
7
很棒且简明的回答。想要补充一点，当使用@decorator()（而不是@decorator）时，这是语法糖，等同于func = decorator()(func)。在需要动态生成装饰器时，这也是常见的做法。 - Omer Dagan
@OmerDagan 这不是语法糖，而只是普通的 Python 代码。在生成器中（@ 符号后面），您可以放置一个产生装饰器函数的普通 Python 表达式。 - leo848
在 func = decorator(func) 中，变量名必须是 func，这也是原始函数的名称吗？var = decorator(func) 也可以工作吗？ - Gathide
是的，左手边变量名和右手边变量名不需要相同；decorator(func)被赋给var。如果它们相同，则将覆盖func。否则不会。 - Anirban Mukherjee
换句话说，如果你想要覆盖 func，那么 @decorator 是一种优雅的简写方式。如果不想覆盖，则必须详细编写 var = decorator(func)。 - Anirban Mukherjee
74

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

def makebold(f): 
    return lambda: "<b>" + f() + "</b>"
def makeitalic(f): 
    return lambda: "<i>" + f() + "</i>"

@makebold
@makeitalic
def say():
    return "Hello"

print say()
13
更进一步，makebold = lambda f: lambda "<b>" + f() + "</b>" 的意思是：创建一个名为 makebold 的 Lambda 函数，该函数接受一个函数 f 作为参数，并返回另一个 Lambda 函数。返回的 Lambda 函数将使用 HTML 标签 <b> 和 </b> 将 f() 函数的结果括起来，从而使文本加粗。 - Robᵩ
16
让函数语法正确的方式是：makebold = lambda f: lambda: "<b>" + f() + "</b>"。该函数的作用是使输入文本加粗，不改变原来的含义。 - martineau
13
虽然有些晚了，但我建议将 makebold = lambda f: lambda *a, **k: "<b>" + f(*a, **k) + "</b>" 翻译为：定义一个函数 makebold，它接受一个函数 f 作为参数，并返回一个新的函数。新函数可以接受任意数量的位置参数和关键字参数，然后在调用原始函数 f 并将结果包装在 HTML 加粗标记中后返回它。 - seequ
1
这需要使用 functools.wraps，以便不丢弃 say 的文档字符串/签名/名称。 - Eric
重要的是你的回答中是否提到了它。在这个页面的其他地方使用@wraps并不能帮助我，当我打印help(say)时，得到的是_"Help on function <lambda>"_而不是_"Help on function say"_。 - Eric
67

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"

现在假设，我希望两个函数在完成前后都打印出"---"。 我可以在每个打印语句前后添加一行代码来实现此目的。 但是因为我不想重复这种操作，所以我会使用装饰器。

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

那现在我可以更改我的类为

class foo:
    @addDashes
    def bar(self):
        print "hi"

    @addDashes
    def foobar(self):
        print "hi again"

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

注意：这并不像@Rune Kaagaard 提出的lambda函数那样优雅。 - rds
1
@Phoenix：需要使用self参数，因为在addDashes()中定义的newFunction()是专门设计为方法装饰器而不是通用函数装饰器。self参数代表类实例，并且会传递给类方法，无论它们是否使用它--请参见@e-satis答案中标题为装饰方法的部分。 - martineau
1
打印输出并请返回翻译后的文本。 - user1767754
缺少 functools.wraps。 - Eric
IBM网站的链接已经过时，是一种误导性的点击诱饵。请更新链接或将其删除。它只会把你带到Big Blue Linux开发者的黑洞中。谢谢。 - Rich Lysakowski PhD
44

您可以创建两个单独的装饰器来实现您想要的效果，就像下面的示例一样。请注意，在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
@makeitalic
def 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>' % tag
        return wrapped
    return 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
@makeitalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

或者甚至可以像这样组合它们：

makebolditalic = lambda fn: makebold(makeitalic(fn))

@makebolditalic
def 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_tags
        return wrapped
    return decorator

makebolditalic = multi_html_deco('b', 'i')

@makebolditalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>
22

另一种实现相同效果的方式：

class bol(object):
  def __init__(self, f):
    self.f = f
  def __call__(self):
    return "<b>{}</b>".format(self.f())

class ita(object):
  def __init__(self, f):
    self.f = f
  def __call__(self):
    return "<i>{}</i>".format(self.f())

@bol
@ita
def sayhi():
  return 'hi'

或者，更灵活地说：

class sty(object):
  def __init__(self, tag):
    self.tag = tag
  def __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'
需要使用functools.update_wrapper来保持sayhi.__name__ == "sayhi"。 - Eric
21

如何在Python中创建两个装饰器，实现以下功能？

当调用以下函数时：

@makebold
@makeitalic
def say():
    return "Hello"

返回：

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

简单方法

为了最简单地实现这一点，可以创建返回lambda（匿名函数）的装饰器，这些lambda在闭包中封闭了函数并调用它：

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

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

现在根据需要使用它们：

@makebold
@makeitalic
def 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 applying
    def 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
@makeitalic
def 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使包装函数几乎可以做所有事情，除了告诉我们函数接受什么参数。

还有其他模块可能会尝试解决这个问题，但解决方案尚未纳入标准库中。

14
一个装饰器会接收一个函数定义，并创建一个新的函数，该函数执行原始函数并转换其结果。
@deco
def do():
    ...

等同于：

do = deco(do)

例子：

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

This

@deco
def 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，它是内部函数，执行原来的函数并转换结果。
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接