Python3学习笔记（20）----面向对象的高级特性

1、给类或实例动态绑定属性和方法

我们在定义完一个类之后，若不想修改源代码，可以动态绑定一些属性和方法：

    class Student(Object):
        pass

    s = Student()
    s.name ="jj";#给一个实例绑定一个属性

    def set_age(self,age):
        self.age = age

    from type import MethodType
    s.set_age = MethodType(set_age,s)#给实例绑定一个方法
    s.set_age(15)#调用该函数

给一个实例绑定的方法，对另一个实例来说，是不起作用的，例如下面的代码是错误的：

    s2 = Student()
    s2.set_age(16)

给class绑定方法后，所有的实例都可以去调用该方法：

    Student.set_age = set_age

2、slots函数

想要限制实例的属性怎么办？比如，只允许对Student实例添加name和age属性：

    class Student(object):
        __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

测试一下：

    >>> s = Student() # 创建新的实例
    >>> s.name = 'Michael' # 绑定属性'name'
    >>> s.age = 25 # 绑定属性'age'
    >>> s.score = 99 # 绑定属性'score'
    Traceback (most recent call last):
    File "", line 1, in <module>
    AttributeError: 'Student' object has no attribute 'score'

由于’score’没有被放到slots中，所以不能绑定score属性，试图绑定score将得到AttributeError的错误。

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

3、使用@property

在之前的Student类中，为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：

    class Student(object):

        def get_score(self):
            return self._score

        def set_score(self, value):
            if not isinstance(value, int):
                raise ValueError('score must be an integer!')
            if value < 0 or value > 100:
                raise ValueError('score must between 0 ~ 100!')
            self._score = value

现在，对任意的Student实例进行操作，就不能随心所欲地设置score了，但是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。

有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？

装饰器（decorator）可以给函数动态加上功能，对于类的方法，装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

    class Student(object):

        @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 or value > 100:
                raise ValueError('score must between 0 ~ 100!')
            self._score = value

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

    >>> 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!

注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的。

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

    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

上面的birth是可读写属性，而age就是一个只读属性，因为age可以根据birth和当前时间计算出来。

4、多重继承

写一个大的类Animal

    class Animal(Object):
        pass

然后写一个哺乳类和鸟类，继承了Animal主类：

    class Buru(Animal):
        pass
    class Bird(Animal):
        pass

这个时候我们再写具体的动物，dog类，和蝙蝠类，都属于哺乳类：

    class Dog(Buru):
        pass
    class Bianfu(Buru):
        pass

根据实际情况，我们要给动物加上Runnable（跑），flyable（飞）功能，我们只需先定义好这两个类：

    class Runnable(Object):
        print("running")
    class flyable(Object):
        print("flying")

然后再给具体的Dog和Bianfu实现具体的功能：

    class Dog(Buru,Runnable):
        pass
    class Bianfu(Buru,flyable):
        pass

这样，通过多重继承，子类就可以具有多个父类的功能。

MixIn

通俗的说，这就是一种模式：混入模式。
在设计类的继承关系时，通常，主线都是单一继承下来的，例如，Buru类和Bird类单一继承了Animal类，但是，如果想让Dog和Bianfu类都混入额外的功能，那就需要多重继承，这种设计通常称作：MixIn

为了更好地看出继承关系，我们把Runnable和Flyable改为RunnableMixIn和FlyableMixIn，似的，你还可以定义出肉食动物CarnivorousMixIn和植食动物HerbivoresMixIn，让某个动物同时拥有好几个MixIn：

    class Dog(Mammal, RunnableMixIn, CarnivorousMixIn):
        pass

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