一、基础知识
定义：当类中提供了某个特殊名称的方法，在该类的实例出现在它们相关的表达式时，Python自动调用它们
特性：
1、运算符重载让类拦截常规的Python运算。
2、类可重载所有Python表达式运算符。
3、类可重载打印，函数调用，属性点号运算等内置运算
4、重载使类实例的行为像内置类型
5、重载是通过提供特殊名称的类方法来实现的
二、字典索引和分片：_getitem_,_setitem_,_delitem_
如果在类中定义了（或者继承了）的话，则对于实例中的索引运算，会自动调用__getitem__,__setitem__,__delitem__三个方法。当实例X出现X[i]这样的索引运算时，Python会调用这个实例继承的__getitem__,__setitem__,__delitem__方法（如果有的话）
class Foo:
def __init__(self,name):
self.name=name
def __getitem__(self, item):
return self.__dict__[item]
def __setitem__(self, key, value):
self.__dict__[key]=value
def __delitem__(self, key):
del self.__dict__[key]
F=Foo('egon') #实例化
print(F['name']) #打印，以字典索引的方式，会找到__getitem__方法下的代码，‘name’传递给第二个参数
F['age']=18 #赋值操作，直接传递给__setitem__方法
print(F.__dict__) #打印F的命名空间
del F['age'] #del会调用__delitem__方法，删除‘age’
print(F.__dict__)
打印结果为：
egon
{'name': 'egon', 'age': 18}
{'name': 'egon'}
三、_slots_
__slots__:实例化的对象将没有名称空间，都保存在类的名称空间，而且只能设置指定的属性，例如下面的例子，每个实例只能设置x,y,z三个属性
class People:
__slots__=['x','y','z']
p=People
p.x=1
p.y=2
p.z=3
print(People.__dict__)
p.e=4 #这个将会报错
四、迭代器对象：_iter_,_next_
python 中所有的迭代环境都会先尝试__iter__方法，再尝试__getitem__,也就是说，只有对象在不支持迭代的情况下，才会尝试索引的方式运算。
Python中，迭代环境是通过调用内置函数iter去尝试寻找__iter__方法来实现的，而这种方法返回一个迭代器对象，如果已经提供了，Python就会重复调用这个迭代器对象的next方法，知道发生了StopIteration异常
class Range:
def __init__(self,start,end,long): #构造函数，定义三个元素，start,end,long
self.start=start
self.end=end
self.long=long
def __iter__(self): #__iter__:生成迭代器对象self
return self #返回这个迭代器本身
def __next__(self): #__next__:一个一个返回迭代器内的值
if self.start>=self.end:
raise StopIteration
n=self.start
self.start+=self.long
return n
r=Range(1,10,2) #实例化对象r,
for i in r: #r会首先调用__iter__方法，把自己转换为迭代器
print(i)
五、实现上下文管理：with/as，_enter_,_exit_
with open('a.txt') as f:#with代码块后会自定关闭文件，无论是否发生异常，一下是with的工作方式：
1、计算表达式，所得到的对象称为环境管理器，他必须有__enter__,__exit__方法。
2、环境管理器的__enter__方法会被调用。如果as字句存在，器返回值会赋值给as字句中的变量，否则直接丢弃。
3、代码块中嵌套的代码会执行。
4、如果with代码块引发异常，__exit__(type,value,traceback)方法就会调用（带有异常细节）
5、如果with代码块没有引发异常，__exit__方法依然会被调用，其type,value,traceback参数都会以none传递
import time
class Open:
def __init__(self,filepath,mode='r',encoding='utf8'):
self.filepath=filepath
self.mode=mode
self.encoding=encoding
self.x=open(filepath,mode=mode,encoding=encoding)
def write(self,line):
t=time.strftime('%Y-%m-%d %X')
self.x.write('%s %s' %(t,line))
def __getattr__(self, item):
return getattr(self.x,item)
def __enter__(self):
print("*************")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print('文件关闭')
self.x.close()
with Open('a.txt','w') as f: #出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量
f.write("abc") #调用自己定义的write方法，把‘abc’ 写入到a.txt文件
print('==============') #这一行代码执行完毕后，会触发__exit__方法，关闭文件
print("继续执行代码")
#代码执行如下
*************
==============
文件关闭
继续执行代码
六、_call_:python会为实例用函数调用的表达式运行__call__方法，这样就可以让类实例的外观看起来像是函数
class callee:
def __call__(self, *args, **kwargs):
print('call:',args,kwargs)
C=callee()
C(1,2,3) #实例加（）后，会调用__call__方法
C(1,2,3,X=4,Y=5)
#打印结果如下
call: (1, 2, 3) {}
call: (1, 2, 3) {'X': 4, 'Y': 5}
七、_del_:析构函数
每当实例产生时，就对调用__init__构造函数，没当实例空间被收回时，就会调用__del__析构函数。吃方法一般不需定义，python 有自己的内存回收机制
import time
class Open:
def __init__(self,filepath,mode='r',encoding='utf8'):
self.filepath=filepath
self.mode=mode
self.encoding=encoding
self.x=open(filepath,mode=mode,encoding=encoding)
def __del__(self):
print('del')
self.x.close()
f=Open('a.txt','w')
del f