python运算符重载博客园_python运算符重载（二）

一、基础知识

定义：当类中提供了某个特殊名称的方法，在该类的实例出现在它们相关的表达式时，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