【Python系列专栏】第二十一篇 Python中的面向对象高级编程：定制类-CSDN博客

本文链接：https://blog.csdn.net/Mrrunsen/article/details/116358787

文章目录

定制类

在前面的章节中，我们知道了可以用 __slots__ 变量限制可绑定的属性，我们也知道了在构造类的时候，只要定义了 __len__() 方法，用户就能使用Python内置的 len() 函数获取该类实例的长度。我们知道形如 __xxx__ 的变量/方法都是有特殊用途的，那么Python中还有哪些特殊的变量/方法可以帮助我们更好地定制类呢？

str

我们先定义一个 Student 类，然后打印一个实例：

>>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...
>>> print(Student('Michael'))
<__main__.Student object at 0x109afb190>

但是这样打印实例，我们只能知道它属于什么类以及在内存的位置，它的其他信息全都无法了解，所以对使用者来说并不友好。怎么才能定制打印的信息，使得打印实例时可以看到更多有用的信息呢？只需要定义好 __str__() 方法就可以了：

>>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...     def __str__(self):
...         return 'Student object (name: %s)' % self.name
...
>>> print(Student('Michael'))
Student object (name: Michael)

这样打印实例就不但能知道实例所属的类，也能获得这个实例的属性信息了。

但是细心的朋友会发现直接敲变量不用 print 函数，打印出的实例依然是原来的样子：

>>> s = Student('Michael')
>>> s
<__main__.Student object at 0x109afb310>

这是因为直接显示变量调用的不是 __str__() 方法，而是 __repr__() 方法，两者的区别是 __str__() 方法返回用户看到的字符串，而 __repr__() 返回程序开发者看到的字符串，也就是说，__repr__() 是为调试服务的。

解决办法是再定义一个 __repr__() 方法。但是通常 __str__() 和 __repr__()代码都是一样的（当然，要写不同的也行），所以，有个偷懒的写法：

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__ # 直接令__repr__等于__str__

iter

如果我们希望用 for ... in 循环来遍历一个类的实例，像遍历 list 或 tuple 那样，就必须实现一个 __iter__() 方法，该方法返回一个迭代对象，然后，Python的 for 循环就会不断调用该迭代对象的 __next__() 方法拿到循环的下一个值，直到遇到 StopIteration 错误时退出循环。

我们以斐波那契数列为例，写一个 Fib 类，可以作用于 for 循环：

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，返回自己即可

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环的条件
            raise StopIteration();
        return self.a # 返回下一个值

现在，试试把Fib类的实例作用于 for 循环，就能遍历斐波拉契数列了：

>>> for n in Fib():
...     print(n)
...
1
1
2
3
5
...
46368
75025

getitem

Fib 类的实例虽然能作用于 for 循环，看起来和 list 有点像了，但是没有办法使用下标访问：

>>> Fib()[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'Fib' object does not support indexing

要能像 list 那样按照下标访问元素，需要实现 __getitem__() 方法：

class Fib(object):
    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a

现在，就可以按下标访问数列的任意一项了：

>>> f = Fib()
>>> f[0]
1
>>> f[1]
1
>>> f[2]
2
>>> f[3]
3
>>> f[10]
89
>>> f[100]
573147844013817084101

但是 list 有个神奇的切片方法：

>>> list(range(100))[5:10]
[5, 6, 7, 8, 9]

对于 Fib 却报错。原因是 __getitem__() 传入的参数可能是一个 int，也可能是一个 slice（切片对象），所以要做判断：

class Fib(object):
    def __getitem__(self, n):
        if isinstance(n, int): # n是索引
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        if isinstance(n, slice): # n是切片
            start = n.start
            stop = n.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a + b
            return L

现在再试试对 Fib 类的实例使用切片：

>>> f = Fib()
>>> f[0:5]
[1, 1, 2, 3, 5]
>>> f[:10]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

但是没有对 step（步长）参数作处理：

>>> f[:10:2]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

也没有对负数作处理，所以，要正确实现一个完整的 __getitem__() 还是有很多工作要做的。

此外，如果把对象看成 dict，那么 __getitem__() 的参数也可能是一个可以作key的object，例如 str。

与 __getitem__() 方法对应的是 __setitem__() 方法，把对象视作 list 或 dict 来对一个/多个位置进行赋值。除此之外，还有 __delitem__() 方法，用于删除某个位置的元素。

总之，通过实现上面的方法，可以让我们自己定义的类表现得和Python自带的 list、tuple、dict 没什么区别，这完全归功于动态语言的“鸭子类型”特点，不需要强制继承某个接口就能实现该接口的部分功能。

getattr

正常情况下，当我们调用类的方法或属性时，如果不存在，就会报错。比如定义Student类：

class Student(object):

    def __init__(self):
        self.name = 'Michael'

调用name属性，没问题，但是，调用不存在的score属性，就有问题了：

>>> s = Student()
>>> print(s.name)
Michael
>>> print(s.score)
Traceback (most recent call last):
  ...
AttributeError: 'Student' object has no attribute 'score'

错误信息很清楚地告诉我们，没有找到score这个attribute。

要避免这个错误，除了可以加上一个score属性外，Python还有另一个机制，那就是写一个 __getattr__() 方法，动态返回一个属性。修改如下：

class Student(object):

    def __init__(self):
        self.name = 'Michael'

    def __getattr__(self, attr):
        if attr=='score':
            return 99

当调用不存在的属性时，Python解释器会试图调用 __getattr__(self, '属性名')来尝试获得属性，依然用 score 属性做例子，进行上述定义后，再次执行就变成了：

>>> s = Student()
>>> s.name
'Michael'
>>> s.score
99

动态返回函数也是完全可以的：

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25

只是调用方式要变为：

>>> s.age()
25

注意，只有在没有找到属性的情况下，才调用 __getattr__，已有的属性，比如 name，不会在 __getattr__ 中查找。

此外，注意到此时调用其他任意属性，如 s.abc，返回的是 None，这是因为在 __getattr__ 中我们没有为这些属性定义返回值，那么默认返回就是 None。要让类只响应特定的几个属性，我们可以默认抛出 AttributeError 错误：

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

这样就相当于把一个类的属性和方法调用都进行动态化处理了，不需要其他特殊手段。

这种完全动态调用的特性有什么实际作用呢？作用就是，可以针对完全动态的情况作调用。举个例子，现在很多网站都搞 REST API，比如新浪微博、豆瓣啥的，调用API的URL类似：

http://api.server/user/friends
http://api.server/user/timeline/list

如果要写SDK，为每个URL对应的API都写一个方法，那得累死，而且，API一旦改动，SDK也要改。

借助完全动态的 __getattr__ 方法，我们可以非常方便地实现链式调用：

class Chain(object):
    def __init__(self, path=''):
        self._path = path
    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))
    def __str__(self):
        return self._path
    __repr__ = __str__

试试：

>>> chain = Chain('http://api.server')
>>> API1 = chain.user.friends
>>> print(API1)
http://api.server/user/friends
>>> API2 = chain.user.timeline.list
>>> print(API2)
http://api.server/user/timeline/list

由于 __getattr__ 返回的也是一个 Chain 类的实例，所以后面继续接着使用点符访问属性也是可以的，这就是链式调用的本质。这样，无论想调用什么API，SDK都可以根据不同的URL进行完全动态的调用，不需要随API的增加而改变！相当方便！！

还有一些REST API会把参数放在URL中，比如GitHub的API：

GET /users/:user/repos

调用时，需要把 :user 替换为实际用户名。这时我们希望可以用这样的链式调用来获取API：

chain().users('michael').repos

尝试一下：

class Chain(object):
    def __init__(self, path=''):
        self._path = path
    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))
    def users(self, username):
        return Chain('%s/%s' % (self._path, username))
    def __str__(self):
        return self._path
    __repr__ = __str__

运行结果：

>>> chain = Chain('/users')
>>> chain.users('michael').repos
/users/michael/repos

当然，除了实现一个 users 方法之外，直接在 getattr 方法里面使用正则也是可以的。

call

一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用 实例名.方法名() 的方式来调用。能不能直接把实例本身当作一个方法调用呢？在Python中，答案是肯定的。

对任何类来说，只需要实现 __call__() 方法，就可以直接对该类的实例进行调用。比如：

class Student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)

调用方式如下：

>>> s = Student('Michael')
>>> s() # 调用实例本身，self参数不需要传入
My name is Michael.

和普通的函数和方法一样，我们还可以为 __call__() 方法定义其他参数。但有一点很特别，我们注意到类的实例都是运行期间动态创建出来的，而一般来说可调用对象（函数/方法）都是预先定义的，所以说当我们把实例本身变成可调用的方法时，实际上我们是动态创建了可调用对象。

能被调用的对象就是一个 Callable 对象，要判断一个对象是否可调用可以使用Python内置的 callable 函数：

>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False

小结

Python中的类允许定义许多定制方法，可以让我们非常方便地生成特定的类。

本节介绍的是最常用的几个定制方法，还有很多可定制的方法，请参考Python的官方文档。

使用枚举类

为何需要枚举类

当我们需要定义常量/枚举值时，一个比较常见的办法是用大写变量通过整数来定义，例如月份：

JAN = 1
FEB = 2
MAR = 3
...
NOV = 11
DEC = 12

这样做的好处是简单，缺点是把数据类型变为了 int 型，并且在Python中仍然是变量，因此可能会在使用者无法意识到的情况下被错误的操作改变值。

如何使用枚举类

更好的方法是使用Python提供的枚举类 Enum，把每一个枚举对象作为枚举类的一个属性：

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')) # 创建一个枚举类的实例

这样我们就获得了一个类型为 Month 的枚举类，可以直接使用 Month.Jan 来引用一个常量，或者枚举它的所有成员：

>>> for name, member in Month.__members__.items():
...     print(name, '=>', member, ',', member.value)
...
Jan => Month.Jan , 1
Feb => Month.Feb , 2
Mar => Month.Mar , 3
Apr => Month.Apr , 4
May => Month.May , 5
Jun => Month.Jun , 6
Jul => Month.Jul , 7
Aug => Month.Aug , 8
Sep => Month.Sep , 9
Oct => Month.Oct , 10
Nov => Month.Nov , 11
Dec => Month.Dec , 12

特别地，枚举类中的每个成员会被分配一个 int 型的 value 属性，默认按初始化顺序从1开始计数。

自定义枚举类

如果需要更精确地控制枚举类型，可以继承 Enum 类然后进行自定义：

from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

@unique 装饰器可以帮助我们检查枚举值是否存在重复，注意属性名字重复也会报错，但是与 @unique 装饰器无关。

自定义的枚举类使用方法和使用 Enum 构造的类似：

>>> day1 = Weekday.Mon         # 按属性访问
>>> print(day1)                # 打印枚举变量
Weekday.Mon
>>> day1                       # 直接显示枚举变量
<Weekday.Mon: 1>
>>> day1.name                  # 获得枚举变量的名称
'Mon'
>>> day1.value                 # 获得枚举变量的值
1

>>> print(Weekday['Tue'])      # 使用属性名作下标访问
Weekday.Tue
>>> print(day1 == Weekday.Mon) # 属性之间可以直接进行比较
True
>>> print(day1 == Weekday.Tue)
False

>>> print(Weekday(1))           # 把类作为一个方法调用，传入枚举值
Weekday.Mon
>>> print(day1 == Weekday(1))
True
>>> Weekday(7)                  # 找不到该枚举值对应的属性
Traceback (most recent call last):
  ...
ValueError: 7 is not a valid Weekday

>>> for name, member in Weekday.__members__.items(): # 遍历枚举类
...     print(name, '=>', member)
...
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat