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

Question

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

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

调用 say() 应该返回：

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

Answer 1

如果您不喜欢冗长的解释，请参阅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://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-python
        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 上运行。
• 装饰器减慢了函数调用的速度。 记住这一点。
• 你不能取消装饰一个函数。（有一些技巧可以创建可以删除的装饰器，但没有人使用它们。）因此，一旦函数被装饰，它就会被装饰< em>所有代码。
• 装饰器包装函数，这会使它们难以调试。 （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 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

---

装饰器有什么用处？

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

看起来很酷而且很强大，但如果有一个实际的例子就更好了。 嗯，有 1000 种可能性。 经典用途是从外部库扩展函数行为（您无法修改它），或用于调试（您不想修改它，因为它是临时的）。

您可以使用它们以 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

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

这确实是一个大游乐场。

Answer 2

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

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

Answer 3

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

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

Answer 4

装饰器只是语法糖。

这

@decorator
def func():
    ...

扩展到

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

Answer 5

当然，您也可以从装饰器函数返回 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()

Answer 6

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

Answer 7

您可以创建两个独立的装饰器来执行您想要的操作，如下所示。 请注意，在 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>

Answer 8

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

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'

Answer 9

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

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

<前><代码>@makebold
@makeitalic
定义说（）：
返回“你好”

回来：

你好 
  

简单的解决方案

为了最简单地做到这一点，让装饰器返回关闭函数（闭包）的 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 使包装函数几乎可以完成所有操作，除了告诉我们该函数将什么作为参数。

还有其他模块可能会尝试解决该问题，但标准库中尚未提供解决方案。

Answer 10

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

@deco
def do():
    ...

相当于：

do = deco(do)

示例：

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

这

@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 ，它在内部执行函数并转换结果。

Answer 11

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

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 = method
        return self.call

    @abstractclassmethod
    def 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 类型，因此在最终的打印语句中，该方法应用于列表本身，而不是列表的元素。

Answer 12

#decorator.py
def 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 it
    return real_decorator

@makeHtmlTag(tag="b", css_class="bold_css")
@makeHtmlTag(tag="i", css_class="italic_css")
def hello():
    return "hello world"

print hello()

也可以在Class中写装饰器

#class.py
class makeHtmlTagClass(object):
    def __init__(self, tag, css_class=""):
        self._tag = tag
        self._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")

Answer 13

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

############################################################
#
#    decorators
#
############################################################

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


def uk(fn):
    def decorate():
        # swap month and day
        fields = fn().split('/')
        date = fields[1] + "/" + fields[0] + "/" + fields[2]
        return date
    return decorate

import datetime
def getDate():
    now = datetime.datetime.now()
    return "%d/%d/%d" % (now.day, now.month, now.year)

@bold
def getBoldDate(): 
    return getDate()

@uk
def getUkDate():
    return getDate()

@bold
@uk
def getBoldUkDate():
    return getDate()


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

输出看起来像：

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

Answer 14

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

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

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

我写了 decopatch 来解决第一个问题，并写了 makefun.wraps 解决其他问题二。 请注意，makefun 利用了与著名的 decorator 库。

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

from decopatch import function_decorator, DECORATED
from makefun import wraps

@function_decorator
def makestyle(st='b', fn=DECORATED):
    open_tag = "<%s>" % st
    close_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_decorator
def makestyle(st='b', fn=WRAPPED, f_args=F_ARGS, f_kwargs=F_KWARGS):
    open_tag = "<%s>" % st
    close_tag = "</%s>" % st
    return 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>'    

请参阅 文档了解详细信息。

Answer 15

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

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

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

Answer 16

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

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  

Answer 17

考虑下面的装饰器，请注意，我们将wrapper()函数作为对象返回，

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

因此其

@make_bold
def say():
    return "Hello"

计算结果为this

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>

希望这有帮助

Answer 18

使用下面的 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>

Answer 19

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

装饰器：

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']

Answer 20

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

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_gray
def 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)

Answer 21

python 3.9 中的 lambda 表达式可以用作装饰器。

对于您的问题

@lambda func: (lambda *variable: '<b>' + func(*variable) + '</b>')
@lambda func: (lambda *variable: '<i>' + func(*variable) + '</i>')
def say():
    return "Hello"

print(say())

如果您想在第一次函数调用后重用上述 lambda，可以将它们分配给变量并重用。 下面的例子。

@make_bold := lambda func: (lambda *variable: '<b>' + func(*variable) + '</b>')
@make_italic := lambda func: (lambda *variable: '<i>' + func(*variable) + '</i>')
def say():
    return "Hello"

@make_bold
@make_italic
def say2():
    return "World"

print(say())
print(say2())

Answer 22

问题

我们如何在 Python 中制作两个装饰器来执行以下操作？

<前><代码>@make_bold
@make_斜体
定义说（）：
返回“你好”

调用 say() 应返回 "Hello"

---

解决方案

---

make_bold

from functools import update_wrapper  

class make_bold:

    def __new__(cls, kallable):
        instance = super().__new__(cls)
        instance = update_wrapper(instance, kallable)
        return instance

    def __init__(self, kallable):
        self._kallable = kallable
        self._file     = sys.stdout

    def __call__(self, *args, **kwargs):   
        # `iret` ...... initial return value
        # `oret` ...... output  return value
        iret = self._kallable(*args, **kwargs)
        oret = "<b>" + r + "</b>"
        
    def __getattr__(self, attrname:str):  
        return getattr(self._kallable, attrname) 

---

make_italic

from functools import update_wrapper  

class make_italic:

    def __new__(cls, kallable):
        instance = super().__new__(cls)
        instance = update_wrapper(instance, kallable)
        return instance

    def __init__(self, kallable):
        self._kallable = kallable
        self._file     = sys.stdout

    def __call__(self, *args, **kwargs):   
        # `iret` ...... initial return value
        # `oret` ...... output  return value
        iret = self._kallable(*args, **kwargs)
        ret  = "".join(str(x) for x in iret)
        oret = "<i>" + ret + "</i>"
        
    def __getattr__(self, attrname:str):  
        return getattr(self._kallable, attrname) 

---

我向 make_italic 添加了一行以修改包装函数返回的值。

ret = "".join(str(x) for x in iret)

这行代码对某些人来说可能有用，也可能没用：

   ABOUT...         ret = "".join(str(x) for x in iret)
     +--------------+---------------------------+----------+
     | non-standard |           input           |  output  |  
     | notation     |                           |          |
     | for          |                           |          |
     | input        |                           |          |
     | type         |                           |          |
     +--------------+---------------------------+----------+
     | string       | 'howdy'                   | 'howdy'  |
     | tuple<char>  | ('h', 'o', 'w', 'd', 'y') | 'howdy'  |
     | list<char>   | ['h', 'o', 'w', 'd', 'y'] | 'howdy'  |
     | list<string> | ['ho', 'wdy']             | 'howdy'  |
     | list<int>    | [1, 2, 3, 456]            | '123456' |
     +--------------+---------------------------+----------+