60、Python之函数高级：从函数对象的理解，学习类装饰器的使用

引言

本文打算接着继续介绍Python中装饰器的内容，不过不同于前面的文章，今天打算聊聊，另一种装饰器的实现——类装饰器。从表面上看，不再是高阶函数或者闭包，但是，本质上其实都是相似的。

本文的主要内容有：

1、Python函数对象的回顾

2、自定义可调用对象

3、类装饰器的使用

Python函数对象的回顾

关于设计理念的东西，笔者还是打算继续反复唠叨，毕竟对这些理念真正理解了，再学习或者Python就会更加得心应手。这些被反复唠叨的理念有：

1、Python中一切皆对象。

2、由于1成立，所以函数是对象、模块是对象、包也是对象。

3、Python中的变量可以理解为“标签”而非“盒子”。

4、基于3，Python中的名称绑定，是变量名字与对象之间形成的绑定关系。这个绑定关系可以发生修改，可以多个变量名绑定到一个对象上。通过变量进行修改操作，一定要能够清晰地理解是修改对象内容，还是修改了绑定关系。

关于函数对象的本质，前面的文章中也已经进行过深入的分析，感兴趣的同学，可以回看一下这篇文章：

《Python之函数高级：函数深度剖析，一次性搞懂函数对象》

这里，简单再会看一下函数对象的一个方法：__call__()方法。

前面的文章中曾经提到，我们调用函数可以有两种方法：

1、通过函数名()的形式进行调用。

2、通过函数名.__call__()的形式进行函数调用。

这两种方法的效果是相同的。简单看下代码的演示：

def add(a, b):
    print('开始执行加法：')
    return a + b


if __name__ == '__main__':
    print(add(10, 20))
    print(add.__call__(10, 20))

执行结果：

可以看到两者执行的效果是相同的。

但是，两者执行的效果是否总是相同呢？我们不妨稍作验证。

直接看代码：

def add(a, b):
    print('开始执行加法：')
    return a + b


if __name__ == '__main__':
    # 函数既然是对象，自然可以进行属性的修改
    add.__call__ = lambda x, y: x + y
    # 通过函数名的调用
    print(add(10, 20))
    print("=" * 20)
    # 通过__call__的调用
    print(add.__call__(10, 20))

执行结果：

显然，如果我们自己重写了函数对象的__call__()方法，并不会影响函数名()方式的函数调用，但是，两者的区别已经可以看出来了。

我们再调整一下__call__()方法：

def add(a, b):
    print('开始执行加法：')
    return a + b


def call(self, x, y):
    print("执行加法前的准备工作")
    return self.__class__.__call__(self, x, y)


if __name__ == '__main__':
    # 函数既然是对象，自然可以进行属性的修改
    # add.__call__ = lambda x, y: x + y
    add.__call__ = call
    # 通过函数名的调用
    print(add(10, 20))
    print('=' * 20)
    # 通过__call__的调用
    print(add.__call__(add, 10, 20))

执行结果：

通过程序的验证，我们可以得出如下推测：

1、Python中，通过函数名()进行函数的调用，会执行函数体中的代码，这些代码其实会编译为字节码，存储在函数的__code__属性中。

2、通过函数名.__call__()方法调用函数，默认会执行函数类中定义的__call__()的方法，也就是执行函数体中的代码。如果我们自己重写了函数对象的__call__()方法，则会覆盖这个效果，具体可以看上面两个代码的效果。

函数本身就是可以调用的，那么__call__()方法是不是有些多此一举了呢，似乎还增加了学习成本。

但是，如果我们回到函数是对象的理念基础上来看，函数对象是Python中一种比较特殊的对象，可以称之为“可调用对象”，除了函数对象外，还有方法对象，也是可调用对象。

所以，如果从“可调用对象”的角度来看这个问题的话，聪明的你也许已经想到了，我们能否自行定义可调用对象，从而让普通对象也能像函数一样，实现对象名()的操作，这种看起来有点酷的效果呢。这就离不开__call__()方法的功劳了。

自定义可调用对象

首先说结论吧：

1、如果一个类中实现了__call__()方法，则对该类的实例对象进行：对象名()的操作时，Python解释器会自行查找__call()方法，并执行。

2、结合函数对象，以及普通对象，我们可以得到一个更加完备的结论：当Python解释器遇到：对象名()的表达式时，首先会判断该对象是否是函数对象（或者方法对象），如果是，则会直接执行其函数体中的代码（__code__中）；如果不是，则会查找对象中是否具有__call__()方法，有则执行；否则，抛出异常。

接下来，我们通过代码来进行验证：

class A:
    def __call__(self, *args, **kwargs):
        print('__call__被执行')
        print(args)
        print(kwargs)


class B:
    pass


if __name__ == '__main__':
    a = A()
    b = B()
    print(a)
    print(b)
    print('=' * 20)
    a(10, 20, '张三', age=18)
    b()

执行结果：

可以看出，与我们前面给出的结论是一致的。

让一个对象变成可调用对象，看着是挺酷的，但是，有什么用呢？

很有用，其中一个用途就是类装饰器的使用。

类装饰器的使用

我们再来简单分析一下装饰器的使用，以及@装饰器名的逻辑。

1、所谓装饰器，是以一个函数对象为参数，对其进行增强，返回一个新的函数对象的二阶函数。

2、@装饰器名的本质是：原函数名 = 装饰器(原函数对象)，这条更新名称绑定关系的操作。

@装饰器的用法，并没有明确要求装饰器必须是函数对象，而且我们已经有了实现可调用对象的方法。

所以，类装饰器的使用也就变得顺理成章了。

我们来简单定义一个类装饰：

import time


class UserLevel:
    def __init__(self, level):
        self.level = level
        self.latency = {'free': 5, 'vip': 2, 'svip': 0}
        self.message = {
            'free': '免费用户正在排队...',
            'vip': 'vip用户正在使用高速通道...',
            'svip': 'svip用户正在使用专属通道...',
        }

    def __call__(self, func):
        def wrap(*args, **kwargs):
            print(self.message[self.level])
            time.sleep(self.latency[self.level])
            return func(*args, **kwargs)

        return wrap


@UserLevel('vip')
def feature():
    print("这是正常执行功能的模块")


if __name__ == '__main__':
    feature()

使用类装饰的地方还可以修改为提前定义对象，然后直接用对象进行装饰：

free = UserLevel('free')
vip = UserLevel('vip')
svip = UserLevel('svip')


@svip
def feature():
    print("这是正常执行功能的模块")

我们通过类装饰器，实现了前面的需要三阶函数才能实现的带参数的装饰器，而且使得代码变得更加易读。参数所表示的属性或者状态，不再以闭包的形式进行存储，而是直接存储在对象的属性中。

当然，关于使用高阶函数（闭包）的装饰器，还是使用类装饰器，其实没有好坏之分。只要理解了其中的实现原理，剩下的就是看具体的需求场景了。

总结

本文首先回顾了Python中一切皆对象及其衍生出来的基本的设计理念，然后对Python中的函数对象进行了回顾，继而泛化除了Python中可调用对象的实现方式。最后，基于可调用对象的机制，实现了类装饰器。

感谢您的拨冗阅读，希望对您学习Python有所帮助。