Python运算符重载方法重载

深碍√TFBOYSˉ_ 2022-03-15 05:42 309阅读 0赞

<table> 
 <thead> 
  <tr> 
   <th>Python运算符重载</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>重载</th> 
   <th>何时调用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>__init __</td> 
   <td>构造函数</td> 
   <td>X=Class()</td> 
  </tr> 
  <tr> 
   <td>__del __</td> 
   <td>析构函数</td> 
   <td>对象销毁</td> 
  </tr> 
  <tr> 
   <td>__repr __</td> 
   <td>打印转换</td> 
   <td>print X，repr(X)</td> 
  </tr> 
  <tr> 
   <td>__str __</td> 
   <td>打印转换</td> 
   <td>print X，str(X)</td> 
  </tr> 
  <tr> 
   <td>__call __</td> 
   <td>调用函数</td> 
   <td>X()</td> 
  </tr> 
  <tr> 
   <td>__getattr __</td> 
   <td>限制</td> 
   <td>X.undefine</td> 
  </tr> 
  <tr> 
   <td>__setattr __</td> 
   <td>取值</td> 
   <td>X.any=value</td> 
  </tr> 
  <tr> 
   <td>__getitem __</td> 
   <td>索引</td> 
   <td>X[key]，For If</td> 
  </tr> 
  <tr> 
   <td>__setitem __</td> 
   <td>索引</td> 
   <td>X[key]=value</td> 
  </tr> 
  <tr> 
   <td>__len __</td> 
   <td>长度</td> 
   <td>len(X)</td> 
  </tr> 
  <tr> 
   <td>__iter __</td> 
   <td>迭代</td> 
   <td>For In</td> 
  </tr> 
  <tr> 
   <td>__add __</td> 
   <td>+</td> 
   <td>X+Y,X+=Y</td> 
  </tr> 
  <tr> 
   <td>__sub __</td> 
   <td>-</td> 
   <td>X-Y,X-=Y</td> 
  </tr> 
  <tr> 
   <td>__mul __</td> 
   <td>*</td> 
   <td>X*Y</td> 
  </tr> 
  <tr> 
   <td>__radd __</td> 
   <td>右加+</td> 
   <td>+X</td> 
  </tr> 
  <tr> 
   <td>__iadd __</td> 
   <td>+=</td> 
   <td>X+=Y</td> 
  </tr> 
  <tr> 
   <td>__or __</td> 
   <td><code>X|Y</code></td> 
   <td><code>X|=Y</code></td> 
  </tr> 
  <tr> 
   <td>__cmp __</td> 
   <td>比较 ==</td> 
   <td>X==Y,X&lt;Y</td> 
  </tr> 
  <tr> 
   <td>__lt __</td> 
   <td>小于&lt;</td> 
   <td>X&lt;Y</td> 
  </tr> 
  <tr> 
   <td>__eq __</td> 
   <td>等于=</td> 
   <td>X=Y</td> 
  </tr> 
 </tbody> 
</table>

**减法重载**

重载"-" 不同对象的减法处理

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