一、装饰器的定义

装饰器，顾名思义，就是起到装饰的作用，即在不改变已有函数代码及其调用方式的前提下，对已有函数进行功能扩展，实现了低侵入性、高内聚低耦合的目标。

二、装饰器使用的前置知识

2.1 Python中函数的使用

和其它编程语言不一样，Python中的函数可以一次性返回多个值（tuple），而且函数可以被引用，赋值给其它变量甚至是函数名。

def hello():
    print("hello")

def world():
    print("world")

# 函数名可以重新被赋值，导致函数名和函数内容的置换
hello,world = world, hello
# world
hello()
# hello
world()

在Python中，函数是一等公民，可以像普通变量一样被赋值、被引用、被当作其它函数的入参、被当作其它函数的返回值。

def say_hello(name):
    print(f"Hello, {name}")

def say_hi(name):
    print(f"Hi, {name}")

def greet_job(func, name):
    func(name)

# 函数被当作其它函数的入参
# Hello, Jack
greet_job(say_hello, "Jack")
# Hi, Jack
greet_job(say_hi, "Jack")

2.2 Python中的内部函数

Python允许在一个函数中定义另外一个函数，即实现函数的嵌套，内部函数具有如下的特性：

• 能够访问所有外层函数中的所有资源；
• 该内部函数仅在其直接外层函数中可见；

def parent():
    print("parent函数执行")

    local_var = "zhangsan"

    def first_child():
        print(f"first_child函数执行，可以访问到外层函数的资源：{local_var}")

    def second_child():
        print(f"second_child函数执行，可以访问到外层函数的资源：{local_var}")

    # 内部函数仅在其直接外层函数中可见
    first_child()
    second_child()

parent()

三、装饰器的使用

3.1 简单装饰器的使用

# 定义装饰器，该装饰器什么也不做，把入参中的函数原封不动地返回
def my_decorator(func):
    return func

def say_hello():
    print("Hello")

# 使用装饰器装饰一下原函数
say_hello = my_decorator(say_hello)
say_hello()

如上是最简单的一个例子，装饰器什么也没做，只是把入参的函数原封不动地返回，一般而言，装饰器肯定会有所内容地：

def my_decorator(func):
    print("装饰器函数被调用了")
    # 对原函数进行装饰
    def wrapper():
        print(f"在{func.__name__}之前做点事情...")
        func()
        print(f"在{func.__name__}之后做点事情...")
    # 将装饰后的函数返回给原函数的引用，更新原函数
    return wrapper

def say_hello():
    print("Hello")

say_hello = my_decorator(say_hello)
say_hello()

输出内容如下：

装饰器函数被调用了
在say_hello之前做点事情...
Hello
在say_hello之后做点事情...

3.2 使用装饰器语法糖

通过如上装饰器的简单使用，我们其实知道了其本质，就是把被装饰的原函数当作参数传入装饰器，然后对其装饰一番，再返回赋值给原函数的引用，从而在原函数执行的时候，顺带执行装饰的代码。

然后如上的写法不够简洁，不够优雅，所以Python为我们提供了语法糖写法：

def my_decorator(func):
    print("装饰器函数被调用了")
    # 对原函数进行装饰
    def wrapper():
        print(f"在{func.__name__}之前做点事情...")
        func()
        print(f"在{func.__name__}之后做点事情...")
    # 将装饰后的函数返回给原函数的引用，更新原函数
    return wrapper

@my_decorator
def say_hello():
    print("Hello")

say_hello()

其实就是使用@@my_decorator替换了一句say_hello = my_decorator(say_hello)，但确实看上去简洁优雅多了。

3.3 装饰器的内部函数

我们在上面的例子中，装饰器内部又定义了一个wrapper函数，那么装饰逻辑分布在wrapper的外部和在内部的区别是什么呢？

其实我们最终返回的是对原函数装饰过后的wrapper函数，所以：

• 在wrapper内部的装饰逻辑，只会在原函数调用的时候才会执行；
• 在wrapper外部的装饰逻辑，只要装饰器生效就会执行；

def my_decorator(func):
    # 无论原函数执行与否，只要装饰器使用了，就会被执行
    print("装饰器函数被调用了")
    # 对原函数进行装饰
    # 只有当原函数执行时，内部的装饰逻辑才会执行
    def wrapper():
        print(f"在{func.__name__}之前做点事情...")
        func()
        print(f"在{func.__name__}之后做点事情...")
    # 将装饰后的函数返回给原函数的引用，更新原函数
    return wrapper

3.4 带参数的原函数

为了能在装饰器中给原函数传入参数，我们不得不在定义wrapper内部函数的时候，增加一个入参，如下所示：

def my_decorator(func):
    print("装饰器函数被调用了")
    # 对原函数进行装饰
    def wrapper(name):
        print(f"在{func.__name__}之前做点事情...")
        func(name)
        print(f"在{func.__name__}之后做点事情...")
    # 将装饰后的函数返回给原函数的引用，更新原函数
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello,{name}")

say_hello("Jack")

但是这样有一个缺点，这个装饰器几乎只对这个方法有用，对其它方法，如果参数不匹配的话就没法使用了，所以我们通常结合Python中的变长参数一起使用：

def my_decorator(func):
    print("装饰器函数被调用了")
    # 对原函数进行装饰，*args表示多个顺序参数，**kwargs表示多个字典参数
    def wrapper(*args, **kwargs):
        print(f"在{func.__name__}之前做点事情...")
        func(*args, **kwargs)
        print(f"在{func.__name__}之后做点事情...")
    # 将装饰后的函数返回给原函数的引用，更新原函数
    return wrapper

@my_decorator
def say_hello(name, age=10):
    print(f"Hello,{name}, your age is: {age}")

say_hello("Jack", 12)

这样改造之后，其它任意函数都可以使用我们的装饰器了。

3.5 带参数的装饰器

我们在如上案例中使用装饰器时，装饰器并没有入参，其实Python也是支持的，只不过需要将装饰器再封装一层：

def my_repeat(times):
    def my_decorator(func):
        def wrapper(*args, **kwargs):
            print(f"在{func.__name__}之前做点事情...")
            # 闭包函数，使用了其外层函数的资源times
            for n in range(times):
                func(*args, **kwargs)
            print(f"在{func.__name__}之后做点事情...")
        # 将装饰后的函数返回给原函数的引用，更新原函数
        return wrapper
    return my_decorator

@my_repeat(3)
def say_hello(name, age=10):
    print(f"Hello,{name}, your age is: {age}")

# 原函数调用时，其装饰函数外层的函数上下文和资源仍然存在
say_hello("Jack", 12)

输出结果为：

在say_hello之前做点事情...
Hello,Jack, your age is: 12
Hello,Jack, your age is: 12
Hello,Jack, your age is: 12
在say_hello之后做点事情...

其实@@my_repeat(3)就等价于：

my_decorator = my_repeat(3)
say_hello = my_decorator(say_hello)

3.6 装饰器装饰类

在上面的使用中，我们都是用来装饰函数，那么装饰类是什么意思，如何使用呢？

相较于函数装饰器，类装饰器具有灵活度大、高内聚、封装性的优点，此时主要依靠类的__call__方法来实现对原函数的装饰逻辑。

class Foo(object):
    def __init__(self, func):
        self._func = func

    def __call__(self):
        print(f"在{self._func.__name__}之前做点事情")
        self._func()
        print(f"在{self._func.__name__}之后做点事情")

@Foo
def bar():
    print("原函数执行的逻辑....")

bar()

此时的@Foo就等价于bar = Foo(bar)；

3.7 装饰器的执行顺序

当有多个装饰器装饰同一个函数的时候，各个装饰器的执行顺序会是怎么样的呢？

def my_decorator1(func):
    def wrapper(*args, **kwargs):
        print(f"my_decorator1在{func.__name__}之前做点事情...")
        func(*args, **kwargs)
        print(f"my_decorator1在{func.__name__}之后做点事情...")
    return wrapper

def my_decorator2(func):
    def wrapper(*args, **kwargs):
        print(f"my_decorator2在{func.__name__}之前做点事情...")
        func(*args, **kwargs)
        print(f"my_decorator2在{func.__name__}之后做点事情...")
    return wrapper

def my_decorator3(func):
    def wrapper(*args, **kwargs):
        print(f"my_decorator3在{func.__name__}之前做点事情...")
        func(*args, **kwargs)
        print(f"my_decorator3在{func.__name__}之后做点事情...")
    return wrapper

@my_decorator1
@my_decorator2
@my_decorator3
def say_hello(name, age=10):
    print(f"Hello,{name}, your age is: {age}")

say_hello("Jack", 12)

输出结果如下：

my_decorator1在wrapper之前做点事情...
my_decorator2在wrapper之前做点事情...
my_decorator3在say_hello之前做点事情...
Hello,Jack, your age is: 12
my_decorator3在say_hello之后做点事情...
my_decorator2在wrapper之后做点事情...
my_decorator1在wrapper之后做点事情...

四、装饰器的应用

Python自带了三个原生的装饰器，下面逐一进行介绍。

4.1 @property

当我们需要访问对象中的属性的时候，对于公开的属性，可以直接访问，对于私有的属性，可以通过get和set方法来访问，如下所示：

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self._age = age
        
    # _age是私有属性，必须通过方法来访问
    def get_age(self):
        return self._age
    
    # _age是私有属性，必须通过方法来修改
    def set_age(self, age):
        self._age = age

    def __call__(self):
        # 对象内部可以不受限制地访问自身的属性
        print('姓名:{},年龄:{}'.format(self.name,self._age))

jack = Person("jack", 20)
print(f"jack的姓名为：{jack.name},年龄为：{jack.get_age()}")
jack.set_age(35)
print(f"jack的姓名为：{jack.name},年龄为：{jack.get_age()}")
jack()

输出内容为：

jack的姓名为：jack,年龄为：20
jack的姓名为：jack,年龄为：35
姓名:jack,年龄:35

但是每次需要访问对象的私有属性，都要通过set和get有点麻烦，所以Python提供了@property来将这些方法变成可以直接读写的属性：

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self._age = age

    @property
    def age(self):
        return self._age
    
    def set_age(self, age):
        self._age = age

    def __call__(self):
        print('姓名:{},年龄:{}'.format(self.name,self._age))

jack = Person("jack", 20)
# 可以以读取属性的方式来调用对象的方法
print(f"jack的姓名为：{jack.name},年龄为：{jack.age}")
jack.set_age(35)
print(f"jack的姓名为：{jack.name},年龄为：{jack.age}")
jack()

如此，我们既可以维持原来保护私有属性的原则，又可以像读取公开属性一样获取其值。

4.2 @classmethod

一般情况下，如果我们想调用某个类的方法的话，首先需要实例化一个对象，然后使用对象来调用这个方法：

class Animal(object):
    name = "tom"
    def eat(self):
        print(f"{self.name}正在吃东西")
    def sleep(self):
        print(f"{self.name}正在睡觉")
    def make_noise(cls):
         print("miao~miao~")

cat = Animal()
cat.eat()
cat.sleep()
cat.make_noise()

但是使用@classmethod就能让我们可以直接通过类名来调用方法，不需要实例化类的对象了：

class Animal(object):
    name = "tom"
    @classmethod
    def eat(cls):
        print(f"{cls.name}正在吃东西")
    @classmethod
    def sleep(cls):
        print(f"{cls.name}正在睡觉")
    @classmethod
    def make_noise(cls):
        print("miao~miao~")

# 完全不需要实例化对象，直接可以调用方法
Animal.eat()
Animal.sleep()
Animal.make_noise()

4.3 @staticmethod

@staticmethod的用法和@classmethod的用法基本类似，区别是被装饰的原函数中不需要cls入参。

class Animal(object):
    name = "tom"
    @staticmethod
    def eat():
        print(f"{Animal.name}正在吃东西")
    @classmethod
    def sleep(cls):
        print(f"{cls.name}正在睡觉")
    @classmethod
    def make_noise(cls):
        print("miao~miao~")

Animal.eat()
Animal.sleep()
Animal.make_noise()