Python的运算符重载 iter()和 next()

最新推荐文章于 2025-11-05 17:14:57 发布

转载最新推荐文章于 2025-11-05 17:14:57 发布 · 2.9k 阅读

文章标签：

#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__会自动执行。

[python]view plain copy 
   
 >>> 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__方法去掉，再调用减号运算符就会出错。

[python]view plain copy 
   
 >>> 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__方法。

[python]view plain copy 
   
 >>> 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] 的形式对对象进行取值和赋值，还可以对对象使用切片操作。

[python]view plain copy 
   
 >>> 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__方法。具体例子如下：

[python]view plain copy 
   
 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__方法。

[python]view plain copy 
   
 __setattr__  
 __setattr__  
 {'a': 1, 'b': 2}  
 __getattr__  
 __setattr__  
 {'a': 1, 'x': 3, 'b': 2}  

迭代器对象: __iter__, __next__

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

[python]view plain copy 
   
 >>> 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__机制。下面看一下迭代器的例子。

[python]view plain copy 
   
 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  

程序的运行结果如下：

[python]view plain copy 
   
 __next__ called  
 4  
 __next__ called  
 5  
 __next__ called  
 6  
 __next__ called  
 -----------  
 __next__ called  
 4  
 __next__ called  
 5  
 __next__ called  
 6  
 __next__ called  