[Python]重载运算符
Python运算符重载
| Method | Overloads | Call for |
| __init__ | 构造函数 | X=Class() |
| __del__ | 析构函数 | 对象销毁 |
| __repr__ | 打印转换 | print X，repr(X) |
| __str__ | 打印转换 | print X，str(X) |
| __call__ | 调用函数 | X() |
| __getattr_ | 限制 | X.undefine |
| __setattr__ | 取值 | X.any=value |
| __getitem__ | 索引 | X[key]，For If |
| __setitem__ | 索引 | X[key]=value |
| __len__ | 长度 | len(X) |
| __iter__ | 迭代 | For In |
| __add__ | + | X+Y,X+=Y |
| __sub__ | - | X-Y,X-=Y |
| __mul__ | * | X*Y |
| __radd__ | 右加+ | +X |
| __iadd__ | += | X+=Y |
| __or__ | | | X|Y,X|=Y |
| __cmp__ | 比较 == | X==Y,X |
| __lt__ | 小于< | X |
| __eq__ | 等于= | X=Y |
减法重载
重载"-" 不同对象的减法处理
class Number:
def __init__(self,start):
self.data=start
def __sub__(self,other):
return Number(self.data-other)
number=Number(20)
y=number-10
print number.data, y.data
重载"-" 相同对象的减法处理
class Big :
def __init__(self,a,b):
self.a=a
self.b=b
def __sub__(self,other):#other不用事先制定类型,可以直接当做一个Big来用
return Big(self.a-other.a,self.b-other.b)
i=Big(20,12);
j=Big(23,4);
k=i-j;
print k.a ,k.b
重载"+"
class AddOperator :
def __init__(self,a,b):
self.a=a
self.b=b
def __add__(self,other):#other不用事先制定类型,可以直接当做一个Big来用
return Big(self.a+other.a,self.b+other.b)
i=AddOperator(20,12);
j=AddOperator(23,4);
k=i+j;
print k.a ,k.b
重载"+="
class AddOperator :
def __init__(self,a,b):
self.a=a
self.b=b
def __iadd__(self,other):#other不用事先制定类型,可以直接当做一个Big来用
return Big(self.a+other.a,self.b+other.b)
i=AddOperator(20,12);
j=AddOperator(23,4);
i+=j;
print i.a ,i.b
重载乘法
不同对象的乘法：
class MulOperator:
def __init__(self,a,b):
self.a=a
self.b=b
def __mul__(self,n):
return MulOperator(self.a*n,self.b*n)
i=MulOperator(20,5)
j=i*4.5
print j.a,j.b
重载乘法：两个对象的相乘似乎也有用，如矩阵的相乘，3D中几个变换矩阵的相乘。
两个4*4矩阵相乘
矩阵 的列数必须等于矩阵 的行数，矩阵 与矩阵 才能相乘，第一个矩阵由4个横向排列的四维向量组成，第二个矩阵由4个纵向排列的四维向量组成，
class Vector4:
def __init__(self,a,b,c,d):
(self.a1,self.a2,self.a3,self.a4)=(a,b,c,d)
def __mul__(self,other):
return (self.a1*other.a1+self.a2*other.a2+self.a3*other.a3+self.a4*other.a4)
def PrintVector(self):
print self.a1,self.a2,self.a3,self.a4
class Matrix :
def __init__(self,a,b,c,d):
(self.a1,self.a2,self.a3,self.a4)=(a,b,c,d)
#(self.a1,self.a2,self.a3,self.a4)=(a,b,c,d)
def __mul__(self,other):
x1=Vector4(other.a1.a1,other.a2.a1,other.a3.a1,other.a4.a1)
x2=Vector4(other.a1.a2,other.a2.a2,other.a3.a2,other.a4.a2)
x3=Vector4(other.a1.a3,other.a2.a3,other.a3.a3,other.a4.a3)
x4=Vector4(other.a1.a4,other.a2.a4,other.a3.a4,other.a4.a4)
a=Vector4(self.a1*x1,self.a1*x2,self.a1*x3,self.a1*x4)
b=Vector4(self.a2*x1,self.a2*x2,self.a2*x3,self.a2*x4)
c=Vector4(self.a3*x1,self.a3*x2,self.a3*x3,self.a3*x4)
d=Vector4(self.a4*x1,self.a4*x2,self.a4*x3,self.a4*x4)
return Matrix(a,b,c,d)
def PrintMatrix(self):
self.a1.PrintVector()
self.a2.PrintVector()
self.a3.PrintVector()
self.a4.PrintVector()
i1=Vector4(1,4,1,4)
i2=Vector4(2,1,6,7)
k=i1*i2
#测试向量点乘
print k
i3=Vector4(1,1,1,1)
i4=Vector4(1,2,4,5)
j1=Vector4(1,2,3,4)
j2=Vector4(2,1,1,1)
j3=Vector4(1,3,21,2)
j4=Vector4(2,4,3,7)
a=Matrix(i1,i2,i3,i4)
b=Matrix(j1,j2,j3,j4)
c=a*b
c.PrintMatrix()
索引重载
class indexer:
def __getitem__(self, index): #iter override
return index ** 2
X = indexer()
X[2]
for i in range(5):
print X[i]
class indexer:
def __setitem__(self, key,value): #iter override
self.mydict[key] = value
return self.mydict
X = indexer()
X[2] = 'test' 它等于调用 X.__setitem__(2, 'test')
打印重载
class adder :
def __init__(self,value=0):
self.data=value
def __add__(self,other):
self.data+=other
class addrepr(adder):
def __repr__(self):
return "addrepr(%d)"% self.data #%d ,%s都可以
x=addrepr(2)
x+1
print x ,repr(x)
i=3;
print "%s---%d"% (i, i)
调用重载，__call__相当与 X()
class Prod:
def __init__(self, value):
self.value = value
def __call__(self, other):
return self.value * other
p = Prod(2) #call __init__
print p(1) #call __call__
print p(2)
析构重载 __del__
class Life:
def __init__(self, name='name'):
print 'Hello', name
self.name = name
def __del__(self):
print 'Goodby', self.name
brain = Life('Brain') #call __init__
brain = 'loretta' # call __del__
重载"|"
class Mat :
def __init__(self,value):
self.age=value
def __or__(self,other):
return self.age!=0 and other.age!=0
a=Mat(10)
b=Mat(21)
c=Mat(0)
print a|b ,a|c
打印转换重载
class PrintOperator:
def __init__(self,a):
self.a=a
def __str__(self,b=50):
return "I am %s years old!" % self.a
i=PrintOperator(10)
print i, str(i)
长度重载
class lenOperator:
def __init__(self,a,b,c):
(self.a,self.b,self.c)=(a,b,c)
def __len__(self):
return 3
a=lenOperator(0,2,4)
print len(a)
cmp重载
class cmpOperator:
def __init__(self,a,b,c):
(self.a,self.b,self.c)=(a,b,c)
def __cmp__(self,other):
if self.a>other.a:
return 1
elif self.aother.b:
return 1
elif self.bself.c:
return 1
elif self.c
delattr重载
class delattrOperator(object):
def __init__(self,a,b):
(self.a,self.b)=(a,b)
def __delattr__(self,name):
print "del obj.%s" % name
object.__delattr__(self,name)
a=delattrOperator(1,2)
print a.a,a.b
del a.a
print a.b
#print a.a 打印a会出错，a已经被删除。
getAttr/setAttr重载
class empty:
def __getattr__(self,attrname):
if attrname == 'age':
return 40
else:
raise AttributeError,attrname
X = empty()
print X.age #call__getattr__
class accesscontrol:
def __setattr__(self, attr, value):
if attr == 'age':
# Self.attrname = value loops!
self.__dict__[attr] = value
else:
print attr
raise AttributeError, attr + 'not allowed'
X = accesscontrol()
X.age = 40 #call __setattr__
X.name = 'wang' #raise exception