我如何在Python中制作两个装饰器来完成以下操作?

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

调用say()应返回:

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

当前回答

考虑下面的修饰符,注意我们将wrapper()函数作为对象返回

def make_bold(func):
    def wrapper():
        return '<b>'+func()+'</b>'
    return wrapper

所以这个

@make_bold
def say():
    return "Hello"

计算结果为

x = make_bold(say)

注意,x不是say(),而是在内部调用say(()的包装器对象。这就是装饰师的工作原理。它总是返回调用实际函数的包装器对象。如果链接此

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

转换为此

x = make_bold(say)
y = make_italic(x)

以下是完整的代码

def make_italic(func):
    def wrapper():
        return '<i>'+func()+'</i>'
    return wrapper


def make_bold(func):
    def wrapper():
        return '<b>'+func()+'</b>'
    return wrapper


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


if __name__ == '__main__':
    # x = make_bold(say) When you wrap say with make_bold decorator
    # y = make_italic(x) When you also add make_italic as part of chaining
    # print(y())
    print(say())


上述代码将返回

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

希望这有帮助

其他回答

用不同数量的参数修饰函数:

def frame_tests(fn):
    def wrapper(*args):
        print "\nStart: %s" %(fn.__name__)
        fn(*args)
        print "End: %s\n" %(fn.__name__)
    return wrapper

@frame_tests
def test_fn1():
    print "This is only a test!"

@frame_tests
def test_fn2(s1):
    print "This is only a test! %s" %(s1)

@frame_tests
def 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_fn1  
This is only a test!  
End: test_fn1  
  
  
Start: test_fn2  
This is only a test! OK!  
End: test_fn2  
  
  
Start: test_fn3  
This is only a test! OK! Just a test!  
End: test_fn3  

下面有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_italic
def 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>

查看文档以了解装饰器是如何工作的。以下是您的要求:

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

我如何在Python中制作两个装饰器来完成以下操作?

调用时需要以下函数:

@马克博尔德@使倾斜def say():return“您好”

要返回:

<b><i> 你好</i></b>

简单的解决方案

为了最简单地做到这一点,请制作返回lambdas(匿名函数)的装饰器,这些函数在函数(闭包)上关闭并调用它:

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模块的修饰符包装!

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

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

在Python3中,默认情况下还会分配__qualiname__和__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'

结论

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

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

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

装饰师:

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_refresh
def home_page(*args, **kwargs):
  return kwargs['refreched_jwt']