引言
本文打算接着继续介绍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有所帮助。