slots —— 限制实例能添加的属性
我们可以给该实例绑定任何属性和方法
class Student(object):
pass
s = Student()
给实例绑定属性
s.name = 'Michael'
print(s.name)
给实例绑定方法
from types import MethodType
def set_age(self, age):
self.age = age
s.set_age = MethodType(set_age, s)
s.set_age(25)
s.age
给class绑定方法，则对该类的所有实例都有该方法
def set_score(self, score):
self.score = score
Student.set_score = set_score
使用slots
试图绑定不在允许列表里的属性将得到 AttributeError 的错误
class Student(object):
# 用tuple定义允许绑定的属性名称
__slots__ = ('name', 'age')
__slots__ 定义的属性仅对当前类实例起作用，对继承的子类是不起作用的
如果在子类中也定义 __slots__ ，子类实例允许定义的属性就是自身的 __slots__ 加上父类的 __slots__
@property —— 把一个方法变成属性调用
class Student(object):
@property
def score(self):
return self._score
# @property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值
@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方法，不定义setter方法就是一个只读属性：
class Student(object):
# birth 是可读写属性
@property
def birth(self):
return self._birth
@birth.setter
def birth(self, value):
self._birth = value
# age 是只读属性
@property
def age(self):
return 2015 - self._birth
多重继承
在设计类的继承关系时，通常，主线都是单一继承下来的，例如，Ostrich继承自Bird。但是，如果需要“混入”额外的功能，通过多重继承就可以实现，比如，让Ostrich除了继承自Bird外，再同时继承Runnable。这种设计通常称之为MixIn。
为了更好地看出继承关系，我们把Runnable和Flyable改为RunnableMixIn和FlyableMixIn
定制类
str() & repr() —— 打印实例的信息
__str__() 返回用户看到的字符串
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name: %s)' % self.name
print(Student('Michael')) ==> Student object (name: Michael)
__repr__() 返回程序开发者看到的字符串，即 __repr__() 是为调试服务的
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name: %s)' % self.name
# 通常 __str__() 和 __repr__() 代码都是一样的，所以，用偷懒的写法：
__repr__ = __str__
iter() & next() —— 使一个对象可迭代
__iter__() 方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的 __next__() 方法拿到循环的下一个值
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1
def __iter__(self):
# 返回实例本身，因为实例实现了 __next__() 方法，所以是个可迭代对象
return self
def __next__(self):
self.a, self.b = self.b, self.a + self.b
if self.a > 100000:
raise StopIteration()
return self.a
getitem() —— 使一个对象能像list那样按照下标取出元素
class Fib(object):
def __getitem__(self, n):
# n是索引
if isinstance(n, int):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
# n是切片
# 这里没有对step参数作处理，也没有对负数作处理
if isinstance(n, slice):
start = n.start
stop = n.stop
if start is None:
start = 0
a, b = 1, 1
L = []
for x in range(stop):
if x > start:
L.append(a)
a, b = b, a + b
return L
f = Fib()
f[3]
print(f[0:5])
print(f[:10])
如果把对象看成 dict ，__getitem__() 的参数也可能是一个可以作 key 的 object ，例如str
与之对应的是 __setitem__() 方法，把对象视作list或dict来对集合赋值
还有一个 __delitem__() 方法，用于删除某个元素
getattr() 动态返回一个属性
当调用不存在的属性时，比如score，Python解释器会试图调用getattr(self, 'score')来尝试获得属性，这样，我们就有机会返回score的值
class Student(object):
def __init__(self):
self.name = 'Michael'
def __getattr__(self, attr):
if attr=='score':
return 99
# __getattr__默认返回就是None
# 要让class只响应特定的几个属性，我们就要按照约定，抛出AttributeError的错误
raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)
call —— 调用实例本身
对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。
class Student(object):
def __init__(self, name):
self.name = name
# __call__()还可以定义参数
def __call__(self):
print('My name is %s.' % self.name)
s = Student('Michael')
s() ==> My name is Michael.
判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，比如函数和我们上面定义的带有call()的类实例
callable(Student()) ==> True
callable(max) ==> True
callable([1, 2, 3]) ==> False
callable(None) ==> False
callable('str') ==> False
其他特殊的方法名见：special-method-names
枚举类
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
这样我们就获得了Month类型的枚举类，可以直接使用Month.Jan来引用一个常量，或者枚举它的所有成员
for name, member in Month.__members__.items():
# value属性则是自动赋给成员的int常量，默认从1开始计数
print(name, '=>', member, ',', member.value)
如果需要更精确地控制枚举类型，可以从Enum派生出自定义类：
from enum import Enum, unique
# @unique装饰器可以帮助我们检查保证没有重复值
@unique
class Weekday(Enum):
Sun = 0 # Sun的value被设定为0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
访问这些枚举类型的方法：
print(Weekday.Tue)
day1 = Weekday.Tue
print(day1)
print(Weekday['Tue'])
print(Weekday(2))
print(Weekday.Tue.value) ==> 2
使用元类
type() —— 动态创建类
假设有一 hello.py 模块
class Hello(object):
def hello(self, name='world'):
print('Hello, %s.' % name)
from hello import Hello
h = Hello()
h.hello() ==> Hello, world.
# Hello是一个class，它的类型就是type
print(type(Hello)) ==> <class 'type'>
# h是一个实例，它的类型就是class Hello
print(type(h)) ==> <class 'hello.Hello'>
type() 函数既可以返回一个对象的类型，又可以创建出新的类型
比如，我们可以通过type()函数创建出Hello类，而无需通过class Hello(object)...的定义：
# 先定义函数
def fn(self, name='world'):
print('Hello, %s.' % name)
# 参数：
# 1. class的名称
# 2. 继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法
# 3. class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上
Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
h = Hello()
h.hello() ==> Hello, world.
print(type(Hello)) ==> <class 'type'>
print(type(h)) ==> <class '__main__.Hello'>
type() 函数也允许我们动态创建出类来，也就是说，动态语言本身支持运行期动态创建类
metaclass —— 控制类的创建行为（缺）
先定义metaclass，就可以创建类，最后创建实例
所以，metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”
一个简单的例子:
# 这个metaclass可以给我们自定义的MyList增加一个add方法
# metaclass是类的模板，所以必须从`type`类型派生：
class ListMetaclass(type):
# __new__()方法参数
# 1. 当前准备创建的类的对象
# 2. 类的名字
# 3. 类继承的父类集合
# 4. 类的方法集合
def __new__(cls, name, bases, attrs):
attrs['add'] = lambda self, value: self.append(value)
return type.__new__(cls, name, bases, attrs)
# 指示Python解释器在创建MyList时，要通过ListMetaclass.__new__()来创建
class MyList(list, metaclass=ListMetaclass):
pass
动态修改的意义在于：总会遇到需要通过metaclass修改类定义的
