python 重载父类的方法 python 类重载

转载

mob64ca14144dde 2024-08-20 11:14:06

文章标签 python 重载父类的方法 python运算符重载运算符 scala Python 文章分类 Python 后端开发

有些事情让我不安，比如运算符重载。我决定不支持运算符重载，这完全是个人选择，因为我见过太多 C++ 程序员滥用它。

——James Gosling

Java 之父

运算符重载的作用是让用户定义的对象使用中缀运算符(如 + 和 |)或一元运算符(如 - 和 ~)。说得宽泛一些，在 Python 中，函数调用(())、属性访问(.)和元素访问 / 切片([])也是运算符。

我们为 Vector 类简略实现了几个运算符。__add__ 和 __mul__ 方法是为了展示如何使用特殊方法重载运算符，不过有些小问题被我们忽视了。此外，我们定义的Vector2d.__eq__ 方法认为 Vector(3, 4) == [3, 4] 是真的(True)，这可能并不合理。

运算符重载基础

在某些圈子中，运算符重载的名声并不好。这个语言特性可能(已经)被滥用，让程序员困惑，导致缺陷和意料之外的性能瓶颈。但是，如果使用得当，API 会变得好用，代码会变得易于阅读。Python 施加了一些限制，做好了灵活性、可用性和安全性方面的平衡：

不能重载内置类型的运算符

不能新建运算符，只能重载现有的

某些运算符不能重载——is、and、or 和 not(不过位运算符

&、| 和 ~ 可以)

前面的博文已经为 Vector 定义了一个中缀运算符，即 ==，这个运算符由__eq__ 方法支持。我们将改进 __eq__ 方法的实现，更好地处理不是Vector 实例的操作数。然而，在运算符重载方面，众多比较运算符(==、!=、>、=、<=)是特例，因此我们首先将在 Vector 中重载四个算术运算符：一元运算符 - 和 +，以及中缀运算符 + 和 *。

一元运算符

-(__neg__)

一元取负算术运算符。如果 x 是 -2，那么 -x == 2。

+(__pos__)

一元取正算术运算符。通常，x == +x，但也有一些例外。如果好奇，请阅读“x 和 +x 何时不相等”附注栏。

~(__invert__)

对整数按位取反，定义为 ~x == -(x+1)。如果 x 是 2，那么 ~x== -3。

支持一元运算符很简单，只需实现相应的特殊方法。这些特殊方法只有一个参数，self。然后，使用符合所在类的逻辑实现。不过，要遵守运算符的一个基本规则：始终返回一个新对象。也就是说，不能修改self，要创建并返回合适类型的新实例。

对 - 和 + 来说，结果可能是与 self 同属一类的实例。多数时候，+ 最好返回 self 的副本。abs(...) 的结果应该是一个标量。但是对 ~ 来说，很难说什么结果是合理的，因为可能不是处理整数的位，例如在ORM 中，SQL WHERE 子句应该返回反集。

1 def __abs__(self):2 return math.sqrt(sum(x * x for x inself))3

4 def __neg__(self):5 return Vector(-x for x in self) #为了计算 -v，构建一个新 Vector 实例，把 self 的每个分量都取反

7 def __pos__(self):8 return Vector(self) #为了计算 +v，构建一个新 Vector 实例，传入 self 的各个分量

x 和 +x 何时不相等

每个人都觉得 x == +x，而且在 Python 中，几乎所有情况下都是这样。但是，我在标准库中找到两例 x != +x 的情况。

第一例与 decimal.Decimal 类有关。如果 x 是 Decimal 实例，在算术运算的上下文中创建，然后在不同的上下文中计算 +x，那么 x!= +x。例如，x 所在的上下文使用某个精度，而计算 +x 时，精度变了，例如下面的 🌰

算术运算上下文的精度变化可能导致 x 不等于 +x

>>> importdecimal>>> ctx =decimal.getcontext()　　　　　　　　　　　　　　　　　　#获取当前全局算术运算符的上下文引用>>> ctx.prec = 40　　　　　　　　　　　　　　　　　　　　　　　　　 #把算术运算上下文的精度设为40

>>> one_third = decimal.Decimal('1') / decimal.Decimal('3') #使用当前精度计算1/3>>>one_third

Decimal('0.3333333333333333333333333333333333333333')　　　　 #查看结果，小数点后的40个数字>>> one_third == +one_third　　　　　　　　　　　　　　　　　　　　#one_third = +one_thied返回TRUE

True>>> ctx.prec = 28　　　　　　　　　　　　　　　　　　　　　　　　　　#把精度降为28

>>> one_third == +one_third#one_third = +one_thied返回False

False>>> +one_third Decimal('0.3333333333333333333333333333')　　 #查看+one_third,小术后的28位数字

虽然每个 +one_third 表达式都会使用 one_third 的值创建一个新 Decimal 实例，但是会使用当前算术运算上下文的精度。

x != +x 的第二例在 collections.Counter 的文档中(https://docs.python.org/3/library/collections.html#collections.Counter)。类实现了几个算术运算符，例如中缀运算符 +，作用是把两个Counter 实例的计数器加在一起。然而，从实用角度出发，Counter 相加时，负值和零值计数会从结果中剔除。而一元运算符 + 等同于加上一个空 Counter，因此它产生一个新的Counter 且仅保留大于零的计数器。

🌰一元运算符 + 得到一个新 Counter 实例，但是没有零值和负值计数器

>>> from collections importCounter>>> ct = Counter('abracadabra')>>> ct['r'] = -3

>>> ct['d'] =0>>>ct

Counter({'a': 5, 'r': -3, 'b': 2, 'c': 1, 'd': 0})>>> +ct

Counter({'a': 5, 'b': 2, 'c': 1})

重载向量加法运算符+

两个欧几里得向量加在一起得到的是一个新向量，它的各个分量是两个向量中相应的分量之和。比如说：

>>> v1 = Vector([3, 4, 5])>>> v2 = Vector([6, 7, 8])>>> v1 +v2

Vector([9.0, 11.0, 13.0])>>> v1 + v2 == Vector([3+6, 4+7, 5+8])

True

确定这些基本的要求之后，__add__ 方法的实现短小精悍,🌰 如下

def __add__(self, other):

pairs= itertools.zip_longest(self, other, fillvalue=0.0) #生成一个元祖，a来自self,b来自other,如果两个长度不够，通过fillvalue设置的补全值自动补全短的

return Vector(a + b for a, b in pairs) #使用生成器表达式计算pairs中的各个元素的和

还可以把Vector 加到元组或任何生成数字的可迭代对象上:

1 #在Vector类中定义

3 def __add__(self, other):4 pairs = itertools.zip_longest(self, other, fillvalue=0.0) #生成一个元祖，a来自self,b来自other,如果两个长度不够，通过fillvalue设置的补全值自动补全短的

5 return Vector(a + b for a, b in pairs) #使用生成器表达式计算pairs中的各个元素的和

7 def __radd__(self, other): #会直接委托给__add__

8 return self + other

__radd__ 通常就这么简单：直接调用适当的运算符，在这里就是委托__add__。任何可交换的运算符都能这么做。处理数字和向量时，+ 可以交换，但是拼接序列时不行。

重载标量乘法运算符*

Vector([1, 2, 3]) * x 是什么意思？如果 x 是数字，就是计算标量积(scalar product)，结果是一个新 Vector 实例，各个分量都会乘以x——这也叫元素级乘法(elementwise multiplication)。

>>> v1 = Vector([1, 2, 3])>>> v1 * 10Vector([10.0, 20.0, 30.0])>>> 11 *v1

Vector([11.0, 22.0, 33.0])

涉及 Vector 操作数的积还有一种，叫两个向量的点积(dotproduct)；如果把一个向量看作 1×N 矩阵，把另一个向量看作 N×1 矩阵，那么就是矩阵乘法。NumPy 等库目前的做法是，不重载这两种意义的 *，只用 * 计算标量积。例如，在 NumPy 中，点积使用numpy.dot() 函数计算。

回到标量积的话题。我们依然先实现最简可用的 __mul__ 和 __rmul__方法：

1 def __mul__(self, scalar):2 ifisinstance(scalar, numbers.Real):3 return Vector(n * scalar for n inself)4 else:5 returnNotImplemented6

7 def __rmul__(self, scalar):8 return self * scalar

这两个方法确实可用，但是提供不兼容的操作数时会出问题。scalar参数的值要是数字，与浮点数相乘得到的积是另一个浮点数(因为Vector 类在内部使用浮点数数组)。因此，不能使用复数，但可以是int、bool(int 的子类)，甚至 fractions.Fraction 实例等标量。

提供了点积所需的 @ 记号(例如，a @ b 是 a 和 b 的点积)。@ 运算符由特殊方法 __matmul__、__rmatmul__ 和__imatmul__ 提供支持，名称取自“matrix multiplication”(矩阵乘法)

>>> va = Vector([1, 2, 3])>>> vz = Vector([5, 6, 7])>>> va @ vz == 38.0 #1*5 + 2*6 + 3*7

True>>> [10, 20, 30] @ vz380.0

>>> va @ 3Traceback (most recent call last):

...

TypeError: unsupported operand type(s)for @: 'Vector' and 'int'

下面是相应特殊方法的代码：

>>> va = Vector([1, 2, 3])>>> vz = Vector([5, 6, 7])>>> va @ vz == 38.0 #1*5 + 2*6 + 3*7

True>>> [10, 20, 30] @ vz380.0

>>> va @ 3Traceback (most recent call last):

...

TypeError: unsupported operand type(s)for @: 'Vector' and 'int'

众多比较运算符

Python 解释器对众多比较运算符(==、!=、>、=、<=)的处理与前文类似，不过在两个方面有重大区别。

正向和反向调用使用的是同一系列方法。例如，对 == 来说，正向和反向调用都是 __eq__ 方法，只是把参数对调了；而正向的 __gt__ 方法调用的是反向的 __lt__方法，并把参数对调。

对 == 和 != 来说，如果反向调用失败，Python 会比较对象的 ID，而不抛出 TypeError。

众多比较运算符：正向方法返回NotImplemented的话，调用反向方法

分组

中缀运算符

正向方法调用

反向方法调用

后备机制

相等性

a == b

a.__eq__(b)

b.__eq__(a)

返回 id(a) == id(b)

a != b

a.__ne__(b)

b.__ne__(a)

返回 not (a == b)

排序

a > b

a.__gt__(b)

b.__lt__(a)

抛出 TypeError

a < b

a.__lt__(b)

b.__gt__(a)

抛出 TypeError

a >= b

a.__ge__(b)

b.__le__(a)

抛出 TypeError

a <= b

a.__le__(b)

b.__ge__(a)

抛出T ypeError

看下面的🌰

1 from array importarray2 importreprlib3 importmath4 importnumbers5 importfunctools6 importoperator7 importitertools8

10 classVector:11 typecode = 'd'

13 def __init__(self, components):14 self._components =array(self.typecode, components)15

16 def __iter__(self):17 returniter(self._components)18

19 def __repr__(self):20 components =reprlib.repr(self._components)21 components = components[components.find('['):-1]22 return 'Vector({})'.format(components)23

24 def __str__(self):25 returnstr(tuple(self))26

27 def __bytes__(self):28 return (bytes([ord(self.typecode)]) +bytes(self._components))29

30 def __eq__(self, other):31 return (len(self) == len(other) and all(a == b for a, b inzip(self, other)))32

33 def __hash__(self):34 hashes =map(hash, self._components)35 returnfunctools.reduce(operator.xor, hashes, 0)36

37 def __add__(self, other):38 pairs = itertools.zip_longest(self, other, fillvalue=0.0) #生成一个元祖，a来自self,b来自other,如果两个长度不够，通过fillvalue设置的补全值自动补全短的

39 return Vector(a + b for a, b in pairs) #使用生成器表达式计算pairs中的各个元素的和

41 def __radd__(self, other): #会直接委托给__add__

42 return self +other43

44 def __mul__(self, scalar):45 ifisinstance(scalar, numbers.Real):46 return Vector(n * scalar for n inself)47 else:48 returnNotImplemented49

50 def __rmul__(self, scalar):51 return self *scalar52

53 def __matmul__(self, other):54 try:55 return sum(a * b for a, b inzip(self, other))56 exceptTypeError:57 returnNotImplemented58

59 def __rmatmul__(self, other):60 returnself @ other61

62 def __abs__(self):63 return math.sqrt(sum(x * x for x inself))64

65 def __neg__(self):66 return Vector(-x for x in self) #为了计算 -v，构建一个新 Vector 实例，把 self 的每个分量都取反

68 def __pos__(self):69 return Vector(self) #为了计算 +v，构建一个新 Vector 实例，传入 self 的各个分量

71 def __bool__(self):72 returnbool(abs(self))73

74 def __len__(self):75 returnlen(self._components)76

77 def __getitem__(self, index):78 cls =type(self)79

80 ifisinstance(index, slice):81 returncls(self._components[index])82 elifisinstance(index, numbers.Integral):83 returnself._components[index]84 else:85 msg = '{.__name__} indices must be integers'

86 raiseTypeError(msg.format(cls))87

88 shorcut_names = 'xyzt'

90 def __getattr__(self, name):91 cls =type(self)92

93 if len(name) == 1:94 pos =cls.shorcut_names.find(name)95 if 0 <= pos

98 raiseAttributeError(msg.format(cls, name))99

100 defangle(self, n):101 r = math.sqrt(sum(x * x for x inself[n:]))102 a = math.atan2(r, self[n-1])103 if (n == len(self) - 1 ) and (self[-1] <0):104 return math.pi * 2 -a105 else:106 returna107

108 defangles(self):109 return (self.angle(n) for n in range(1, len(self)))110

111 def __format__(self, fmt_spec=''):112 if fmt_spec.endswith('h'):113 fmt_spec = fmt_spec[:-1]114 coords =itertools.chain([abs(self)], self.angles())115 outer_fmt = ''

116 else:117 coords =self118 outer_fmt = '({})'

119 components = (format(c, fmt_spec) for c incoords)120 return outer_fmt.format(','.join(components))121

122 @classmethod123 deffrombytes(cls, octets):124 typecode =chr(octets[0])125 memv = memoryview(octets[1:]).cast(typecode)126 returncls(memv)127

128 va = Vector([1.0, 2.0, 3.0])129 vb = Vector(range(1, 4))130 print('va == vb:', va == vb) #两个具有相同数值分量的 Vector 实例是相等的

131 t3 = (1, 2, 3)132 print('va == t3:', va ==t3)133

134 print('[1, 2] == (1, 2):', [1, 2] == (1, 2))

上面代码执行返回的结果为：

va ==vb: True

va==t3: True

[1, 2] == (1, 2): False

从 Python 自身来找线索，我们发现 [1,2] == (1, 2) 的结果是False。因此，我们要保守一点，做些类型检查。如果第二个操作数是Vector 实例(或者 Vector 子类的实例)，那么就使用 __eq__ 方法的当前逻辑。否则，返回 NotImplemented，让 Python 处理。

🌰 vector_v8.py：改进 Vector 类的 __eq__ 方法

1 def __eq__(self, other):2 if isinstance(other, Vector): #判断对比的是否和Vector同属一个实例

3 return (len(self) == len(other) and all(a == b for a, b inzip(self, other)))4 else:5 return NotImplemented #否则，返回NotImplemented

改进以后的代码执行结果：

>>> va = Vector([1.0, 2.0, 3.0])>>> vb = Vector(range(1, 4))>>> va ==vb

True>>> t3 = (1, 2, 3)>>> va ==t3

False

增量赋值运算符

Vector 类已经支持增量赋值运算符 += 和 *= 了，示例如下

🌰 增量赋值不会修改不可变目标，而是新建实例，然后重新绑定

>>> v1 = Vector([1, 2, 3])>>> v1_alias = v1 　　　　　　　　　　　　#复制一份，供后面审查Vector([1, 2, 3])对象

>>> id(v1) 　　　　　　　　　　　　　　　　#　记住一开始绑定给v1的Vector实例的ID

4302860128

>>> v1 += Vector([4, 5, 6]) 　　　　　　#增量加法运算

>>> v1 　　　　　　　　　　　　　　　　　　 #结果与预期相符

Vector([5.0, 7.0, 9.0])>>> id(v1) 　　　　　　　　　　　　　　　　#但是创建了新的Vector实例

4302859904

>>> v1_alias 　　　　　　　　　　　　　　 #审查v1_alias，确认原来的Vector实例没被修改

Vector([1.0, 2.0, 3.0])>>> v1 *= 11 　　　　　　　　　　　　　　 #增量乘法运算

>>> v1 　　　　　　　　　　　　　　　　　　#同样，结果与预期相符，但是创建了新的Vector实例

Vector([55.0, 77.0, 99.0])>>>id(v1)4302858336

完整代码：

1 from array importarray2 importreprlib3 importmath4 importnumbers5 importfunctools6 importoperator7 importitertools8

10 classVector:11 typecode = 'd'

13 def __init__(self, components):14 self._components =array(self.typecode, components)15

16 def __iter__(self):17 returniter(self._components)18

19 def __repr__(self):20 components =reprlib.repr(self._components)21 components = components[components.find('['):-1]22 return 'Vector({})'.format(components)23

24 def __str__(self):25 returnstr(tuple(self))26

27 def __bytes__(self):28 return (bytes([ord(self.typecode)]) +bytes(self._components))29

30 def __eq__(self, other):31 ifisinstance(other, Vector):32 return (len(self) == len(other) and all(a == b for a, b inzip(self, other)))33 else:34 returnNotImplemented35

36 def __hash__(self):37 hashes =map(hash, self._components)38 returnfunctools.reduce(operator.xor, hashes, 0)39

40 def __add__(self, other):41 pairs = itertools.zip_longest(self, other, fillvalue=0.0)42 return Vector(a + b for a, b inpairs)43

44 def __radd__(self, other):45 return self +other46

47 def __mul__(self, scalar):48 ifisinstance(scalar, numbers.Real):49 return Vector(n * scalar for n inself)50 else:51 returnNotImplemented52

53 def __rmul__(self, scalar):54 return self *scalar55

56 def __matmul__(self, other):57 try:58 return sum(a * b for a, b inzip(self, other))59 exceptTypeError:60 returnNotImplemented61

62 def __rmatmul__(self, other):63 returnself @ other64

65 def __abs__(self):66 return math.sqrt(sum(x * x for x inself))67

68 def __neg__(self):69 return Vector(-x for x inself)70

71 def __pos__(self):72 returnVector(self)73

74 def __bool__(self):75 returnbool(abs(self))76

77 def __len__(self):78 returnlen(self._components)79

80 def __getitem__(self, index):81 cls =type(self)82

83 ifisinstance(index, slice):84 returncls(self._components[index])85 elifisinstance(index, numbers.Integral):86 returnself._components[index]87 else:88 msg = '{.__name__} indices must be integers'

89 raiseTypeError(msg.format(cls))90

91 shorcut_names = 'xyzt'

93 def __getattr__(self, name):94 cls =type(self)95

96 if len(name) == 1:97 pos =cls.shorcut_names.find(name)98 if 0 <= pos

101 raiseAttributeError(msg.format(cls, name))102

103 defangle(self, n):104 r = math.sqrt(sum(x * x for x inself[n:]))105 a = math.atan2(r, self[n-1])106 if (n == len(self) - 1 ) and (self[-1] <0):107 return math.pi * 2 -a108 else:109 returna110

111 defangles(self):112 return (self.angle(n) for n in range(1, len(self)))113

114 def __format__(self, fmt_spec=''):115 if fmt_spec.endswith('h'):116 fmt_spec = fmt_spec[:-1]117 coords =itertools.chain([abs(self)], self.angles())118 outer_fmt = ''

119 else:120 coords =self121 outer_fmt = '({})'

122 components = (format(c, fmt_spec) for c incoords)123 return outer_fmt.format(','.join(components))124

125 @classmethod126 deffrombytes(cls, octets):127 typecode =chr(octets[0])128 memv = memoryview(octets[1:]).cast(typecode)129 return cls(memv)

View Code

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。