十四、特殊类
14.1 描述符
Python 中,通过使用描述符,可以让程序员在引用一个对象属性时自定义要完成的工作。
实质就是通过编程人员自己书写代码,定义一个描述符类,来完成对象的属性调用过程。
本质上看,描述符就是一个类,只不过它定义了另一个类中属性的访问方式。换句话说,一个类可以将属性管理全权委托给描述符类。
描述符是 Python 中复杂属性访问的基础,它在内部被用于实现 property、方法、类方法、静态方法和 super 类型。
描述符类基于以下 3 个特殊方法,换句话说,这 3 个方法组成了描述符协议:
set(self, obj, type=None):在设置属性时将调用这一方法(本节后续用 setter 表示);
get(self, obj, value):在读取属性时将调用这一方法(本节后续用 getter 表示);
delete(self, obj):对属性调用 del 时将调用这一方法。
其中,实现了 setter 和 getter 方法的描述符类被称为数据描述符;反之,如果只实现了 getter 方法,则称为非数据描述符。
实际上,在每次查找属性时,描述符协议中的方法都由类对象的特殊方法 getattribute() 调用(注意不要和 getattr() 弄混)。也就是说,每次使用类对象.属性(或者 getattr(类对象,属性值))的调用方式时,都会隐式地调用 getattribute(),它会按照下列顺序查找该属性:
验证该属性是否为类实例对象的数据描述符;
如果不是,就查看该属性是否能在类实例对象的 dict 中找到;
最后,查看该属性是否为类实例对象的非数据描述符。
为了表达清楚,这里举个例子:
#描述符类
class revealAccess:
def __init__(self, initval = None, name = 'var'):
self.val = initval
self.name = name
def __get__(self, obj, objtype):
print("Retrieving",self.name)
return self.val
def __set__(self, obj, val):
print("updating",self.name)
self.val = val
class myClass:
x = revealAccess(10,'var "x"') #参数实际就是(initcal=10,name='var "x"')
y = 5
m = myClass()
print(m.x) #调用了revealAccess的__get__()方法
m.x = 20 #调用了revealAccess的__set__()方法
print(m.x) #调用了revealAccess的__get__()方法
print(m.y)
运行结果为:
Retrieving var "x"
10
updating var "x"
Retrieving var "x"
20
5
从这个例子可以看到,如果一个类的某个属性有数据描述符,那么每次查找这个属性时,都会调用描述符的 get() 方法,并返回它的值;同样,每次在对该属性赋值时,也会调用 set() 方法。
注意,虽然上面例子中没有使用 del() 方法,但也很容易理解,当每次使用 del 类对象.属性(或者 delattr(类对象,属性))语句时,都会调用该方法。
除了使用描述符类自定义类属性被调用时做的操作外,还可以使用 property() 函数或者 @property 装饰器,它们会在后续章节做详细介绍。
14.2 MetaClass元类
MetaClass元类,本质也是一个类,但和普通类的用法不同,它可以对类内部的定义(包括类属性和类方法)进行动态的修改。可以这么说,使用元类的主要目的就是为了实现在创建类时,能够动态地改变类中定义的属性或者方法。
不要从字面上去理解元类的含义,事实上 MetaClass 中的 Meta 这个词根,起源于希腊语词汇 meta,包含“超越”和“改变”的意思。
举个例子,根据实际场景的需要,我们要为多个类添加一个 name 属性和一个 say() 方法。显然有多种方法可以实现,但其中一种方法就是使用 MetaClass 元类。
如果在创建类时,想用 MetaClass 元类动态地修改内部的属性或者方法,则类的创建过程将变得复杂:先创建 MetaClass 元类,然后用元类去创建类,最后使用该类的实例化对象实现功能。
和前面章节创建的类不同,如果想把一个类设计成 MetaClass 元类,其必须符合以下条件:
必须显式继承自 type 类;
类中需要定义并实现 new() 方法,该方法一定要返回该类的一个实例对象,因为在使用元类创建类时,该 new() 方法会自动被执行,用来修改新建的类。
讲了这么多,读者可能对 MetaClass 元类的功能还是比较懵懂。没关系,我们先尝试定义一个 MetaClass 元类:
#定义一个元类
class FirstMetaClass(type):
# cls代表动态修改的类
# name代表动态修改的类名
# bases代表被动态修改的类的所有父类
# attr代表被动态修改的类的所有属性、方法组成的字典
def __new__(cls, name, bases, attrs):
# 动态为该类添加一个name属性
attrs['name'] = "python学习"
attrs['say'] = lambda self: print("调用 say() 实例方法")
return super().__new__(cls,name,bases,attrs)
此程序中,首先可以断定 FirstMetaClass 是一个类。其次,由于该类继承自 type 类,并且内部实现了 new() 方法,因此可以断定 FirstMetaCLass 是一个元类。
有关 new() 的具体用法,后续我们会在类的特殊方法中介绍。
lambda 函数我们会在函数章节重点介绍。
可以看到,在这个元类的 new() 方法中,手动添加了一个 name 属性和 say() 方法。这意味着,通过 FirstMetaClass 元类创建的类,会额外添加 name 属性和 say() 方法。通过如下代码,可以验证这个结论:
#定义类时,指定元类
class CLanguage(object,metaclass=FirstMetaClass):
pass
clangs = CLanguage()
print(clangs.name)
clangs.say()
可以看到,在创建类时,通过在标注父类的同时指定元类(格式为metaclass=元类名),则当 Python 解释器在创建这该类时,FirstMetaClass 元类中的 new 方法就会被调用,从而实现动态修改类属性或者类方法的目的。
运行上面的程序,输出结果为:
python学习
调用 say() 实例方法
显然,FirstMetaClass 元类的 new() 方法动态地为 Clanguage 类添加了 name 属性和 say() 方法,因此,即便该类在定义时是空类,它也依然有 name 属性和 say() 方法。
对于 MetaClass 元类,它多用于创建 API,因此我们几乎不会使用到它。
14.3 枚举类
一些具有特殊含义的类,其实例化对象的个数往往是固定的,比如用一个类表示月份,则该类的实例对象最多有 12 个;再比如用一个类表示季节,则该类的实例化对象最多有 4 个。
针对这种特殊的类,Python 3.4 中新增加了 Enum 枚举类。也就是说,对于这些实例化对象个数固定的类,可以用枚举类来定义。
例如,下面程序演示了如何定义一个枚举类:
from enum import Enum
class Color(Enum):
# 为序列值指定value值
red = 1
green = 2
blue = 3
如果想将一个类定义为枚举类,只需要令其继承自 enum 模块中的 Enum 类即可。例如在上面程序中,Color 类继承自 Enum 类,则证明这是一个枚举类。
在 Color 枚举类中,red、green、blue 都是该类的成员(可以理解为是类变量)。注意,枚举类的每个成员都由 2 部分组成,分别为 name 和 value,其中 name 属性值为该枚举值的变量名(如 red),value 代表该枚举值的序号(序号通常从 1 开始)。
和普通类的用法不同,枚举类不能用来实例化对象,但这并不妨碍我们访问枚举类中的成员。访问枚举类成员的方式有多种,例如以 Color 枚举类为例,在其基础上添加如下代码:
#调用枚举成员的 3 种方式
print(Color.red)
print(Color[‘red’])
print(Color(1))
#调取枚举成员中的 value 和 name
print(Color.red.value)
print(Color.red.name)
#遍历枚举类中所有成员的 2 种方式
for color in Color:
print(color)
程序输出结果为:
Color.red
Color.red
Color.red
1
red
Color.red
Color.green
Color.blue
枚举类成员之间不能比较大小,但可以用 == 或者 is 进行比较是否相等,例如:
print(Color.red == Color.green)
print(Color.red.name is Color.green.name)
输出结果为:
Flase
Flase
需要注意的是,枚举类中各个成员的值,不能在类的外部做任何修改,也就是说,下面语法的做法是错误的:
Color.red = 4
除此之外,该枚举类还提供了一个 members 属性,该属性是一个包含枚举类中所有成员的字典,通过遍历该属性,也可以访问枚举类中的各个成员。例如:
for name,member in Color.members.items():
print(name,“->”,member)
输出结果为:
red -> Color.red
green -> Color.green
blue -> Color.blue
值得一提的是,Python 枚举类中各个成员必须保证 name 互不相同,但 value 可以相同,举个例子:
from enum import Enum
class Color(Enum):
# 为序列值指定value值
red = 1
green = 1
blue = 3
print(Color[‘green’])
输出结果为:
Color.red
可以看到,Color 枚举类中 red 和 green 具有相同的值(都是 1),Python 允许这种情况的发生,它会将 green 当做是 red 的别名,因此当访问 green 成员时,最终输出的是 red。
在实际编程过程中,如果想避免发生这种情况,可以借助 @unique 装饰器,这样当枚举类中出现相同值的成员时,程序会报 ValueError 错误。例如:
#引入 unique
from enum import Enum,unique
#添加 unique 装饰器
@unique
class Color(Enum):
# 为序列值指定value值
red = 1
green = 1
blue = 3
print(Color[‘green’])
运行程序会报错:
Traceback (most recent call last):
File “D:\python3.6\demo.py”, line 3, in
class Color(Enum):
File “D:\python3.6\lib\enum.py”, line 834, in unique
(enumeration, alias_details))
ValueError: duplicate values found in <enum ‘Color’>: green -> red
除了通过继承 Enum 类的方法创建枚举类,还可以使用 Enum() 函数创建枚举类。例如:
from enum import Enum
#创建一个枚举类
Color = Enum(“Color”,(‘red’,‘green’,‘blue’))
#调用枚举成员的 3 种方式
print(Color.red)
print(Color[‘red’])
print(Color(1))
#调取枚举成员中的 value 和 name
print(Color.red.value)
print(Color.red.name)
#遍历枚举类中所有成员的 2 种方式
for color in Color:
print(color)
Enum() 函数可接受 2 个参数,第一个用于指定枚举类的类名,第二个参数用于指定枚举类中的多个成员。
如上所示,仅通过一行代码,即创建了一个和前面的 Color 类相同的枚举类。运行程序,其输出结果为:
Color.red
Color.red
Color.red
1
red
Color.red
Color.green
Color.blue