python测试开发面试常考题：装饰器

黄太孙耐克裁判坐牢冠

简介

Python 装饰器是一个可调用的(函数、方法或类)，它获得一个函数对象 func_in 作为输入，并返回另一函数对象 func_out。它用于扩展函数、方法或类的行为。
装饰器模式通常用于扩展对象的功能。在日常生活中，这种扩展的例子有：在枪上加一个消音器，使用不同的相机镜头等等。

Django框架中有大量装饰器

• 限制某些HTTP请求对视图的访问
  
• 控制
  
• 按单个视图控制压缩
  
• 基于特定HTTP请求头控制缓存
  

Pyramid框架和Zope应用服务器也使用装饰器来实现各种目标。

• 将函数注册为事件订阅者
  
• 以特定权限保护一个方法
  
• 实现适配器模式
  

应用

装饰器模式在跨领域方面大放异彩：

• 数据验证
  
• 缓存
  
• 日志
  
• 监控
  
• 调试
  
• 业务规则
  
• 加密
  

使用修饰器模式的另一个常见例子是(Graphical User　Interface,GUI)工具集。在GUI工具集中,我们希望能够将一些特性,比如边框、阴影、颜色以及滚屏,添加到组件/控件。
第一类对象

装饰器是Python中非常强大和有用的工具，它允许程序员修改函数或类的行为。装饰器允许我们封装另一个函数，以扩展被封装函数的行为，而不需要修改它。但在深入研究装饰器之前，让我们先了解一些概念，这些概念在学习装饰器时将会很有用。
在Python中，函数是第一类对象，这意味着 Python 中的函数可以作为参数使用或传递。
第一类函数的属性：

• 函数是对象类型的实例
  
• 可以将函数存储在变量
  
• 可以将函数作为参数传递给其他函数
  
• 可以从函数中返回函数。
  
• 可以将它们存储在数据结构中，如哈希表、列表、...
  

例1：将函数视为对象。

1. def shout(text):
2.     return text.upper()
4. print(shout('Hello'))
6. yell = shout
8. print(yell('Hello'))

复制代码

输出：

1. HELLO
2. HELLO

复制代码

例2：将函数作为参数传递

1. def shout(text):
2.     return text.upper()
4. def whisper(text):
5.     return text.lower()
7. def greet(func):
8.     # storing the function in a variable
9.     greeting = func("""Hi, I am created by a function passed as an argument.""")
10.     print (greeting)
12. greet(shout)
13. greet(whisper)

复制代码

输出：

1. HI, I AM CREATED BY A FUNCTION PASSED AS AN ARGUMENT.
2. hi, i am created by a function passed as an argument.

复制代码

例3： 从函数中返回函数。

1. def shout(text):
2.     return text.upper()
4. def whisper(text):
5.     return text.lower()
7. def greet(func):
8.     # storing the function in a variable
9.     greeting = func("""Hi, I am created by a function passed as an argument.""")
10.     print (greeting)
12. greet(shout)
13. greet(whisper)

复制代码

输出：

1. 25

复制代码

参考资料

• 本文涉及的python中文资源 请在github上点赞，谢谢！
  
• 本文相关书籍下载
  

• https://www.geeksforgeeks.org/decorators-in-python/
  
• https://realpython.com/primer-on-python-decorators/
  

装饰器

如上所述，装饰器是用来修改函数或类的行为的。在装饰器中，函数被当作函数的参数，然后在封装函数中调用。

• 装饰器的语法：
  

1. @gfg_decorator
2. def hello_decorator():
3.     print("Gfg")
5. '''Above code is equivalent to -
7. def hello_decorator():
8.     print("Gfg")
9.    
10. hello_decorator = gfg_decorator(hello_decorator)'''

复制代码

gfg_decorator 是一个可调用的函数，它将在另一个可调用的函数hello_decorator函数上面添加一些代码，并返回封装函数。

• 装饰器可以修改行为：
  

1. # defining a decorator
2. def hello_decorator(func):
4.     # inner1 is a Wrapper function in
5.     # which the argument is called
6.      
7.     # inner function can access the outer local
8.     # functions like in this case "func"
9.     def inner1():
10.         print("Hello, this is before function execution")
12.         # calling the actual function now
13.         # inside the wrapper function.
14.         func()
16.         print("This is after function execution")
17.          
18.     return inner1
21. # defining a function, to be called inside wrapper
22. def function_to_be_used():
23.     print("This is inside the function !!")
26. # passing 'function_to_be_used' inside the
27. # decorator to control its behaviour
28. function_to_be_used = hello_decorator(function_to_be_used)
31. # calling the function
32. function_to_be_used()

复制代码

输出：

1. Hello, this is before function execution
2. This is inside the function !!
3. This is after function execution

复制代码

让我们跳到另一个例子，在这个例子中，我们可以用装饰器轻松地找出函数的执行时间。

1. import time
2. import math
3. import functools
5. # decorator to calculate duration
6. # taken by any function.
7. def calculate_time(func):
8.      
9.     # added arguments inside the inner1,
10.     # if function takes any arguments,
11.     # can be added like this.
12.     @functools.wraps(func) # 支持内省，一般可以不用，多用于文档
13.     def inner1(*args, **kwargs):
15.         # storing time before function execution
16.         begin = time.time()
17.          
18.         func(*args, **kwargs)
20.         # storing time after function execution
21.         end = time.time()
22.         print("Total time taken in : ", func.__name__, end - begin)
24.     return inner1
28. # this can be added to any function present,
29. # in this case to calculate a factorial
30. @calculate_time
31. def factorial(num):
33.     # sleep 2 seconds because it takes very less time
34.     # so that you can see the actual difference
35.     time.sleep(2)
36.     print(math.factorial(num))
38. # calling the function.
39. factorial(10)

复制代码

@functools.wraps装饰器使用函数functools.update_wrapper()来更新特殊属性，如__name__和__doc__，这些属性在自省中使用。
输出：

1. 3628800
2. Total time taken in :  factorial 2.0061802864074707

复制代码

• 如果函数有返回或有参数传递给函数，怎么办？
  

在上面所有的例子中，函数都没有返回任何东西，所以没有问题，但人们可能需要返回的值。

1. def hello_decorator(func):
2.     def inner1(*args, **kwargs):
3.          
4.         print("before Execution")
5.          
6.         # getting the returned value
7.         returned_value = func(*args, **kwargs)
8.         print("after Execution")
9.          
10.         # returning the value to the original frame
11.         return returned_value
12.          
13.     return inner1
16. # adding decorator to the function
17. @hello_decorator
18. def sum_two_numbers(a, b):
19.     print("Inside the function")
20.     return a + b
22. a, b = 1, 2
24. # getting the value through return of the function
25. print("Sum =", sum_two_numbers(a, b))

复制代码

输出：

1. before Execution
2. Inside the function
3. after Execution
4. Sum = 3

复制代码

内部函数接收的参数是*args和**kwargs，这意味着可以传递任何长度的位置参数的元组或关键字参数的字典。这使得它成为通用的装饰器，可以装饰具有任何数量参数的函数。

• 链式装饰器
  

链式装饰器是指用多个装饰器来装饰函数。

1. # code for testing decorator chaining
2. def decor1(func):
3.     def inner():
4.         x = func()
5.         return x * x
6.     return inner
8. def decor(func):
9.     def inner():
10.         x = func()
11.         return 2 * x
12.     return inner
14. @decor1
15. @decor
16. def num():
17.     return 10
19. @decor
20. @decor1
21. def num2():
22.     return 10
23.    
24. print(num())
25. print(num2())

复制代码

输出

1. 400
2. 200

复制代码

上面的例子类似于调用函数---

1. decor1(decor(num))
2. decor(decor1(num2))

复制代码

一些常用的装饰器在 Python 中甚至是内建的，它们是 @classmethod, @staticmethod, 和 @property。@classmethod 和 @staticmethod 装饰器用于定义类命名空间中的方法，这些方法与该类的特定实例没有关系。@property装饰器是用来定制类属性的getters和setters的。

• 类装饰器
  

在 Python 3.7 中的新的 dataclasses 模块中完成：

1. from decorators import debug, do_twice
3. @debug
4. @do_twice
5. def greet(name):
6.     print(f"Hello {name}")

复制代码

语法的含义与函数装饰器相似。你可以通过写PlayingCard = dataclass(PlayingCard)来进行装饰。
类装饰器的一个常见用途是作为元类的一些使用情况的更简单的替代。
编写一个类装饰器与编写一个函数装饰器非常相似。唯一的区别是，装饰器将接收类而不是函数作为参数。事实上，你在上面看到的所有装饰器都可以作为类装饰器工作。

• 带参数与不带参数的装饰器
  

1. def repeat(_func=None, *, num_times=2):
2.     def decorator_repeat(func):
3.         @functools.wraps(func)
4.         def wrapper_repeat(*args, **kwargs):
5.             for _ in range(num_times):
6.                 value = func(*args, **kwargs)
7.             return value
8.         return wrapper_repeat
10.     if _func is None:
11.         return decorator_repeat
12.     else:
13.         return decorator_repeat(_func)

复制代码

使用functools.partial也可达到类似效果。
以下是slowdown的演进版本

1. import functools
2. import time
4. def slow_down(_func=None, *, rate=1):
5.     """Sleep given amount of seconds before calling the function"""
6.     def decorator_slow_down(func):
7.         @functools.wraps(func)
8.         def wrapper_slow_down(*args, **kwargs):
9.             time.sleep(rate)
10.             return func(*args, **kwargs)
11.         return wrapper_slow_down
13.     if _func is None:
14.         return decorator_slow_down
15.     else:
16.         return decorator_slow_down(_func)

复制代码

• 有状态的装饰器
  

1. import functools
3. def count_calls(func):
4.     @functools.wraps(func)
5.     def wrapper_count_calls(*args, **kwargs):
6.         wrapper_count_calls.num_calls += 1
7.         print(f"Call {wrapper_count_calls.num_calls} of {func.__name__!r}")
8.         return func(*args, **kwargs)
9.     wrapper_count_calls.num_calls = 0
10.     return wrapper_count_calls
12. @count_calls
13. def say_whee():
14.     print("Whee!")

复制代码

对函数的调用次数--存储在包装函数的函数属性 .num_calls 中。下面是使用它的效果：

1. >>> say_whee()
2. Call 1 of 'say_whee'
3. Whee!
5. >>> say_whee()
6. Call 2 of 'say_whee'
7. Whee!
9. >>> say_whee.num_calls
10. 2

复制代码

维护状态的典型方法是使用类装饰器。

1. import functools
3. class CountCalls:
4.     def __init__(self, func):
5.         functools.update_wrapper(self, func)
6.         self.func = func
7.         self.num_calls = 0
9.     def __call__(self, *args, **kwargs):
10.         self.num_calls += 1
11.         print(f"Call {self.num_calls} of {self.func.__name__!r}")
12.         return self.func(*args, **kwargs)
14. @CountCalls
15. def say_whee():
16.     print("Whee!")

复制代码

• 单例模式
  

单例是只有一个实例的类。比如 None、True 和 False，可以使用 is 关键字来比较 None。

1. import functools
3. def singleton(cls):
4.     """Make a class a Singleton class (only one instance)"""
5.     @functools.wraps(cls)
6.     def wrapper_singleton(*args, **kwargs):
7.         if not wrapper_singleton.instance:
8.             wrapper_singleton.instance = cls(*args, **kwargs)
9.         return wrapper_singleton.instance
10.     wrapper_singleton.instance = None
11.     return wrapper_singleton
13. @singleton
14. class TheOne:
15.     pass

复制代码

如你所见，这个类装饰器与我们的函数装饰器遵循相同的模板。唯一的区别是，我们使用 cls 而不是 func 作为参数名，以表明它是类装饰器。
让我们看看它是否有效：

1. >>> first_one = TheOne()
2. >>> another_one = TheOne()
4. >>> id(first_one)
5. 140094218762280
7. >>> id(another_one)
8. 140094218762280
10. >>> first_one is another_one
11. True

复制代码

注意：在Python中，单例其实并不像其他语言那样经常使用，通常用全局变量来实现更好。

• 缓存返回值
  

装饰器可以为缓存和备忘提供一个很好的机制。作为一个例子，让我们看一下斐波那契数列的递归定义：

1. import functools
2. from decorators import count_calls
4. def cache(func):
5.     """Keep a cache of previous function calls"""
6.     @functools.wraps(func)
7.     def wrapper_cache(*args, **kwargs):
8.         cache_key = args + tuple(kwargs.items())
9.         if cache_key not in wrapper_cache.cache:
10.             wrapper_cache.cache[cache_key] = func(*args, **kwargs)
11.         return wrapper_cache.cache[cache_key]
12.     wrapper_cache.cache = dict()
13.     return wrapper_cache
15. @cache
16. @count_calls
17. def fibonacci(num):
18.     if num < 2:
19.         return num
20.     return fibonacci(num - 1) + fibonacci(num - 2)

复制代码

在标准库中，最近使用最少的缓存（LRU）可作为 @functools.lru_cache。
这个装饰器比你上面看到的那个有更多的功能。你应该使用@functools.lru_cache而不是写你自己的缓存装饰器：

1. import functools
3. @functools.lru_cache(maxsize=4)
4. def fibonacci(num):
5.     print(f"Calculating fibonacci({num})")
6.     if num < 2:
7.         return num
8.     return fibonacci(num - 1) + fibonacci(num - 2)

复制代码

maxsize参数指定了多少个最近的调用被缓存。默认值是128，但你可以指定maxsize=None来缓存所有函数调用。然而，要注意的是，如果你要缓存许多大的对象，这可能会导致内存问题。
描述器descriptor

任何定义了 __get__(), __set__() 或 __delete__() 方法的对象。当类属性为描述器时，它的特殊绑定行为就会在属性查找时被触发。通常情况下，使用 a.b 来获取、设置或删除属性时会在 a 的类字典中查找名称为 b 的对象，但如果 b 是描述器，则会调用对应的描述器方法。理解描述器的概念是更深层次理解 Python 的关键，因为这是许多重要特性的基础，包括函数、方法、属性、类方法、静态方法以及对超类的引用等等。
有关描述符的方法的详情可参看 实现描述器。
class property(fget=None, fset=None, fdel=None, doc=None)
fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。

1. class C():
2.     def __init__(self):
3.         self._x = None
5.     def getx(self):
6.         return self._x
8.     def setx(self, value):
9.         self._x = value
11.     def delx(self):
12.         del self._x
14.     x = property(getx, setx, delx, "I'm the 'x' property.")
15.    
16. demo = C()
17. demo.x = 5
18. print(demo.x)
19. print(demo.getx())

复制代码

执行结果

1. 5
2. 5

复制代码

更快捷的方式：

1. class C():
2.     def __init__(self):
3.         self._x = None
5.     @property
6.     def x(self):
7.         """I'm the 'x' property."""
8.         return self._x
10.     @x.setter
11.     def x(self, value):
12.         self._x = value
14.     @x.deleter
15.     def x(self):
16.         del self._x
17.    
18. demo = C()
19. demo.x = 5
20. print(demo.x)

复制代码

@property 装饰器会将 x() 方法转化为同名的只读属性的 "getter"，并将 x的文档字符串设置为 "I'm the 'x' property."
执行结果

1. 5

复制代码

来源:https://www.cnblogs.com/testing-/p/17503984.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！