标签：__ return Python self 运算符 Vector components 重载 def

正确重载运算符

一元运算符

- (__neg__)
+ (__pos__) 最好返回 self 的副本
~ (__invert__) 对整数位按位取反 (~x == -(x+1))

print(~2)

-3

中辍运算符

`+`

from array import array
from itertools import zip_longest

class Vector:
    typecode = 'd'

    def __init__(self, components) -> None:
        self._componeents = array(self.typecode, components)

    def __iter__(self):
        return iter(self._componeents)

    def __neg__(self):
        return Vector(-x for x in self)

    def __pos__(self):
        return Vector(self)
    
    def __add__(self, other):
        pairs = zip_longest(self, other, fillvalue=0.0)
        return Vector(a + b for a, b in pairs)
    
    def __radd__(self, other):
        return self + other  # 直接委托给 __add__

Counter

collections.Count 计数器

from collections import Counter
ct = Counter('asfsdgasdasfasdgsd')

print(1, ct)
ct['s'] = -2
ct['g'] = 0
print(2, ct)
print(3, +ct)  # 会剔除无意义的 0 和负值

1 Counter({'s': 6, 'a': 4, 'd': 4, 'f': 2, 'g': 2})
2 Counter({'a': 4, 'd': 4, 'f': 2, 'g': 0, 's': -2})
3 Counter({'a': 4, 'd': 4, 'f': 2})

def __add__(self, other):
    try:
        pairs = zip_longest(self, other, fillvalue=0.0)
        return Vector(a + b for a, b in pairs)
    except TypeError:
        return NotImplemented
    
def __radd__(self, other):
    return self + other

`-`

from array import array
from itertools import zip_longest
import reprlib, numbers

class Vector:
    typecode = 'd'

    def __init__(self, components) -> None:
        self._componeents = array(self.typecode, components)

    def __repr__(self):
        components = reprlib.repr(self._componeents)  # array('d', [1, 2, 3, 4, ...])
        components = components[components.find('['):-1]  # [1, 2, 3, 4, ...]
        return 'Vector({})'.format(components)  # Vector([1, 2, 3, 4])

    def __iter__(self):
        return iter(self._componeents)

    def __mul__(self, scalar):
        if isinstance(scalar, numbers.Real):
            return Vector(n * scalar for n in self)
        else:
            return NotImplemented
    
    def __rmul__(self, scalar):
        return self * scalar

v1 = Vector([1, 2, 3])
print(1, repr(v1 * 10))
print(2, repr(20 * v1))

1 Vector([10.0, 20.0, 30.0])
2 Vector([20.0, 40.0, 60.0])

运算符	正向方法	逆向方法	就地方法	说明
`+`	`__add__`	`__radd__`	`__iadd__`	加法或拼接
`-`	`__sub__`	`__rsub__`	`__isub__`	减法
`*`	`__mul__`	`__rmul__`	`__imul__`	乘法或重复复制
`/`	`__truediv__`	`__rtruediv__`	`__itruediv__`	除法

更多的

运算符	方法名字
`//`	floordiv
`%`	mod
`divmod()`	divmod
`**`, `pow()`	pow
`@`	matmul
`&`	and
`	`
`^`	xor
`<<`	lshift
`>>`	rshift

pow(a, b, modulo) <==> a ** b % modulo

@ 是点积，可在 numpy 中使用，a @ b <==> dot(a, b)

from array import array
from itertools import zip_longest
import reprlib, numbers

class Vector:
    typecode = 'd'

    def __init__(self, components) -> None:
        self._componeents = array(self.typecode, components)

    def __repr__(self):
        components = reprlib.repr(self._componeents)  # array('d', [1, 2, 3, 4, ...])
        components = components[components.find('['):-1]  # [1, 2, 3, 4, ...]
        return 'Vector({})'.format(components)  # Vector([1, 2, 3, 4])

    def __iter__(self):
        return iter(self._componeents)

    def __matmul__(self, other):
        try:
            return sum(a * b for a, b in zip(self, other))
        except TypeError:
            return NotImplemented

    def __rmatmul__(self, other):
        return self @ other

比较运算符

中辍运算符	正向方法调用	后备机制
`a == b`	`a.__eq__(b)`	返回 `id(a) == id(b)`
`a != b`	`a.__ne__(b)`	返回 `not (a == b)`
`a > b`	`a.__gt__(b)`	抛出 `TypeError`
`a < b`	`a.__lt__(b)`	抛出 `TypeError`
`a >= b`	`a.__ge__(b)`	抛出 `TypeError`
`a <= b`	`a.__le__(b)`	抛出 `TypeError`

反向方法调用 b.__xx__(a)

from array import array
from itertools import zip_longest
import reprlib, numbers

class Vector:
    typecode = 'd'

    def __init__(self, components) -> None:
        self._componeents = array(self.typecode, components)

    def __repr__(self):
        components = reprlib.repr(self._componeents)  # array('d', [1, 2, 3, 4, ...])
        components = components[components.find('['):-1]  # [1, 2, 3, 4, ...]
        return 'Vector({})'.format(components)  # Vector([1, 2, 3, 4])

    def __iter__(self):
        return iter(self._componeents)

    def __eq__(self, other):
        if isinstance(other, Vector):
            return (len(self) == len(other) and all(a == b for a, b in zip(self, other)))
        else:
            return NotImplemented

注意:

== 会调用 a.__eq__(b) 进行判断
当 a.__eq__(b) 抛出 NotImplemented 异常时,
会调用反向方法 b.__eq__(a) 进行判断,
如果再次得到 NotImplemented, 则返回 False
否则返回 True

在两个自定义 class 时判断是否相等时, 可能第一个 class 抛出 NotImplemented, 而第二个 class 通过, 同样返回 True

!= 类似于 not ==

增量赋值运算符

后面忘保存了。。。

标签：__,return,Python,self,运算符,Vector,components,重载,def
From： https://www.cnblogs.com/Zinc233/p/FluentPython_S13.html

【Python】笔记：正确重载运算符