关于 Python 装饰器的一些个人理解

桃扇骨 2022-11-29 12:55 221阅读 0赞

装饰器

  1. 本质是一个接受参数为函数的函数。
  2. 作用：为一个已经实现的方法添加额外的通用功能，比如日志记录、运行计时等。

举例

不带参数的装饰器，不用@
  1. # 不带参数的装饰器
  2. def deco_test(func):
  3.     def wrapper(*args, **kwargs):
  4.         print("before function")
  5.         f = func(*args, **kwargs)
  6.         print("after function")
  7.         return f
  8.     return wrapper
  10. def do_something(a,b,c):
  11.     print(a)
  12.     time.sleep(1)
  13.     print(b)
  14.     time.sleep(1)
  15.     print(c)
  16.     return a
  18. if __name__ == '__main__':
  19.     # 不用@
  20.     f = deco_test(do_something)("1","2","3")

输出：

  1. before function
  2. 1
  3. 2
  4. 3
  5. after function

个人理解：

相当于在 do_something 函数外面套了两个输出：before function 和 after function。

不带参数的装饰器，用 @
  1. # 不带参数的装饰器
  2. def deco_test(func):
  3.     def wrapper(*args, **kwargs):
  4.         print("before function")
  5.         f = func(*args, **kwargs)
  6.         print("after function")
  7.         return f
  8.     return wrapper
  10. @deco_test
  11. def do_something(a,b,c):
  12.     print(a)
  13.     time.sleep(1)
  14.     print(b)
  15.     time.sleep(1)
  16.     print(c)
  17.     return a
  19. if __name__ == '__main__':
  20.     # 使用@
  21.     f = do_something("1","2","3")

输出：

  1. before function
  2. 1
  3. 2
  4. 3
  5. after function

个人理解：

相当于执行 do_something 函数的时候，因为有 @ 的原因，已经知道有一层装饰器 deco_test，所以不需要再单独写 deco_test(do_something) 了。

带参数的装饰器
  1. # 带参数的装饰器
  2. def logging(level):
  3.     def wrapper(func):
  4.         def inner_wrapper(*args, **kwargs):
  5.             print("[{level}]: enter function {func}()".format(level=level, func=func.__name__))
  6.             f = func(*args, **kwargs)
  7.             print("after function: [{level}]: enter function {func}()".format(level=level, func=func.__name__))
  8.             return f
  9.         return inner_wrapper
  10.     return wrapper
  12. @logging(level="debug")
  13. def do_something(a,b,c):
  14.     print(a)
  15.     time.sleep(1)
  16.     print(b)
  17.     time.sleep(1)
  18.     print(c)
  19.     return a
  21. if __name__ == '__main__':
  22.     # 使用@
  23.     f = do_something("1","2","3")

输出：

  1. [debug]: enter function do_something()
  2. 1
  3. 2
  4. 3
  5. after function: [debug]: enter function do_something()

个人理解：

装饰器带了一个参数 level = "debug"。

最外层的函数 logging() 接受参数并将它们作用在内部的装饰器函数上面。内层的函数 wrapper() 接受一个函数作为参数，然后在函数上面放置一个装饰器。这里的关键点是装饰器是可以使用传递给 logging() 的参数的。

类装饰器
  1. # 类装饰器
  2. class deco_cls(object):
  3.     def __init__(self, func):
  4.         self._func = func
  6.     def __call__(self, *args, **kwargs):
  7.         print("class decorator before function")
  8.         f = self._func(*args, **kwargs)
  9.         print("class decorator after function")
  10.         return f
  12. @deco_cls
  13. def do_something(a,b,c):
  14.     print(a)
  15.     time.sleep(1)
  16.     print(b)
  17.     time.sleep(1)
  18.     print(c)
  19.     return a
  21. if __name__ == '__main__':
  22.     # 使用@
  23.     f = do_something("1","2","3")

输出：

  1. class decorator before function
  2. 1
  3. 2
  4. 3
  5. class decorator after function

个人理解：

使用一个装饰器去包装函数，返回一个可调用的实例。 因此定义了一个类装饰器。

两层装饰器
  1. # 不带参数的装饰器
  2. def deco_test(func):
  3.     def wrapper(*args, **kwargs):
  4.         print("before function")
  5.         f = func(*args, **kwargs)
  6.         print("after function")
  7.         return f
  8.     return wrapper
  10. # 带参数的装饰器
  11. def logging(level):
  12.     def wrapper(func):
  13.         def inner_wrapper(*args, **kwargs):
  14.             print("[{level}]: enter function {func}()".format(level=level, func=func.__name__))
  15.             f = func(*args, **kwargs)
  16.             print("after function: [{level}]: enter function {func}()".format(level=level, func=func.__name__))
  17.             return f
  18.         return inner_wrapper
  19.     return wrapper
  21. @logging(level="debug")
  22. @deco_test
  23. def do_something(a,b,c):
  24.     print(a)
  25.     time.sleep(1)
  26.     print(b)
  27.     time.sleep(1)
  28.     print(c)
  29.     return a
  31. if __name__ == '__main__':
  32.     # 使用@
  33.     f = do_something("1","2","3")

输出：

  1. [debug]: enter function wrapper()
  2. before function
  3. 1
  4. 2
  5. 3
  6. after function
  7. after function: [debug]: enter function wrapper()

个人理解：

在函数 do_something() 外面先套一层 deco_test() 装饰器，再在最外面套一层 logging() 装饰器。

文档

第九章：元编程

发表评论

表情：
评论列表 （有 0 条评论，221人围观）

还没有评论，来说两句吧...

相关阅读

    相关 python装饰器的理解

    讲 Python 装饰器前，我想先举个例子，跟装饰器这个话题可能很贴切。 每个人都有的内裤主要功能是用来遮羞，但是到了冬天它没法为我们防风御寒，咋办？我们想到的一个办法就是把

    红太狼红太狼/ 0 赞/ 259 阅读