1、__slots__

python作为动态语言，可以先定义框架，后补方法和属性

观察class Student(object):

                pass

①给实例补属性

s=Student()

s.name='Mike'

print(s.name)

②给实例补方法

def set_age(self,age)

        self.age=age

s.set_age=types.MethodType(set_age,s)

s.set_age(25)

s.age

s2 = Student() # 创建新的实例
>>> s2.set_age(25) # 尝试调用方法

结果肯定是报错的

那怎么让Student class添加新方法呢？

③给class补方法

def set_score(self,score)
    self.score=score
Student.set_score=set_score

④如何限制添加

补充属性与方法我们已经研究了，现在学习怎么禁止添加。

禁止添加的方法就是在构造函数里面定义一个__slots__变量

class Student (object):
    __slots__=('name','age')
a=Student()
a.name=1
a.age=2
a.s=3

肯定会报错的。

应当注意，__slots__的限制力无法继承

2、@property

@property本质上是python自带的一个装饰器，目的是将getter和setter转化为属性

对于getter，@property就可以使用

对于setter，写作@XX.setter

class Student(object)
    @proeprty
    def score(self):
        return self._score
    @score.setter
    def score(self,value):
        if not isinstance(vlaue,int):
            raise ValueError('must be int!')
        if value>100 or value<0:
            raise ValueError('from 0 to 100!')
        self.score=value
s=Student()
s.score=1
print(s.score)
            

3、多重继承

如果分类标准是复合型的，这将引发灾难性的指数增长，所以对于复合型的分类，应当使用多重继承。

class Animal(object):
    pass
class Mammal(Animal):
    pass
class Bird(Animal):
    pass
class Flyable(object):
    def fly(self):
        print("fly")
class Runnable(object):
    def run(self):
        print("run")
class Dog(Mammal,Runnable):
    pass
dog=Dog()
dog.run()

这就是最简单的多继承，dog既是一种动物，又是一种会跑的对象，自然就有了跑方法。

这种设计方法我们称作MixIn。

MixIn设计方法在python自带库函数中当然也有体现，python自带了TCPServer和UDPServer来进行网络通信，多进程与多线程模型由ForkingMixIn和ThreadingMixIn来实现，那么如何混搭一个多进程的TCP服务呢？

class MyTCPServer(TCPServer,ForkingMixIn):
    pass

4、定制类

其实就很像Java的重写覆盖（不涉及继承）

__str__返回用户看到的字符串

__repr__返回调试字符串

__iter__允许for in循环

__next__捕捉for in 的数据

__getitem__使类有list的特性

__getattr__试图寻找某种属性

__call__使class具有函数特性

class Student(object):
    def __init__(self,name):
        self.name=name
    def __str__(self):
        return ("name:"+self.name)
    def __repr__(self):
        return ("name:" + self.name)
    def __iter__(self):#允许for in 循环
        return self
    def __next__(self):#使得for循环可以捕捉数据
        return self.name
    def __getitem__(self, item):
        a=b=1
        for i in range(item):
            (a,b)=(b,a+b)
        return a
    def __getattr__(self, item):
        if item=='score':
            return 99
        else:
            raise AttributeError('\'Student\' object has no attribute \'%s\'' % item)

student=Student('mike')
print(student.sc)
print(student.name)

class Student(object):
    def __init__(self,name):
        self.name=name
    def __call__(self):
        print("name:%s" % self.name)
s=Student("MIKE")
s()

5、枚举类

一个变量只有有限且固定的选项，则可以使用枚举类。

from enmu import Enum
Month=Enum('Month',('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
for (i,number) in Month.__member__.items():
    print("%s:%s,%s" % (i,number,number.value))

按照这种写法，自动value从1开始排列

如果从Enum中派生子类，可以自定义value

from enum import Enum,unique
@unique
class Weekday(Enum):
    Sun=0
    Mon=1
    Tue=2
    Wed=3
    Thu=4
    Fri=5
    Sat=6   
for (i,number) in Weekday.__members__.items():
    print("%s,%s:%s" % (i,number,number.value))

6、动态类

class Hello(object):
    def hello(self,name='world'):
        print('hello,%s' % name)
h=hello()
h.hello()

如果使用type(name,(object,object,object...),dict(key=value))

def hello(self,name='world'):
    print('name:%s' % name)
Hello=type('Hello',(object,),dict(hello=hello))
h=Hello()
h.hello()