装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能

关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。

优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点：多层装饰比较复杂。

使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

注意事项：可代替继承。

 

 1 - 最简单的装饰器
 2 
 3   ``` python
 4   def deco(func):
 5      ...:     def inner(*args, **kwargs):
 6      ...:         return func(*args, **kwargs)
 7      ...:     return inner
 8   
 9   ```
10 
11 - 带参数的装饰器
12 
13   ``` python
14   def timer(n):
15      ...:     def wrapper(func):
16      ...:         def inner(*args, **kwargs):
17      ...:             import time
18      ...:             start = time.time()
19      ...:             result = func(*args, **kwargs)
20      ...:             end = time.time()
21      ...:             print(f'花费时长: {end - start}')
22      ...:             return result
23      ...:         return inner
24      ...:     return wrapper
25   
26   ```
27 
28 - 类装饰器
29 
30   ``` python
31   class Deco:
32       def __init__(self, func):
33           self.func = func
34           
35       def __call__(self, *args, **kwargs):
36           return func(*args, **kwargs)
37   ```
38 
39 - 带参数的类装饰器
40 
41 - ``` python
42    class Timer:
43       ...:     def __init__(self, n):
44       ...:         self.n = n
45       ...:     def __call__(self, func):
46       ...:         def inner(*args, **kwargs):
47       ...:             start = time.time()
48       ...:             result = func(*args, **kwargs)
49       ...:             end = time.time()
50       ...:             print(f'耗时{end - start}')
51       ...:             return result
52       ...:        return inner
53   
54   ```