⑥Python面向对象高级编程

⑥面向对象高级编程

使用_slots_

可以为创建的对象动态绑定属性和方法，这是动态语言的灵活性。

class student(object):
    pass
>>> s = student()
>>> s.name = 'Michael'
>>> print(s.name)

还可以给实例绑定一个新方法。

>>> def set_age(self, age): # 定义一个函数作为实例方法
...     self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法
>>> s.age # 测试结果
25

对某个实例绑定新方法，对其他实例不起作用，只对当前实例有作用。如果想给所有实例都绑定方法，可以给class绑定方法。

def set_score(self,score):
    self.score = score
    
>>> student.set_score =

给类绑定方法之后，所有实例均可以调用。

如果想限制实例的属性，需要对类添加​​__slots__​​来限制对实例添加的属性。

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

注意：__slots__只对当前类起作用，对子类不起作用

使用@property

为了简化绑定属性时的检查函数和属性调用这样的流程，引入了类似于装饰器（decorate）的特性@property，将一个方法变成属性调用。

class screen():
    @property
    def width(self):
        return self._width

    @width.setter
    def width(self,value):
        self._width = value

    @property
    def height(self):
        return self._height

    @height.setter
    def height(self, value):
        self._height = value

    @property
    def resolution(self):#resolution是只读属性
        return self._width * self._height

多重继承

继承是面向对象编程的一个重要方式，因为通过继承，子类就可以拓展父类的功能。

如果想要一个对象继承多个父类的功能，按照传统的层次设计，类的数量会指数级增长。

┌───────────────┐
                │    Animal     │
                └───────────────┘
                        │
           ┌────────────┴────────────┐
           │                         │
           ▼                         ▼
    ┌─────────────┐           ┌─────────────┐
    │   Mammal    │           │    Bird     │
    └─────────────┘           └─────────────┘
           │                         │
     ┌─────┴──────┐            ┌─────┴──────┐
     │            │            │            │
     ▼            ▼            ▼            ▼
┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐
│  MRun   │  │  MFly   │  │  BRun   │  │  BFly   │
└─────────┘  └─────────┘  └─────────┘  └─────────┘
     │            │            │            │
     │            │            │            │
     ▼            ▼            ▼            ▼
┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐
│   Dog   │  │   Bat   │  │ Ostrich │  │ Parrot  │
└─────────┘  └─────────┘  └─────────┘  └─────────┘

为了解决这样的问题，正确的方法应该是采用多重继承。

class Runnable(object):
    def run(self):
        print('Running...')
 
class Flyable(object):
    def fly(self):
        print('Flying...')
        
class Dog(Mammal,Runnable):
    pass

Python这样的多继承设计，能够通过不同的继承父类的组合，很好的实现多功能，其基于的技术成为Mixln，其目的就是给一个类增加多个功能，这样，在设计类的时候，优先考虑通过多重继承来组合多个Minln的功能，而不是设计多层次的复杂继承关系。

class Dog(Mammal,RunnableMixln,CarnivorousMixln):
    pass

这样的设计我们可以很清楚的看到继承的主线，和我们想要增加的功能，也就是从Mixln继承来的。

定制类

通过类的模式方法，来对类进行定制。

class custome():
    
    def __init__(self):
        pass
    
    def __str__(self):
        pass
    
    def __repr__(self):
        pass
    
    def __getitem__(self, item):
        pass
    
    def __getattr__(self, item):
        pass

使用枚举类

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