ToB企服应用市场:ToB评测及商务社交产业平台

标题: python 装饰器 [打印本页]
作者: 用多少眼泪才能让你相信    时间: 2024-1-8 16:59
标题: python 装饰器
装饰器(Decorators)是 Python 的一个重要部分。其功能主要为：在不修改函数定义的基础下，增加或修改函数的功能；有助于让我们的代码更简短，也更Pythonic（Python范儿）。
预备知识

函数作为变量
  1. def hi(name="Bob"):
  2.     return "hi " + name
  4. print(hi()) # 直接调用
  5. # [out] hi Bob
  7. greet = hi # 作为变量赋值给 greet
  8. print(greet())
  9. # [out] hi Bob
  11. del hi # 删除hi函数（此时应当是hi函数的实例对象）
  12. print(hi())
  13. # [out] NameError: name 'hi' is not defined
  14. print(greet()) # 输出正常，
  15. # [out] hi Bob
  16. # 可以推测 greet = hi 的过程是将 hi函数实对象的引用赋给了greet,
  17. # del hi是删除了hi变量和hi实例对象的引用关系，
  18. # greet还可以正常引用hi对象实例
复制代码
函数作为参数
  1. def funcFather(f):
  2.     print("I'm funcFather")
  3.     if callable(f):
  4.         f()
  6. def funcSon():
  7.     print("I'm funcSon")
  9. funcFather(funcSon)
  10. # I'm funcFather
  11. # I'm funcSon
复制代码
函数作为返回值
  1. def funcFather():
  2.     print("I'm funcFather")
  3.     return funcSon
  5. def funcSon():
  6.     print("I'm funcSon")
  8. f = funcFather()
  9. f()
  10. # I'm funcFather
  11. # I'm funcSon
复制代码
嵌套函数
在Python中，我们可以在一个函数funcA 中定义另一个函数funcB；
  1. def funcFather():
  2.     print("I'm funcFather")
  4.     def funcSon():
  5.         print("I'm funcSon")
  7.     funcSon()
  9. funcFather()
  10. # I'm funcFather
  11. # I'm funcSon
复制代码
funcB中可以继续嵌套funcC,funcD一直套娃；
闭包
闭包：如果在funcA中定义的局部变量var1，在funcA外部无法引用var1;
如果在函数funcA内定义funcB，在funcB中访问var1,此时在funcA中将funcB作为返回值，则可以达到在funcA外部使用var1;
所以在函数内定义函数，引用外部函数的变量，并以内部函数作为返回值，称为闭包；
以下是一个例子：
  1. def outer(x):
  2.     def inner(y):
  3.         return x + y
  5.     return inner
  8. funcIn = outer(5)
  9. print(funcIn(6))
  10. # 11
复制代码
装饰器

其实装饰器就是一个闭包，装饰器是闭包的一种应用。用于拓展原来函数功能的一种函数，这个函数的特殊之处在于它的返回值也是一个函数，使用python装饰器的好处就是在不用更改原函数的代码前提下给函数增加新的功能。使用时，再需要的函数前加上@demo即可。
基础装饰器
  1. def log(func):
  2.     def wrapper():
  3.         print(f"[INFO]:  enter {func.__name__}")
  4.         return func()
  6.     return wrapper
  8. @log
  9. def hello(name="Bob"):
  10.     print(f"Hi {name}")
  12. hello()
  13. # [INFO]:  enter hello
  14. # Hi Bob
复制代码
以上例说明装饰器执行过程：将被装饰函数（hello）作为变量传给装饰器函数log），
进入log函数，发现其返回了wrapper函数，而wrapper函数则是打印了提示信息后，执行了hello函数；因此以上以上装饰器等价于
  1. log_hello = log(hello)
  2. log_hello()
复制代码
functools.wraps
以上装饰器存在什么问题呢？当我们使用
print(hello.__name__)时，得到的是 wrapper，而不是我们期待的hello！
回到装饰器原理，我们说加了装饰器的函数相当于被包裹了一层，其装饰器函数中的return wrapper才是我们实际得到的函数对象，它重写了我们函数的名字和注释文档(docstring)，因此__name__被改变了。
幸运的是Python提供给我们一个简单的函数来解决这个问题，那就是functools.wraps。我们修改上一个例子来使用functools.wraps：
  1. from functools import wraps
  4. def log(f):
  5.     @wraps(f)
  6.     def wrapper():
  7.         print("Enter wrapper")
  8.         f()
  9.         print("Leave wrapper")
  11.     return wrapper
  14. @log
  15. def hello():
  16.     print("Hi")
  17. print(hello.__name__)
  18. # hello
复制代码
根据以上，一般装饰器定义大致如下：
  1. def decorator(func):
  2.     @wraps(func)
  3.     def wrapper():
  4.         ...
  5.     return wrapper
复制代码
修饰带参数函数
如果被修饰函数带有参数，通常如下定义：
  1. def show_func_args_and_ret(func):
  2.     @wraps(func)
  3.     def wrapper(*args, **kwargs):
  4.         print(f"funcName:{func.__name__}\n"
  5.               f"args:    {args}\n"
  6.               f"kwargs:  {kwargs}\n")
  7.         res = func(*args, **kwargs)
  8.         print(f"return:  {res}\n")
  10.     return wrapper
  13. @show_func_args_and_ret
  14. def hello(hour, name="Bob"):
  15.     print(f"{hour}: Hi,{name}")
  16.     return "ok"
  19. hello(12, name="Ben")
  20. # funcName:hello
  21. # args:    (12,)
  22. # kwargs:  {'name': 'Ben'}
  23. #
  24. # 12: Hi,Ben
  25. # return:  ok
复制代码
将wrapper函数定义为wrapper(*args, **kwargs)以便接受任意格式的参数；由上面装饰器原理我们知道，传递给被修饰函数的参数，都会先传入wrapper函数，因此可以在wrapper 使用参数来显示函数参数，返回值等；在web编程中可以通过获取函数的request参数，完成鉴权等；
带参数装饰器
装饰器也是可以带参数的，但是刚刚演示的装饰器的参数被修饰函数，该如何使得装饰器有自己的参数呢，答案是再套一层；
  1. def logging(level):
  2.     def out_wrapper(func):
  3.         def wrapper(*args, **kwargs):
  4.             print("[{0}]: enter {1}()".format(level, func.__name__))
  5.             return func(*args, **kwargs)
  7.         return wrapper
  9.     return out_wrapper
  12. @logging(level="INFO")
  13. def hello(hour, name="Bob"):
  14.     print(f"{hour}: Hi,{name}")
  15.     return "ok"
  16. # [INFO]: enter hello()
  17. # 12: Hi,Ben
复制代码
至于为什么带参数装饰器，就不会将第一层解释为函数，可能得了解一下装饰器的实现细节。
类装饰器
不咋用，先摘抄一段吧：
装饰器也不一定只能用函数来写，也可以使用类装饰器，用法与函数装饰器并没有太大区别，实质是使用了类方法中的call魔法方法来实现类的直接调用。
  1. class logging(object):
  2.     def __init__(self, func):
  3.         self.func = func
  5.     def __call__(self, *args, **kwargs):
  6.         print("[DEBUG]: enter {}()".format(self.func.__name__))
  7.         return self.func(*args, **kwargs)
  9. @logging
  10. def hello(a, b, c):
  11.     print(a, b, c)
  13. hello("hello,","good","morning")
  14. -----------------------------
  15. >>>[DEBUG]: enter hello()
  16. >>>hello, good morning
复制代码
类装饰器也是可以带参数的，如下实现
  1. class logging(object):
  2.     def __init__(self, level):
  3.         self.level = level
  5.     def __call__(self, func):
  6.         def wrapper(*args, **kwargs):
  7.             print("[{0}]: enter {1}()".format(self.level, func.__name__))
  8.             return func(*args, **kwargs)
  9.         return wrapper
  11. @logging(level="TEST")
  12. def hello(a, b, c):
  13.     print(a, b, c)
  15. hello("hello,","good","morning")
  16. -----------------------------
  17. >>>[TEST]: enter hello()
  18. >>>hello, good morning
复制代码
参考
python 装饰器详解
Python 函数装饰器

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4