[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<Y
__lt__	小于<	X<Y
__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.a<other.a:
           return -1
        elif self.b>other.b:
           return 1
        elif self.b<other.b:
            return -1
        elif self.c>self.c:
            return 1
        elif self.c<self.c:
            return -1
        elif self.c==self.c:
           return 0    
i=cmpOperator(1,2,3)
j=cmpOperator(2,4,5)
k=cmpOperator(2,4,5)
a=cmpOperator(1,4,5)
print cmp(i,j),cmp(j,k),cmp(a,i)

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