Python面向对象高级编程之slots、@property和多重继承

Python对于类的属性的处理是非常灵活的，正常情况下，当我们定义了一个class，创建了一个class的实例后，我们可以给该实例绑定任何属性和方法 。今天这一篇文章就将两个关于对象的属性的用法：slots和@property。

__slots__变量

在类中定义__slots__变量可以限制实例的属性，比如， 只允许对Student实例添加name和age属性。

1
2

class Student():
    __slots__ = ('name', 'age')

即用tuple定义允许绑定的属性名称，试图在实例中绑定其他属性会得到AttributeError的错误。

使用__slots__要注意，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的。

除非在子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__。

@property

在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把成绩随便改，为了限制score的范围，通常的做法就是设置set和get方法。具体来说，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数。

但是通过Python内置的@property就可以把一个方法变成属性调用：

1
2
3
4
5
6
7
8
9
10
11
12
13

class Student():
    
    @property
    def score(self):
        return self._score;
    
    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError("score must be an integer")
        if value < 0 and value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

1
2
3
4
5
6
7
8

>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.set_score(60)
>>> s.score # OK，实际转化为s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

1
2
3
4
5
6
7
8
9
10
11
12
13

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2015 - self._birth

多重继承

在谈到Python的多重继承的时候，绕不开的一个名词就是MixIn，如果之前写过Django Restful Framework框架，从很多函数名中就可以看出里面用到了很多MixIn。

在设计类的继承关系时，通常，主线都是单一继承下来的，例如，Ostrich继承自Bird。但是，如果需要“混入”额外的功能，通过多重继承就可以实现，比如，让Ostrich除了继承自Bird外，再同时继承Runnable。这种设计通常称之为MixIn。

比如：

1
2

class Dog(Animal, RunnableMixIn, CarnivorousMixIn):
    pass

MixIn的目的就是给一个类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个MixIn的功能，而不是设计多层次的复杂的继承关系。