Python语言中的装饰器
小标 2018-11-14 来源 : 阅读 746 评论 0

摘要:本文主要向大家介绍了Python语言中的装饰器,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助。

本文主要向大家介绍了Python语言中的装饰器,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助。

装饰器在stackoverflow上看到一篇讲python中decorator的回答,实在是受益匪浅,决定将其翻译成中文,分享给大家。原文链接如下How to make a chain of function decorators in Python?函数是对象在python中,函数是对象。以一个简单的函数为例。def shout(word="yes"):
    return word.capitalize()+"!"print(shout())会输出Yes!作为对象,是可以赋值给另外一个变量的。scream = shoutprint(scream())输出和上面是一样的。更有意思的是,python中的函数是可以定义在另外一个函数内部的。def talk():
    def whisper(word="yes"):
        return word.lower()+"..."
    print(whisper())

talk()输出yes...函数引用通过上面的例子可以看到,函数是对象,所以可以被赋值给另外一个变量可以在另外一个函数中被定义。这也就意味着,一个函数可以将另外一个函数作为返回值。def getTalk(kind="shout"):
    def shout(word="yes"):
        return word.capitalize()+"!"
    def whisper(word="yes"):
        return word.lower()+"..."
    if kind == "shout":        return shout    else:        return whisper

talk = getTalk()print talk    # 输出 print talk()  # 输出 Yes!print getTalk("whisper")()  # 输出yes...如果能够返回一个函数,也可以将一个函数作为参数传入,复用上面的scream函数def doSomethingBefore(func):
    print("I do something before then I call the function you gave me")
    print(func)

doSomethingBefore(scream)输出I do something before then I call the function you gave me
Yes!现在应该能够理解装饰器了吧,装饰器实际上就是对函数进行了包装,它能够在不改变函数的前提下,在这个函数被执行之前或者执行之后执行一段代码。手写装饰器# 装饰器将一个另外的函数作为参数传入def my_shiny_new_decorator(a_function_to_decorate):
    # 定义一个wrapper
    def the_wrapper_around_the_original_function():
        # 在传入的函数被执行前执行
        print("Before the function runs")
        a_function_to_decorate()        # 在传入的函数被执行后执行
        print("After the function runs")    return the_wrapper_around_the_original_functiondef a_stand_alone_function():
    print("I am a stand alone function, don't you dare modify me")

a_stand_alone_function()# 输出:  I am a stand alone function, don't you dare modify mea_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()# 输出 # 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就会被调用,这很简单,只需要用a_stand_alone_function_decorated返回的函数覆盖之前的a_stand_alone_function就可以了。使用装饰器@my_shiny_new_decoratordef another_stand_alone_function():
    print("Leave me alone")

another_stand_alone_function() 
# 输出#Before the function runs#Leave me alone#After the function runs是的,就是这么简单。 @decorator就是下面代码的简写another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)装饰器就是Decorator patternpython式实现。像下面的代码def bread(func):
    def wrapper():
        print("")
        func()
        print("<\______>")    return wrapperdef ingredients(func):
   def wrapper():
        print("#tomatoes#")
        func()
        print("~salad~")    return wrapperdef sandwich(food="--ham--"):
    print(food)

sandwich()#outputs: --ham--sandwich = bread(ingredients(sandwich))
sandwich()就可以写成@bread@ingredientsdef sandwich(food="--ham--"):
    print(food)

sandwich()#outputs:## #tomatoes## --ham--# ~salad~#<\______>装饰器的顺序很重要,如果改变上面的顺序,函数的行为就被改变了@ingredients@breaddef sandwich(food="--ham--"):
    print(food)
strange_sandwich()#outputs:##tomatoes### --ham--#<\______># ~salad~还是一个装饰器的例子# The decorator to make it bolddef makebold(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return "" + fn() + ""
    return wrapper# The decorator to make it italicdef makeitalic(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return "" + fn() + ""
    return wrapper@makebold@makeitalicdef say():
    return "hello"print(say())#outputs: hello# 等同于下面的函数 def say():
    return "hello"say = makebold(makeitalic(say))
print(say())#outputs: hello装饰器更高级的应用向被装饰的函数传递参数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# 因为最终被调用是被装饰器返回的函数,即wrapper,# 所以将参数传递给wrapper会将这些参数传递给被装饰的函数@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)。也就是说装饰方法和装饰函数没有差异,只需要在装饰方法的时候将第一个参数考虑进去就行def method_friendly_decorator(method_to_decorate):    def wrapper(self, lie):
        lie = lie - 3
        return method_to_decorate(self, lie)    return wrapperclass 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, **kwargsdef 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:        # //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_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 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 functiondef 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: //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 knows about my arguments: Leslie Howard用上面的方法可以向装饰器传递参数,也可以用 *args, **kwargs这样的参数形式。但是要记住,这样的动态方法只能被使用一次,就是导入这个脚本的时候,后面不能再动态使用。装饰一个装饰器看下面的装饰器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!最佳实践装饰器在python2.4后被引入,使用的时候确认版本支持。使用装饰器会增加函数调用的时间。被装饰的函数不能取消装饰装饰器使得代码更加难以调试注意,使用装饰器会会有一些副作用,被装饰的函数其实已经是另外一个函数了。为了消除这个副作用,可以使用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@bardef foo():
    print("foo")
print(foo.__name__)#outputs: wrapper# "functools" can help for thatimport functoolsdef 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实际使用装饰器可以在很多场景下使用。比如倒入某个外部库的时候,可以使用装饰器扩展库中函数的行为。或者在debug的时候使用。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 wrapperdef 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 wrapperdef 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@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 urlopen
    result = urlopen("//subfusion.net/cgi-bin/quote.pl?quote=futurama").read()    try:
        value = result.split("


")[1].split("

")[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等等。

本文由职坐标整理并发布,希望对同学们学习Python有所帮助,更多内容请关注职坐标编程语言Python频道!


本文由 @小标 发布于职坐标。未经许可,禁止转载。
喜欢 | 0 不喜欢 | 0
看完这篇文章有何感觉?已经有0人表态,0%的人喜欢 快给朋友分享吧~
评论(0)
后参与评论

您输入的评论内容中包含违禁敏感词

我知道了

助您圆梦职场 匹配合适岗位
验证码手机号,获得海同独家IT培训资料
选择就业方向:
人工智能物联网
大数据开发/分析
人工智能Python
Java全栈开发
WEB前端+H5

请输入正确的手机号码

请输入正确的验证码

获取验证码

您今天的短信下发次数太多了,明天再试试吧!

提交

我们会在第一时间安排职业规划师联系您!

您也可以联系我们的职业规划师咨询:

小职老师的微信号:z_zhizuobiao
小职老师的微信号:z_zhizuobiao

版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com,All Rights Reserved.
 沪公网安备 31011502005948号    

©2015 www.zhizuobiao.com All Rights Reserved

208小时内训课程