面向对象高级编程
使用slots
正常情况下，当我们定义了一个Class，并创建了一个关于Class的instance后，我们可以该instance绑定任何属性和方法，这表现了动态语言的灵活性。
class Student(object):
pass
给instance绑定属性：
>>>s = Student()
>>>s.name = 'Michael'
>>>print('s.name')
Michael
给instance绑定一个方法：
>>> 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
注意，给一个instance绑定的方法对另一个instance不成立
>>>s2 = Student
>>>s2.set_age(25)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'set_age'
为了解决这个，给所有的instance都绑定方法，我们选择给Class绑定方法
>>> def set_score(self, score):
... self.score = score
...
>>> Student.set_score = set_score
给Class绑定方法后，所有的instance都可以调用。这体现了动态语言的优点。
使用slots（限制instance的属性）
为了达到限制的目的，可以再定义Class的时候，定义一个特殊的slots变量，来限制该Class实例可以添加的属性。
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 "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
注意，slots定义的属性仅仅对当前类起作用，对集成的子类不起作用。除非在子类中也定义slots，这样，子类实例允许定义的属性就是自身的slots加上父类的slots。
使用@property
为了解决在绑定属性时，虽然将属性直接暴露出去但是无法检查参数的问题（导致例子中的成绩可以随意修改）
s = Student()
s.score = 9999
为了解决这样的问题可以添加方法来get和set
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
这样就可以：
>>> s = Student()
>>> s.set_score(60) # ok!
>>> s.get_score()
60
>>> s.set_score(9999)
Traceback (most recent call last):
...
ValueError: score must between 0 ~ 100!
为了简化，使类的属性即可以被检查又可以通过访问属性的简单方式进行访问，可以使用Python内置的装饰器：
class Student(object):
"""docstring for Student"""
@property
def score(self):
return self._score
@score.setter
def score(self,value):
if not isinstance(value,int):
raise ValueError('score mmust be an integer')
if value < 0 or value > 0:
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!
定义只读属性的方法：只定义getter方法，不定义setter方法
多重继承
继承是面向对象编程的三个重要特点之一，因为通过继承，子类就可以扩展父类的功能。
# Dog - 狗狗；
# Bat - 蝙蝠；
# Parrot - 鹦鹉；
# Ostrich - 鸵鸟。
# 哺乳类：能跑的哺乳类，能飞的哺乳类；
# 鸟类：能跑的鸟类，能飞的鸟类。
# 使用多重继承
class Animal(object):
pass
# 大类:
class Mammal(Animal):
pass
class Bird(Animal):
pass
# 各种动物:
class Dog(Mammal):
pass
class Bat(Mammal):
pass
class Parrot(Bird):
pass
class Ostrich(Bird):
pass
为了给动物加上Runnable和Flyable的功能，可以定义相应的类：
class Runnable(object):
def run(self):
print('Running...')
class Flyable(object):
def fly(self):
print('Flying...')
对于需要Runnable功能的动物，就多继承一个Runnable，例如Dog：
class Dog(Mammal,Runnable):
pass
对于需要Flyable功能的动物，就多继承一个Flyable，例如Bat：
class Bat(Mammal, Flyable):
pass
Mixln
在设计类的继承关系时，通常主线都是单一继承下来的，但是如果需要“混入”特殊的功能，通过多重继承就可以实现（Mixln），这是因为通过多重继承子类就可以同时获得多个父类的功能。
为了更好地看出继承关系，我们把Runnable和Flyable改为RunnableMixIn和FlyableMixIn,类似的，你还可以定义出肉食动物CarnivorousMixIn和植食动物HerbivoresMixIn，让某个动物同时拥有好几个MixIn：
class Dog(Mannal,RunnableMixln,CarnivorousMixln):
pass
MixIn的目的就是给一个类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个MixIn的功能，而不是设计多层次的复杂的继承关系。
定制类
除了之前介绍过的slots和len方法之外还有很多有特殊用途的函数可以帮我们定制类。
str
>>> class Student(object):
... def __init__(self, name):
... self.name = name
...
>>> print(Student('Michael'))
<__main__.Student object at 0x109afb190>
#为了改变上面不美观的输出结果，需要定义好__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)
但是直接敲变量不用print打印出来的实例还是不好看：
>>> 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)
这是因为直接显示变量调用的不是str()，而是repr()，两者的区别是str()返回用户看到的字符串，而repr()返回程序开发者看到的字符串，也就是说，repr()是为调试服务的。
解决方案就是直接将事先定义好的str赋值给repr
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name=%s)' % self.name
__repr__ = __str__
iter
如果一个类想被用于for... in循环，就必须实现一个iter()方法，该方法返回一个迭代的对象，然后python的for循环就会不断的调用该迭代的next()方法得到循环的下一个值，知道StopIteration.
例如：
class Fib(object):
def __init__(self):
self.a, selff.b = 0,1 #初始化两个计数器a，b
def __iter__(self):
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
上面的例子中的instance虽然可以yongfor循环，但是不可以完全把它当做list处理：
>>> Fib()[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'Fib' object does not support indexing
为了取出下标元素，需要实现getitem方法：
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
为了进一步的实现list中的slice操作：
#我们必须让__getitem__()判断传入的参数是int还是slice
class Fib(object):
"""docstring for Fib"""
def __getitem__(self, n):
if isinstance(n, int):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
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
如果要让getitem实现对step参数和负数的处理还需要进一步的完善。
getattr
正常情况下，当调用类的方法或属性时，如果不存在就会报错。
例子：
class Student(object):
def __init__(self):
self.name = 'Michael'
#调用name属性，没有问题，但是调用不存在的score属性就有问题了
>>> s = Student()
>>> print(s.name)
Michael
>>> print(s.score)
Traceback (most recent call last):
...
AttributeError: 'Student' object has no attribute 'score'
要避免这个错误，除了可以加上一个score属性外，Python还有另一个机制，那就是写一个getattr()方法，动态返回一个属性。修改如下：
class Student(object):
def __init__(self):
self.name = 'Michael'
def __getattr__(self, attr):
if attr=='score':
return 99
当调用不存在的属性时，比如score，Python解释器会试图调用getattr(self, 'score')来尝试获得属性，这样，我们就有机会返回score的值：
>>> s = Student()
>>> s.name
'Michael'
>>> s.score
99
注意，只有在没有找到属性和的情况下才调用_getattr，已有的属性不会在__getattr中查找。
注意到任意调用如s.abc都会返回None，这是因为我们定义的getattr默认返回就是None。要让class只响应特定的几个属性，我们就要按照约定，抛出AttributeError的错误：
class Student(object):
def __getattr__(self, attr):
if attr=='age':
return lambda: 25
raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)
call
一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用，也可以通过call直接在instance上调用（不用显式的写出method）。
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
#调用方式
>>>s = Student('Michael')
>>>s()
My name is Michael
除此之外，call()还可以定义参数，这让对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者本身就没什么根本的区别。
更多的时候我们判断一个对象是否可以被调用，能被调用的对象是一个Callable对象：
>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False
使用枚举类
当我们定义常量的时候，可以使用大写变量通过整数来定义：
JAN = 1
FEB = 2
MAR = 3
...
NOV = 11
DEC = 12
但是变量的类型仍然是int。
更好的方法是为这样的枚举类型定义一个Class类型，每个变量都是Class的一个唯一的实例
#获得Month类型的枚举类
from enum import Enum
Month = Enum ('Month',('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
#可以直接使用Month.Jan来引用一个常量，或者枚举它的全部成员：
for name,member in Month.__members__.items():
print(name,'=>',member,',',member.value)
value属性则是自动赋给成员的int常量，默认从1开始计数。
如果需要更精确地控制枚举类型，可以从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
使用元类
type()
动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，而是运行时动态创建的。
前情提要：已经写好了hello.py的Module：
class Hello(object):
def hello(self,name='world'):
print('Hello,%s.' %name)
当Python解释器载入hello Module使，就会依次执行该Module的所有语句，执行结果就是动态的创建一个Hello的class对象（类也是一种对象）。
>>> from hello import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class 'hello.Hello'>
type()函数可以查看一个类型或变量的类型，Hello是一个class，它的类型就是type，而h是一个实例，它的类型就是class Hello。
type()函数可以返回一个对象的类型，又可以创建出新的类型。
#可以通过type()函数创建出Hello类，而无需通过之前的方法
>>> def fn(self, name='world'): # 先定义函数
... print('Hello, %s.' % name)
...
>>> 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'>
要创建一个Class对象，type()函数依次传入3个参数：
1.class的名称
2.继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法
3.class的方法名称与函数绑定
通过type()函数创建的类和直接写Class是一样的，因为Python解释器遇到Class定义时，仅仅是扫面一下class定义的语法，然后调用type()函数创建出class
正常情况下，我们都用class Xxx...来定义类，但是，type()函数也允许我们动态创建出类来，也就是说，动态语言本身支持运行期动态创建类，这和静态语言有非常大的不同，要在静态语言运行期创建类，必须构造源代码字符串再调用编译器，或者借助一些工具生成字节码实现，本质上都是动态编译，会非常复杂。
metaclass
除了使用type()动态创建类以外，要控制类的创建行为，还可以使用metaclass：先定义metaclass，就可以创建类，最后创建instance（可以将类看成是metaclass创建的实例）
例子：使用metaclass给自定义的Mylist增加一个add方法
#metaclass是类的模板，必须从type类派生
class ListMetaclass(type):
def __new__(cls,name,bases,attrs):
attrs['add'] = lambda self,value : self.append(value)
return type.__new__(cls,name,bases,attrs)
有了ListMetaclass，我们在定义类的时候还要指示使用ListMetaclass来定制类，传入关键字metaclass：
class Mylist(list,metaclass=ListMetaclass):
pass
当我们传入关键字参数metaclass时，魔术就生效了，它指示Python解释器在创建MyList时，要通过ListMetaclass.new()来创建，在此，我们可以修改类的定义，比如，加上新的方法，然后，返回修改后的定义。
new()方法接收到的参数依次是：
当前准备创建的类的对象；
类的名字；
类继承的父类集合；
类的方法集合。
#测试：
>>> L = MyList()
>>> L.add(1)
>> L
[1]
#普通的list没有add()方法
>>> L2 = list()
>>> L2.add(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'add'
元类的方法可以用在写ApI或者数据库中的ORM（object relationship mapping）等方面。
为了加深理解，附上一个知乎上的回答：
[type和object的关系]https://www.zhihu.com/question/38791962/answer/78172929
