前几天一直在练手廖雪峰老师的python课程，接下来继续学习，由于面向对象编程这一课相对理论便不在此练手，直接上手面向对象高级编程。
一、使用 __slots__
一般情况下一个class是可以绑定一个属性和方法的，例如：
#给实例绑定属性 和 方法
#绑定属性
class Student(object):
pass
s = Student()
s.name = 'nihao'
print(s.name)
绑定方法：
#绑定方法
def setAge(self, a):
self.age = a
from types import MethodType
s.setAge = MethodType(setAge, s)
s.setAge(22)
print( s.age )
给一个实例绑定一个方法，对于另外一个实例是不起作用的
例如：
#给一个实例绑定一个方法，对于另外一个实例是不起作用的 s2 = Student() #s2.setAge(11)
说明：这里的s2.setAge(11)是会报错的。
但是给class绑定方法后，所有实例均可调用
#但是给class绑定方法后，所有实例均可调用
def setScore(self, score):
self.score = score
Student.setScore = setScore
s.setScore(11)
print( s.score )
s2.setScore(33)
print( s2.score )
其他的案例将函数写在class里面，任何实例都可以调用：
class Test(object):
def myFun(self, num):
self.num = num
t = Test()
t.myFun(22)
print(t.num)
总结：可以给一个实例绑定方法和属性，但是另外一个实例调用是不起作用的，除非给class绑定一个方法，或者在class里面自定义一个方法，这样才会在所有的实例中都可以调用。
使用__slots__
说明：__slots__ 的英文单词是槽的意思，也就是一个位置的意思。占用一个坑。__slots__的好处是可以限定一个class的实例绑定属性的个数和指定属性的标准。
比方说我限定了一个类只能在外部绑定哪些属性名称，通过__slots__定义的就可以使用 否则定义其他属性的 class 都不认识。
案例：
class Student(object):
__slots__ = ('name', 'age') #用tuple定义允许绑定的属性名称
s = Student()
s.name = 'cici'
print( s.name )
s.age = '18'
print( s.age )
s.score = 100
print( s.score )
输出：
cici
18
Traceback (most recent call last):
File "/mnt/hgfs/webspace/pythonStudy/one.py", line 678, in <module>
s.score = 100
AttributeError: 'Student' object has no attribute 'score'
由此可见，只有定义了属性名称，是可以做外部绑定的，没有定义的属性名称，是绑定不成功的。
另外需要注意的是：__slots__只对当前类起作用，对于继承的子类是不起作用的。
二、使用@property
通常我们通过实例去给一个实例绑定一个属性，或者修改属性的值，显然很不安全，可以通过如下案例实现：
class Student(object):
def getScore(self):
return self._score
def setScore(self, val):
if not isinstance(val, int):
raise ValueError('请输入整型')
if val <0 or val> 100:
raise ValueError('范围要在0-100直间')
self._score = val
s = Student()
s.setScore(44)
print( s.getScore() )
说明：由此可见，通过设置方法，去设置参数，再通过另外一个方法去获取参数。明显比较安全些，但是这种写法稍微复杂了一点，要调用两个方法才行
python恰好有一个即可以验证参数，有可以像普通绑定属性这样简单的方式，那就是python内置的@property装饰器 装饰器就是负责把一个方法变成属性调用的形式：
案例：
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, val):
if not isinstance(val, int):
raise ValueError('score is integer')
elif val <0 or val >100:
raise ValueError('0-100')
self._score = val
s = Student()
s.score = 90
print(s.score)
输出：90
说明：要将一个getter方法变成属性一样的调用，只需要加上@property就可以了，另外 @property 本身又创建了一个装饰器@score.setter 负责把一个setter方法变成属性赋值，这样就可以得到一个可控的属性操作了。
三、定制类
在python中类似__xxx__的变量或则函数名说明它们是拥有特殊用途的函数。
例如：
__str__
案例：
class Student(object):
def __init__(self, name):
self.name = name
print( Student('cici') )
输出：<__main__.Student object at 0x7fd703484940>
说明：由此可见，这种输出是非常不好看的，改一下
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name: %s)' % self.name
print( Student('cici') )
输出：Student object (name: cici)
由此可见，__str__()方法是可以返回一个好看的字符串的，而且还可以看出实例内部的数据。
__iter__
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 #初始化两个计数器
def __iter__(self):
return self #实例本身就是迭代对象
def __next__(self):
self.a, self.b = self.b, self.a+self.b #计算下一个值
if self.a > 20: #退出循环的条件
raise StopIteration()
return self.a #返回下一个值
for item in Fib():
print(item)
输出：
1 1 2 3 5 8 13
说明：如果一个类想要被for ... in ... 循环，类似list 或 tuple ，就必须实现一个__iter__() 方法 返回它自己，改方法返回一个迭代对象，然后，python 的 for 循环将会不间断的调用该迭代对象的 __next__() 方法，拿到循环的下一个值，直到遇到 StopIteration 错误时退出。
__getitem__
上面定义的Fib实例虽然可以作用于for循环，看起来类似list，但是它并不能类似list一样去使用，比如取值的时候：
class Fib(object):
def __getitem__(self, item):
a,b = 1,1
for x in range(item):
a, b = b, a+b
return a
print(Fib()[0])
print(Fib()[1])
print(Fib()[2])
print(Fib()[3])
print(Fib()[4])
print(Fib()[5])
输出：
1 1 2 3 5 8
说明：由此可见，若要将一个实例像list那样调用按照下标取元素，需要在定义一个__getitem__（）方法。
注意： list 有一个切片方法，但是用在类里面会报错，这是由于__getitem__()传入的参数有可能是一个int 也有可能是一个切片的对象slice，所以需要做判断：
__getattr__
一般情况下，如果我们调用一个类的方法或者属性，如果不存在，就会报错，例如：
class Student(object):
def __init__(self):
self.name = 'cici'
s = Student()
print( s.name )
print( s.score )
输出：
cici
Traceback (most recent call last):
File "/mnt/hgfs/webspace/pythonStudy/one.py", line 771, in <module>
print( s.score )
AttributeError: 'Student' object has no attribute 'score'
说明：由此可见，调用 name 的时候没有问题，而调用 score的时候说Student没有找score的元素
通过__getattr__控制
class Student(object):
def __init__(self):
self.name = 'cici'
def __getattr__(self, item):
if item == 'score':
return 100
s = Student()
print( s.name )
print( s.score )
print( s.aaaaa )
输出:
cici 100 None
说明：由此可见，在类中增加了一个__getattr__ 可以自定义输出的属性，另外在次访问不存在的属性或时会友好的返回None
__call__
一个对象实例可以有自己的属性和方法，当我们调用实例方法时使用 instance.method() 来调用，能不能直接在实例本身上调用呢？案例
例如：
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
return self.name
s = Student('cici')
print( s() )
输出：‘cici'
说明：由此可见，如果像调用实例本身 s() 其实是可以调用成功的，因为这类中我们已经定义了一个__call__()方法，这样就实现了调用实例就好像调用函数一样的效果。
那么问题就来了，如果区分它是一个对象，还是一个函数呢？更多时候，我们需要判断一个对象是否能够被调用，能够被调用的对象就是一个Callable对象
例如：
print( callable(Student) )
返回：True
所以、通过callable()函数，就可以判断这个对象是否是 可调用的 对象。
四、使用枚举类
定义一个枚举
from enum import Enum, unique
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
for name, member in Month.__members__.items():
print(name, '=>', member, ',', member.value)
输出：
Jan => Month.Jan , 1 Feb => Month.Feb , 2 Mar => Month.Mar , 3 Apr => Month.Apr , 4 May => Month.May , 5 Jun => Month.Jun , 6 Jul => Month.Jul , 7 Aug => Month.Aug , 8 Sep => Month.Sep , 9 Oct => Month.Oct , 10 Nov => Month.Nov , 11 Dec => Month.Dec , 12
访问枚举的方法
@unique
class Weekday(Enum):
Sun = 0 # Sun的value被设定为0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
#访问这些枚举类型的方法
day1 = Weekday.Mon
print( day1 )
print( day1.value )
print( Weekday['Thu'])
print( Weekday['Thu'].value)
print( Weekday(2) )
输出：
Weekday.Mon 1 Weekday.Thu 4 Weekday.Tue
可见，既可以用成员名称引用枚举常量，又可以直接根据value的值获得枚举常量。
五、使用元类
。。。