Python面向对象运算符重载

Posted 2020-09-14

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python面向对象运算符重载相关的知识，希望对你有一定的参考价值。

运算符重载的概念如下：

运算符重载让类拦截常规的Python运算；
类可重载所有Python表达式运算符；
类也可重载打印、函数调用、属性点号运算等内置运算；
重载是类实例的行为想内置类型；
重载是通过提供特殊名称的类方法来实现的；

常见的运算符重载方法

方法	重载	调用
__init__	构造函数	对象建立：X = Class(args)
__del__	解析函数	X对象收回
__add__	运算符+	如果没有__iadd__,X+Y,X+=Y
__or__	运算符或	如果没有__ior__
__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]，没__iter__时的for循环和其他迭代器
__setitem__	索引赋值语句	X[key]=value,X[i:k]=sequence
__delitem__	索引和分片删除	del X[key], del X[i:j]
__len__	长度	len(X)，如果没有__bool__，真值测试
__bool__	布尔测试	bool(X)，真测试
__lt__，__gt__，__le__，__ge__，__eq__，__ne__	特定的比较	XY…，x>
__radd__	右侧加法	Other + X
__iadd__	增强的加法	X += Y
__iter__，__next__	迭代环境	I=iter(X),next(I)
__contains__	成员关系测试	item in X(任何可迭代对象)
__index__	整数值	hex(X),bin(X),oct(X),o[X],O[X:]
__enter__,__exit__	环境管理器	with obj as var:
__get__,__set__,__delete__	描述符属性	X.attr，X.attr=Value,del X.attr
__new__	创建	在__init__之前创建对象

所有重载方法的名称前后都有两个下划线字符，以便把同类中定义的变量名区别开来。

构造函数和表达式:init和sub

>>> class Number:
... def __init__(self, start):
... self.data = start
... def __sub__(self, other):
... return Number(self.data - other)
...
>>> X = Number(5)
>>> Y = X - 2
>>> Y
<__main__.Number object at 0x10224d550>
>>> Y.data
3

索引和分片: getitem和setitem

基本索引

>>> class Index:
... def __getitem__(self, item):
... return item ** 2
...
>>>
>>> for i in range(5):
... I = Index()
... print(I[i], end=‘ ‘)
...
0 1 4 9 16

切片索引

>>> class Index:
... data = [5, 6, 7, 8, 9]
... def __getitem__(self, item):
... print(‘getitem: ‘, item)
... return self.data[item]
... def __setitem__(self, key, value):
... self.data[key] = value
...
>>> X = Index()
>>> print(X[1:4])
getitem: slice(1, 4, None)
[6, 7, 8]
>>> X[1:4] = (1, 1, 1)
>>> print(X[1:4])
getitem: slice(1, 4, None)
[1, 1, 1]

索引迭代：getitem

如果重载了这个方法，for循环每次循环时都会调用类的getitem方法；

>>> class stepper:
... def __getitem__(self, item):
... return self.data[item].upper()
...
>>>
>>> X = stepper()
>>> X.data = ‘ansheng‘
>>> for item in X:
... print(item)
...
A
N
S
H
E
N
G

迭代器对象：iter和next

>>> class Squares:
... def __init__(self, start, stop):
... self.value = start - 1
... self.stop = stop
... def __iter__(self):
... return self
... def __next__(self):
... if self.value == self.stop:
... raise StopIteration
... self.value += 1
... return self.value ** 2
...
>>> for i in Squares(1, 5):
... print(i)
...
1
4
9
16
25

成员关系：contains、iter和getitem

class Iters:
def __init__(self, value):
self.data = value
def __getitem__(self, item):
print(‘get[%s]‘ % item, end=‘‘)
return self.data[item]
def __iter__(self):
print(‘iter>==‘, end=‘‘)
self.ix = 0
return self
def __next__(self):
print(‘next:‘, end=‘‘)
if self.ix == len(self.data): raise StopIteration
item = self.data[self.ix]
self.ix += 1
return item
def __contains__(self, item):
print(‘contains: ‘, end=‘ ‘)
return item in self.data
X = Iters([1, 2, 3, 4, 5])
print(3 in X)
for i in X:
print(i, end=‘|‘)
print([i ** 2 for i in X])
print(list(map(bin, X)))
I = iter(X)
while True:
try:
print(next(I), end=‘ @‘)
except StopIteration as e:
break

属性引用：getattr和setattr

当通过未定义的属性名称和实例通过点号进行访问时，就会用属性名称作为字符串调用这个方法，但如果类使用了继承，并且在超类中可以找到这个属性，那么就不会触发。

>>> class empty:
... def __getattr__(self, item):
... if item == ‘age‘:
... return 40
... else:
... raise AttributeError(item)
...
>>>
>>> x = empty()
>>> print(x.age)
40
>>> print(x.name)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 6, in __getattr__
AttributeError: name

>>> class accesscontrol:
... def __setattr__(self, key, value):
... if key == ‘age‘:
... self.__dict__[key] = value
... else:
... raise AttributeError(key + ‘ not allowed‘)
...
>>>
>>> x = accesscontrol()
>>> x.age = 40
>>> print(x.age)
40
>>> x.name = ‘Hello‘
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 6, in __setattr__
AttributeError: name not allowed

repr和str会返回字符串表达式

__repr__和__str__都是为了更友好的显示，具体来说，如果在终端下print(Class)则会调用__repr__，非终端下会调用__str__方法，且这两个方法只能返回字符串；

class adder:
def __init__(self, value=0):
self.data = value
def __add__(self, other):
self.data += other
def __repr__(self):
return ‘addrepr(%s)‘ % self.data
def __str__(self):
return ‘N: %s‘ % self.data
x = adder(2)
x + 1
print(x)
print((str(x), repr(x)))

右侧加法和原处加法: radd和iadd

只有当+右侧的对象是类实例，而左边对象不是类实例的时候，Python才会调用__radd__

class Commuter:
def __init__(self, val):
self.val = val
def __add__(self, other):
print(‘add‘, self.val, other)
return self.val + other
def __radd__(self, other):
print(‘radd‘, self.val, other)
return other + self.val
x = Commuter(88)
y = Commuter(99)
print(x + 1)
print(‘‘)
print(1 + y)
print(‘‘)
print(x + y)

使用__iadd__进行原处加法

class Number:
def __init__(self, val):
self.val = val
def __iadd__(self, other):
self.val += other
return self
x = Number(5)
x += 1
x += 1
print(x.val)
class Number:
def __init__(self, val):
self.val = val
def __add__(self, other):
return Number(self.val + other)
x = Number(5)
x += 1
x += 1
print(x.val)

Call表达式：call

当调用类实例时执行__call__方法

class Callee:
def __call__(self, *args, **kwargs):
print(‘Callee:‘, args, kwargs)
C = Callee()
C(1, 2, 3)
C(1, 2, 3, x=1, y=2, z=3)
class Prod:
def __init__(self, value):
self.value = value
def __call__(self, other):
return self.value * other
x = Prod(3)
print(x(3))
print(x(4))

比较:lt,gt和其他方法

类可以定义方法来捕获所有的6种比较运算符：<、>、<=、>=、==和!=

class C:
data = ‘spam‘
def __gt__(self, other):
return self.data > other
def __lt__(self, other):
return self.data < other
x = C()
print(x > ‘han‘)
print(x < ‘han‘)

布尔值测试：bool和len

class Truth:
def __bool__(self):
return True
X = Truth()
if X: print(‘yes‘)
class Truth:
def __bool__(self):
return False
X = Truth()
print(bool(X))

如果没有这个方法，Python退而求其次的求长度，因为一个非空对象看作是真:

>>> class Truth:
... def __len__(self): return 0
...
>>> X = Truth()
>>> if not X: print(‘no‘)
...
no

如果两个方法都有，__bool__会胜过__len__：

>>> class Truth:
... def __bool__(self): return True
... def __len__(self): return 0
...
>>> X = Truth()
>>> bool(X)
True

如果两个方法都没有定义，对象毫无疑义的看作为真：

>>> class Truth: pass
...
>>> bool(Truth)
True

对象解析函数：del

每当实例产生时，就会调用init构造函数，每当实例空间被收回时，它的对立面__del__，也就是解析函数，就会自动执行；

class Life:
def __init__(self, name=‘unknown‘):
print(‘Hello, ‘, name)
self.name = name
def __del__(self):
print(‘Goodbye‘, self.name)
brian = Life(‘Brian‘)
brian = ‘loretta‘

本文出自 “一盏烛光” 博客，谢绝转载！

以上是关于Python面向对象运算符重载的主要内容，如果未能解决你的问题，请参考以下文章

7Python全栈之路系列之面向对象运算符重载

Python面向对象之运算符重载

Python面向对象编程第16篇运算符重载

Python入门-6面向对象编程：10特殊方法和运算符重载-特殊属性

面向对象程序设计-C++_课时30运算符重载——基本规则_课时31运算符重载——原型_课时32运算符重载——赋值_课时33运算符重载——类型转换

Python面向对象运算符重载

常见的运算符重载方法

构造函数和表达式:__init__和__sub__

索引和分片: __getitem__和__setitem__

索引迭代：__getitem__

迭代器对象：__iter__和__next__

成员关系：__contains__、__iter__和__getitem__

属性引用：__getattr__和__setattr__

__repr__和__str__会返回字符串表达式

右侧加法和原处加法: __radd__和__iadd__

Call表达式：__call__

比较:__lt__,__gt__和其他方法