这样，同时拥有Mammal、Runnable的属性和方法。

    __slots__限制实例的属性

    由于类的实例可以动态绑定新的属性，有时候我们不希望这样，可以通过__slots__进行限制：

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

    然后，我们试试：

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

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

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

    1. >>> class SubStudent(Student):
    2. ...     pass
    3. ...
    4. >>> g = SubStudent()
    5. >>> g.score = 99

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

    当我们通过实例使用类的属性时，通常不希望直接访问，而是处理之后再暴露出来。例如：

    1. class Student(object):
    2.     def setScore(self, value):
    3.         if(value > 100):
    4.             value = 100
    5.         if(value < 0):
    6.             value = 0
    7.         self.__score = value
    9.     def getScore(self):
    10.         return self.__score
    12. s = Student()
    13. s.setScore(199)
    14. print(s.getScore())

    输出：

    1. 100

    这里，__score属性我们通过setScore先设置，然后使用getScore获得，并对不合理值进行了处理。

    上面我们通过类里的方法实现了类属性的设置和访问。那么，有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？Python里的@property装饰器就是做这个的：

    1. class Student(object):
    3.     @property
    4.     def score(self):
    5.         return self.__score
    7.     @score.setter
    8.     def score(self, value):
    9.         if(value > 100):
    10.             value = 100
    11.         if(value < 0):
    12.             value = 0
    13.         self.__score = value
    15. s = Student()
    16. print(s.score)

    输出：

    1. 100

    Python内置的@property装饰器就是负责把一个方法变成属性调用。此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值。

    @property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性。

    定制类

    我们可以使用类似__slots__这种变量或者函数名来定制类，这些在Python里是有特殊作用的。

    通过自定义下面这些属性或方法，我们可以对类做自定义处理：

    __slots__：限制实例的属性
    ：自定义返回长度

    输出：

    1. Student object (name: yjc)

    这样打印出来的实例，不但好看，而且容易看出实例内部重要的数据。

    __repr__()：与__str__()类似，当直接敲变量Student('yjc')不用print的时候，会自动调用该方法。

    __getattr__()：默认调用类里不存在的属性时，会报错。通过该方法，可以动态返回一个属性。

    1. class Student(object):
    3.     def __init__(self):
    4.         self.name = 'yjc'
    6.     def __getattr__(self, attr):
    7.         if attr=='score':
    8.             return 80

    这时候调用score属性，不会报错了：

    1. >>> s = Student()
    2. >>> s.name
    3. 'yjc'
    4. >>> s.score
    5. 80

    __call__()：通过覆写该方法，可以将实例像方法那样直接调用：

    1. class Student(object):
    2.     def __init__(self, name):
    3.         self.name = name
    5.     def __call__(self):
    6.         print('My name is %s.' % self.name)

    调用方式如下：

    1. >>> s = Student('yjc')
    2. >>> s() # self参数不要传入
    3. My name is yjc.

    __call__()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。

    通过callable()函数，我们就可以判断一个对象是否是可调用对象：

    1. >>> callable(Student())
    2. True
    3. >>> callable(max)
    4. True

    Python提供Enum类来实现枚举功能：

    1. # coding: utf-8
    2. from enum import Enum
    4. Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
    6. # 可以直接使用Month.Jan来引用一个常量：
    7. print(Month.Jan.value)
    9. # 枚举所有成员：
    10. for name,member in Month.__members__.items():
    11.     print(name, '=>', member, ',', member.value)

    输出：

    value属性则是自动赋给成员的int常量，默认从1开始计数。

    如果想自定义value值：

    1. # coding: utf-8
    2. from enum import Enum,unique
    4. @unique
    5. class Month(Enum):
    6.     Jan = 0
    7.     Feb = 1
    8.     Mar = 2
    10. print(Month.Jan.value)
    12. for name,member in Month.__members__.items():

    输出：

    1. 0
    2. Jan => Month.Jan , 0
    3. Feb => Month.Feb , 1
    4. Mar => Month.Mar , 2

    @unique装饰器可以帮助我们检查保证没有重复值。如果重复了，会报ValueError错误：

    1. ValueError: duplicate values found in <enum 'Month'>

    元类

    1. # coding:utf-8
    3. class Hello(object):
    4.     pass
    6. h = Hello()
    8. print(type(h))
    9. print(type(Hello))
    10. print(type(object))

    输出：

    1. <class '__main__.Hello'>
    2. <class 'type'>
    3. <class 'type'>

    通过打印我们发现，类Hello的类型是type，但它的实例类型是class Hello类型。

    type()函数既可以返回一个对象的类型，又可以创建出新的类型，比如，我们可以通过type()函数创建出Hello类：

    1. # 定义成员方法：减
    2. def sub(self, x, y):
    3.     return x-y
    5. # 生成类
    6. Hello = type('Hello', (object,), {"add":add, "mysub":sub})
    8. h = Hello()
    9. print(h.add(1, 2))
    10. print(h.mysub(1, 2))
    12. print(type(h))
    13. print(type(Hello))

    输出：

    1. 3
    2. -1
    3. <class '__main__.Hello'>
    4. <class 'type'>

    要创建一个class对象，type()函数依次传入3个参数：

    1. class的名称；
    2. 继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
    3. class的方法名称与函数绑定。

    通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。

    metaclass

    metaclass，直译为元类，可以理解为类的模板。通过metaclass也可以动态创建类。

    metaclass是Python面向对象里最难理解，也是最难使用的魔术代码。正常情况下，我们不会碰到需要使用metaclass的情况。

    通过metaclass创建出类，需要：先定义metaclass，然后创建类。下面的示例是给自定义的MyList增加一个add方法：

    示例：

    输出：

    1. <class '__main__.ListMetaclass'> 
    2.  MyList 
    3.  (<class 'list'>,) 
    4.  {'add': <function ListMetaclass.__new__.<locals>.<lambda> at 0x02424540>, '__module__': '__main__', '__qualname__': 'MyList'} 
    6. <class '__main__.ListMetaclass'> 
    7.  OtherList 
    8.  (<class '__main__.MyList'>,) 
    9.  {'add': <function ListMetaclass.__new__.<locals>.<lambda> at 0x02424588>, '__module__': '__main__', '__qualname__': 'OtherList'} 
    11. ['3']

    以上通过metaclass动态生成了MyList类，并增加了成员方法add()。

    通过分析输出，我们可以发现：__new__()方法接收到的参数依次是：

    1. 当前准备创建的类的对象，例如ListMetaclass；
    2. 类的名字，例如MyList；
    3. 类继承的父类集合，例如list；

    什么时候需要用到呢？ORM就是一个典型的例子。