Python运算符重载详解及实例代码

Python运算符重载

  Python语言提供了运算符重载功能，增强了语言的灵活性，这一点与C++有点类似又有些不同。鉴于它的特殊性，今天就来讨论一下Python运算符重载。

  Python语言本身提供了很多魔法方法，它的运算符重载就是通过重写这些Python内置魔法方法实现的。这些魔法方法都是以双下划线开头和结尾的，类似于__X__的形式，python通过这种特殊的命名方式来拦截操作符，以实现重载。当Python的内置操作运用于类对象时，Python会去搜索并调用对象中指定的方法完成操作。

   类可以重载加减运算、打印、函数调用、索引等内置运算，运算符重载使我们的对象的行为与内置对象的一样。Python在调用操作符时会自动调用这样的方法，例如，如果类实现了__add__方法，当类的对象出现在+运算符中时会调用这个方法。  

常见运算符重载方法

方法名

重载说明

运算符调用方式

init

构造函数

对象创建: X = Class(args)

del

析构函数

X对象收回

add/sub

加减运算

X+Y， X+=Y/X-Y， X-=Y

or

运算符|

X|Y, X|=Y

_repr／str__

打印／转换

print(X)、repr(X)／str(X)

call

函数调用

X(*args, **kwargs)

getattr

属性引用

X.undefined

setattr

属性赋值

X.any=value

delattr

属性删除

del X.any

getattribute

属性获取

X.any

getitem

索引运算

X[key]，X[i:j]

setitem

索引赋值

X[key]，X[i:j]=sequence

delitem

索引和分片删除

del X[key]，del X[i:j]

len

长度

len(X)

bool

布尔测试

bool(X)

lt, gt,

le, ge,

eq, ne

特定的比较

依次为X<Y，X>Y，X<=Y，X>=Y，

X==Y，X!=Y

注释：（lt: less than, gt: greater than,

le: less equal, ge: greater equal,

eq: equal, ne: not equal

）

radd

右侧加法

other+X

iadd

实地（增强的）加法

X+=Y(or else add)

iter, next

迭代

I=iter(X), next()

contains

成员关系测试

item in X(X为任何可迭代对象)

index

整数值

hex(X), bin(X), oct(X)

enter, exit

环境管理器

with obj as var:

get, set,

delete

描述符属性

X.attr, X.attr=value, del X.attr

new

创建

在init之前创建对象

下面对常用的运算符方法的使用进行一下介绍。

构造函数和析构函数：init和del

   它们的主要作用是进行对象的创建和回收，当实例创建时，就会调用__init__构造方法。当实例对象被收回时，析构函数__del__会自动执行。  

    >>> class Human(): 
    ...   def __init__(self, n): 
    ...     self.name = n 
    ...       print("__init__ ",self.name) 
    ...   def __del__(self): 
    ...     print("__del__") 
    ...  
    >>> h = Human('Tim') 
    __init__ Tim 
    >>> h = 'a' 
    __del__ 

加减运算：add和sub

   重载这两个方法就可以在普通的对象上添加＋－运算符操作。下面的代码演示了如何使用＋－运算符，如果将代码中的__sub__方法去掉，再调用减号运算符就会出错。  

    >>> class Computation(): 
    ...   def __init__(self,value): 
    ...     self.value = value 
    ...   def __add__(self,other): 
    ...     return self.value + other 
    ...   def __sub__(self,other): 
    ...     return self.value - other 
    ...  
    >>> c = Computation(5) 
    >>> c + 5 
    10 
    >>> c - 3 
    2 

对象的字符串表达形式：repr和str

   这两个方法都是用来表示对象的字符串表达形式：print()、str()方法会调用到__str__方法，print()、str()和repr()方法会调用__repr__方法。从下面的例子可以看出，当两个方法同时定义时，Python会优先搜索并调用__str__方法。

    >>> class Str(object): 
    ...   def __str__(self): 
    ...     return "__str__ called"   
    ...   def __repr__(self): 
    ...     return "__repr__ called" 
    ...  
    >>> s = Str() 
    >>> print(s) 
    __str__ called 
    >>> repr(s) 
    '__repr__ called' 
    >>> str(s) 
    '__str__ called' 

索引取值和赋值：getitem, setitem

   通过实现这两个方法，可以通过诸如 X[i] 的形式对对象进行取值和赋值，还可以对对象使用切片操作。  

    >>> class Indexer: 
      data = [1,2,3,4,5,6] 
      def __getitem__(self,index): 
        return self.data[index] 
      def __setitem__(self,k,v): 
        self.data[k] = v 
        print(self.data) 
    >>> i = Indexer() 
    >>> i[0] 
    1 
    >>> i[1:4] 
    [2, 3, 4] 
    >>> i[0]=10 
    [10, 2, 3, 4, 5, 6] 

设置和访问属性：getattr、setattr

   我们可以通过重载__getattr__和__setattr__来拦截对对象成员的访问。__getattr__在访问对象中不存在的成员时会自动调用。__setattr__方法用于在初始化对象成员的时候调用，即在设置__dict__的item时就会调用__setattr__方法。具体例子如下：  

    class A(): 
      def __init__(self,ax,bx): 
        self.a = ax 
        self.b = bx 
      def f(self): 
        print (self.__dict__) 
      def __getattr__(self,name): 
        print ("__getattr__") 
      def __setattr__(self,name,value): 
        print ("__setattr__") 
        self.__dict__[name] = value 

    a = A(1,2) 
    a.f() 
    a.x 
    a.x = 3 
    a.f() 

 上面代码的运行结果如下，从结果可以看出，访问不存在的变量x时会调用__getattr__方法；当__init__被调用的时候，赋值运算也会调用__setattr__方法。

    __setattr__ 
    __setattr__ 
    {'a': 1, 'b': 2} 
    __getattr__ 
    __setattr__ 
    {'a': 1, 'x': 3, 'b': 2} 

迭代器对象: iter, next

   Python中的迭代，可以直接通过重载__getitem__方法来实现，看下面的例子。  

    >>> class Indexer: 
    ...   data = [1,2,3,4,5,6] 
    ...   def __getitem__(self,index): 
    ...       return self.data[index] 
    ...  
    >>> x = Indexer() 
    >>> for item in x: 
    ...   print(item) 
    ...  
    1 
    2 
    3 
    4 
    5 
    6 

  通过上面的方法是可以实现迭代，但并不是最好的方式。Python的迭代操作会优先尝试调用__iter__方法，再尝试__getitem__。迭代环境是通过iter去尝试寻找__iter__方法来实现，而这种方法返回一个迭代器对象。如果这个方法已经提供，Python会重复调用迭代器对象的next()方法，直到发生StopIteration异常。如果没有找到__iter__，Python才会尝试使用__getitem__机制。下面看一下迭代器的例子。  

    class Next(object): 
      def __init__(self, data=1): 
        self.data = data 
      def __iter__(self): 
        return self 
      def __next__(self): 
        print("__next__ called") 
        if self.data > 5: 
          raise StopIteration 
        else: 
          self.data += 1 
          return self.data 
    for i in Next(3): 
      print(i) 
    print("-----------") 
    n = Next(3) 
    i = iter(n) 
    while True: 
      try: 
        print(next(i)) 
      except Exception as e: 
        break 

程序的运行结果如下：

    __next__ called 
    4 
    __next__ called 
    5 
    __next__ called 
    6 
    __next__ called 
    ----------- 
    __next__ called 
    4 
    __next__ called 
    5 
    __next__ called 
    6 
    __next__ called 

可见实现了__iter__和__next__方法后，可以通过for in的方式迭代遍历对象，也可以通过iter()和next()方法迭代遍历对象。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！