面向对象的高级编程

__solt__限制实例的属性

在定义class的时候，定义一个特殊的__solts__变量，来限制class实例能添加的属性

class Student(object):
	__solts__=('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'

__solts__只对当前的类实例起作用，对继承的子类不起作用

@property装饰器

@property装饰器负责吧一个方法变成属性调用，相当于getter方法
@property有创造了另外一个装饰器@xxx.setter，负责吧一个setter方法变成属性赋值

class Student(object):

	@property  
	#相当于getter方法
	def mm(self):
		return self.__mm
	
	@mm.setter
	#相当于setter方法
	def mm(self,value):
		if not isintance(value,int):
			raise ValueError('wrong')
		if value<0 or value>100:
			raise ValueErrror('budui')
		self.__mm=value

多重继承

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

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
class Bat(Mammal, Flyable):   #多继承一个
    pass

MixIn

MixIn的目的就是给一个类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个MixIn的功能，而不是设计多层次的复杂的继承关系

class Dog(Mammal, RunnableMixIn, CarnivorousMixIn):
    pass

多重继承的拓扑排序https://kevinguo.me/2018/01/19/python-topological-sorting/

定制类

1. __str__方法

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__

2.iter__方法 (#这个地方有bug?)
如果一个类想被用于for … in循环，类似list或tuple那样，就必须实现一个__iter()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。

class Fib(object):
    def __init__(self):
        self.a, self.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 # 返回下一个值
     for n in Fib():    #把类用在循环中
     print(n)

__getitem__方法

像list那样按照下标取出元素，需要实现__getitem__()方法

class Fib(object):
		def __getitem__(self,n):
			a,b=1,1
			for x in range(n):
				a,b=b,a+b
			return a
f=Fib()
f[0]

如果想用切片，需要对传入的参数进行判断是int，还是slice

class Fib(object):
    def __getitem__(self, n):
        if isinstance(n, int): # n是索引
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        if isinstance(n, slice): # n是切片
            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

__getattr__方法

当调用不存在的属性时，比如score，Python解释器会试图调用__getattr__(self, ‘score’)来尝试获得属性，这样，我们就有机会返回score的值：还可以返回函数。其他调用返回None。

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)  #按规定抛出AttributeError

__call__方法

任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用

class Student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)
>>> s = Student('Michael')
>>> s()          # self参数不要传入
My name is Michael.

枚举类

定义常量时，使用枚举类，定义一个class类型，每个常量都是class的一个唯一的实例。
Enum类

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

元类

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

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

 Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class

学习：http://blog.jobbole.com/21351/（深刻理解python中的元类）