这篇文章主要介绍了 Python 运算符重载详解及实例代码的相关资料, 需要的朋友可以参考下
Python 是一种面向对象、解释型计算机程序设计语言,由 Guido van Rossum 于 1989 年底发明,第一个公开发行版发行于 1991 年。Python 语法简洁而清晰,具有丰富和强大的类库。它常被昵称为胶水语言,它能够把用其他语言制作的各种模块(尤其是 C/C++)很轻松地联结在一起。
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() 方法迭代遍历对象。
来源: http://www.phperz.com/article/17/0315/326055.html