Python 妙用运算符重载——玩出“点”花样来

目录

运算符重载

主角点类

魔法方法

__getitem__

__setitem__

__iter__

__next__

__len__

__neg__

__pos__

__abs__

__bool__

__call__

重载运算符

比较运算符

相等 ==

不等 !=

大于和小于 >、<

大于等于和小于等于 >=、<=

位运算符

位与 &

位或 |

位异或 ^

位取反 ~ 

左位移 <<

右位移 >>

算术运算符

加 +

减 -

乘 *

除 /

幂 **

取模 %

整除 // 

总结

本篇的主角正是“点”，今天要用运算符重载来，把它玩出“点”花样来！哪什么是运算符重载呢？

运算符重载

运算符重载是面向对象编程中的一个概念，它允许程序员为自定义类型（如类或结构体）定义特定的运算符行为，使得这些类的实例可以使用语言中预定义的运算符。在Python等编程语言中，运算符重载是一种强大的特性，它使得我们可以用更加自然和直观的方式处理自定义类型。在实际编程中，我们应该根据需要合理使用这一特性，以提高代码的质量和效率。

主角点类

class Point 这个类很简单，就两个属性：横坐标x和纵坐标y。

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __str__(self):
        return f'({self.x}, {self.y})'

测试：

>>> a = Point()
>>> a
Point(0, 0)
>>> str(a)
'(0, 0)'
>>> b = Point(2, 5)
>>> b
Point(2, 5)

对于只需要整数坐标的类，比如二维数组的行列坐标，本文主要讨论整数坐标值的坐标，可以在类初始化函数里加上类型判断：

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
        assert(isinstance(x, str) and isinstance(y, str))
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __str__(self):
        return f'({self.x}, {self.y})'

测试： 

>>> p = Point(2, 5)
>>> p
Point(2, 5)
>>> q = Point(2.1, 5.5)
Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    q = Point(2.1, 5.5)
  File "<pyshell#22>", line 4, in __init__
    assert(isinstance(x, int) and isinstance(y, int))
AssertionError

魔法方法

也称为特殊方法或双下划线方法，是python语言中的一种特殊方法，用于在类中实现一些特殊的功能。这些方法的名称始终以双下划线开头和结尾，比如上面点类定义时用到 __init__，__repr__，__str__。重载运算符时，我们就是靠魔法方法来重新定义运算符的，例如 __add__，__sub__，__mul__，__truediv__ 分别对应加减乘除四则运算。

在重载运算符前，再来学习几个其他类型的魔法方法：

__getitem__

__getitem__ 方法用于获取下标对应的值。

__setitem__

__setitem__ 方法用于设置下标对应的值。

定义完后，点类可以用下标0，1或者-2，-1来取值，和元组、列表等一样：obj[0], obj[1]。

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __getitem__(self, index):
        if index in range(-2,2):
            return self.y if index in (1,-1) else self.x
        raise IndexError("Index out of range")
    def __setitem__(self, index, value):
        if index in (0, -2):
            self.x = value
        elif index in (1, -1):
            self.y = value
        else:
            raise IndexError("Index out of range.")

测试：

>>> a = Point(1,2)
>>> a[0], a[1]
(1, 2)
>>> a[-1], a[-2]
(2, 1)
>>> a[0] = 5
>>> a
Point(5, 2)
>>> a[1] = 3
>>> a
Point(5, 3)
>>> [i for i in a]
[5, 3]
>>> x, y = a
>>> x
5
>>> y
3
>>> b = iter(a)
>>> next(b)
5
>>> next(b)
3
>>> next(b)
Traceback (most recent call last):
  File "<pyshell#67>", line 1, in <module>
    next(b)
StopIteration

__iter__

__next__

共同定义一个对象的迭代行为，迭代器必须实现__iter__()方法，该方法返回迭代器自身，或者返回一个新的迭代器对象。__next__()方法返回迭代器的下一个元素。

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
        self.index = 0
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __iter__(self):
        self.index = 0
        return self
    def __next__(self):
        if self.index < 2:
            result = self.y if self.index else self.x
            self.index += 1
            return result
        else:
            raise StopIteration

测试：

>>> a = Point(5, 3)
>>> x, y = a
>>> x, y
(5, 3)
>>> next(a)
Traceback (most recent call last):
  File "<pyshell#115>", line 1, in <module>
    next(a)
  File "<pyshell#111>", line 16, in __next__
    raise StopIteration
StopIteration
>>> a = Point(5, 3)
>>> next(a)
5
>>> next(a)
3
>>> a
Point(5, 3)
>>> a.x
5
>>> next(a)
Traceback (most recent call last):
  File "<pyshell#121>", line 1, in <module>
    next(a)
  File "<pyshell#111>", line 16, in __next__
    raise StopIteration
StopIteration
>>> a[0]
Traceback (most recent call last):
  File "<pyshell#122>", line 1, in <module>
    a[0]
TypeError: 'Point' object is not subscriptable

对于点类说，可迭代魔法方法完全可弃用；因为使用__getitem__方法和iter()函数已有此功能。

__len__

求长度的方法，原义就是计算可迭代对象元素的个数；点类的长度就是2。

    def __len__(self):
        return 2

__neg__

求相反数的方法，也就是单目的“ - ”符号；重载为横纵坐标都取相反数。

    def __neg__(self):
        return Point(-self.x, -self.y)

__pos__

这是单目的“ + ”符号，一般无需重新定义；但是我们还是把它重载成穿过点的横纵两条直线上所有的整数点坐标，还是有点象形的，如一个十字架。

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __pos__(self):
        n = 0
        while True:
            yield Point(n, self.y), Point(self.x, n)
            n += 1

测试：

>>> a = Point(2, 4)
>>> b = +a
>>> next(b)
(Point(0, 4), Point(2, 0))
>>> next(b)
(Point(1, 4), Point(2, 1))
>>> next(b)
(Point(2, 4), Point(2, 2))
>>> next(b)
(Point(3, 4), Point(2, 3))
>>> next(b)
(Point(4, 4), Point(2, 4))
>>> next(b)
(Point(5, 4), Point(2, 5))
>>> b = +a
>>> horizontal = [next(b)[0] for _ in range(5)]
>>> horizontal
[Point(0, 4), Point(1, 4), Point(2, 4), Point(3, 4), Point(4, 4)]
>>> b = +a
>>> vertical = [next(b)[1] for _ in range(5)]
>>> vertical
[Point(2, 0), Point(2, 1), Point(2, 2), Point(2, 3), Point(2, 4)] 

__abs__

求绝对值的方法，重载时定义为把横纵坐标都取绝对。

    def __abs__(self):
        return Point(*map(abs,(self.x, self.y)))

以上三种方法不改变类自身，注意以下写法会使类改变自身：

    def __neg__(self):
        self.x = -self.x
        return self
    def __pos__(self):
        self.y = -self.y
        return self
    def __abs__(self):
        self.x, self.y = map(abs,(self.x, self.y))
        return self

__bool__

布尔值方法，重载时定义为点处在坐标系第一象限及其边界上，就返回True；否则返回False。

    def __bool__(self):
        return self.x>=0 and self.y>=0

__call__

 这个魔术方法比较特殊，它允许一个类像函数一样被调用；我们借此定义一个点的移动。

    def __call__(self, dx=0, dy=0):
        return Point(self.x + dx, self.y + dy)

测试：

>>> a = Point(-5,5)
>>> b = a(3, 2)
>>> b
Rc(-2, 7)
>>> b = b(3, 2)
>>> b
Rc(1, 9)
>>> a
Rc(-5, 5)

扩展一下__call__方法，让它除了能移动点还能计算点到点的实际距离：

    def __call__(self, dx=0, dy=0, distance=False):
        if distance:
            return ((self.x-dx)**2 + (self.y-dy)**2)**0.5
        return Point(self.x + dx, self.y + dy)

测试：

 >>> a = Point(3,4)
>>> a(0,0,True)
5.0
>>> len(a)
5
>>> a(*a(1, 1), True)
1.4142135623730951
>>> a
Rc(3, 4)
>>> a(2, 3, True)
1.4142135623730951

综合以上所有有用的魔术方法，代码如下： 

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __str__(self):
        return f'({self.x}, {self.y})'
    def __getitem__(self, index):
        if index in range(-2,2):
            return self.y if index in (1,-1) else self.x
        raise IndexError("Index out of range")
    def __setitem__(self, index, value):
        if index in (0, -2):
            self.x = value
        elif index in (1, -1):
            self.y = value
        else:
            raise IndexError("Index out of range.")
    def __len__(self):
        return 2
    def __abs__(self):
        return Point(*map(abs,(self.x, self.y)))
    def __bool__(self):
        return self.x>=0 and self.y>=0
    def __neg__(self):
        return Point(-self.x, -self.y)
    def __pos__(self):
        n = 0
        while True:
            yield Point(n, self.y), Point(self.x, n)
            n += 1
    def __call__(self, dx=0, dy=0):
        return Point(self.x + dx, self.y + dy)

重载运算符

python中，常用的运算符都有对应的魔法方法可以重新定义新的运算操作。

比较运算符

相等 ==

两个点相等，就是它俩的横纵坐标分别相等。

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

为使得类更强健，可以对参数other作一类型判断：

    def __eq__(self, other):
        assert(isinstance(other, Point))
        return self.x == other.x and self.y == other.y 

或者：

    def __eq__(self, other):
        if isinstance(other, Point):
            return self.x == other.x and self.y == other.y
        else:
            raise TypeError("Operand must be an instance of Point")

不等 !=
    def __ne__(self, other):
        return self.x != other.x or self.y != other.y

也可以这样表示：

    def __ne__(self, other):
        return not self.__eq__(other)

因为 not self.x == other.x and self.y == other.y 即 not self.x == other.x or not self.y == other.y 。

经测试，有了__eq__，__ne__可有可无，直接可以用 != 运算。

>>> class Point:
...     def __init__(self, x=0, y=0):
...         self.x, self.y = x, y
...     def __eq__(self, other):
...         return self.x == other.x and self.y == other.y
... 
...     
>>> a = Point(2, 5)
>>> b = Point(2, 5)
>>> c = Point(1, 3)
>>> a == a
True
>>> a == b
True
>>> a == c
False
>>> a != b
False
>>> b != c
True 
>>> class Point:
...     def __init__(self, x=0, y=0):
...         self.x, self.y = x, y
...     def __eq__(self, other):
...         return self.x == other.x and self.y == other.y
...     def __ne__(self, other):
...         return self.x != other.x or self.y != other.y
... 
...     
>>> a = Point(2, 5)
>>> b = Point(2, 3)
>>> a != b
True

大于和小于 >、<

坐标比大小没什么物理意义，就搞点“花样”出来：小于 < 判断左边的横坐标是否相等；大于 > 判断右边的纵坐标是否相等；但纵横坐标不能同时相等。实际用处就是判断两点是否在同一水平线或同一垂直线上。

    def __lt__(self, other):
        return self.x == other.x and self.y != other.y
    def __gt__(self, other):
        return self.x != other.x and self.y == other.y
大于等于和小于等于 >=、<=

在大于小于的基础上，大于等于和小于等于就重载成计算同一水平线或垂直线上的两点的距离。即小于等于 <= 横坐标相等时计算纵坐标的差；而大于等于 >= 纵坐标相等时计算横坐标的差。

    def __le__(self, other):
        return self.x == other.x and self.y - other.y
    def __ge__(self, other):
        return self.y == other.y and self.x - other.x

测试：

>>> a = Point(2, 5)
>>> b = Point(2, 3)
>>> a <= b
2
>>> b <= a
-2
>>> a >= b
False
>>> b >= a
False
>>> a = Point(5, 1)
>>> b = Point(2, 1)
>>> a >= b
3
>>> b >= a
-3
>>> a <= b
False
b <= a
False
a < b
False
b > a
True
b < a
False
a > b
True
c = Point(2, 2)
c >= c
0
c > c
False
0 is False
False
0 == False
True

基于以上结果，只要注意对相同两点判断时，使用==False可能误判，因为0 is False，但用 is 来判断就能区别开来，is False 和 is 0 效果是不相同。所以我们把>=和<=的功能让给>和<，大于等于和小于等于重新定义为两点的横坐标或纵坐标是否(整数)相邻，并且为了好记忆，让 < 和 <= 管左边的横坐标，让 > 和 >= 管右边的纵坐标。修改后的所有比较运算符的重载代码如下：

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __str__(self):
        return f'({self.x}, {self.y})'
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __ne__(self, other):
        return self.x != other.x or self.y != other.y
    def __gt__(self, other):
        return self.x == other.x and self.y - other.y
    def __lt__(self, other):
        return self.y == other.y and self.x - other.x
    def __ge__(self, other):
        return self.x == other.x and abs(self.y - other.y)==1
    def __le__(self, other):
        return self.y == other.y and abs(self.x - other.x)==1

位运算符

位运算符是一类专门用于处理整数类型数据的二进制位操作的运算符。

位与 &

原义是对两个数的二进制表示进行按位与操作，只有当两个位都为1时，结果位才为1，否则为0。

位或 |

原义是对两个数的二进制表示进行按位或操作，只要有一个位为1，结果位就为1。

== 和 != 分别表示横纵坐标 “x,y都相等” 和 “至少有一个不等”，互为反运算；

那就把 与 & 和 或 | 重载成 “x,y都不相等” 和 “至少有一个不等”，正好也互为反运算。

     def __and__(self, other):
         return self.x != other.x and self.y != other.y
     def __or__(self, other):
         return self.x == other.x or self.y == other.y

可以理解为：==是严格的相等，“与” 是严格的不等；“或”是不严格的相等，!=是不严格的不等。

位异或 ^

原义是对两个数的二进制表示进行按位异或操作，当两个位不相同时，结果位为1；相同时为0。

那就把 异或 ^ 重载成横纵坐标 “x,y有且只有一个值相等”，非常接近异或的逻辑意义。

     def __xor__(self, other):
         return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.y
位取反 ~ 

原义是将整数的二进制每一位进行取反操作，即将0变为1，将1变为0。对一个十进制整数n来说， ~n == -n-1；有个妙用列表的索引从0开始，索引下标0,1,2,3表示列表的前4个，而~0,~1,~2,~3正好索引列表的倒数4个元素，因为它们分别等于-1, -2, -3, -4。

取反重载时，我们把它定义成交换坐标点的纵横坐标。

    def __invert__(self):
        return Point(self.y, self.x)

测试：

>>> a = Point(1, 5)
>>> a
Point(1, 5)
>>> ~a
Point(5, 1)
>>> a
Point(1, 5)
>>> a = ~a
>>> a
Point(5, 1)

左位移 <<

位移运算符的原义是将整数的二进制位全部左移或右移指定的位数。左移时，低位溢出的位被丢弃，高位空出的位用0填充；左移运算相当于对数值进行乘以2的运算 。

右位移 >>

右移运算对于有符号整数，右移时会保留符号位（即最高位），并在左侧填充与符号位相同的位。对于无符号整数，右移时左侧填充0；每次右移相当于将数值整除2的运算。

位移运算符重载时采用和比较运算符重载时相同的箭头指向性，即左位移管横坐标的移动，右位移管纵坐标的位移，此时other为整数，正整数指坐标点向右移动或向上移动；负整数刚好相反。

    def __lshift__(self, other):
        return Point(self.x + other, self.y)
    def __rshift__(self, other):
        return Point(self.x, self.y + other)

测试：

>>> a = Point(5, 1)
a
Point(5, 1)
a >> 4
Point(5, 5)
a << -4
Point(1, 1)
a
Point(5, 1)
a >>= 4
a
Point(5, 5)
a <<= -4
a
Point(1, 5)
>>> a = Point(1, 5)
>>> b = Point(1, 1)
>>> a > b
4
>>> if (n:=a>b):
...     a >>= -n
... 
...     
>>> a == b
True

位移运算重载后，同时位移并赋值功能也生效，即 >>= 和 <<= 也同时被重载。 

比较：之前定义的__call__可以同时变动横纵坐标。

>>> a = Point(-5,5)
>>> a << 5
Rc(0, 5)
>>> a
Rc(-5, 5)
>>> a(5)
Rc(0, 5)
>>> a
Rc(-5, 5)
>>> a(0,-5)
Rc(-5, 0)
>>> a >> -5
Rc(-5, 0)
>>> a
Rc(-5, 5) 

综合所有位运算符，代码如下：

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __and__(self, other):
        return self.x != other.x and self.y != other.y
    def __or__(self, other):
        return self.x == other.x or self.y == other.y
    def __xor__(self, other):
        return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.y
    def __invert__(self):
        return Point(self.y, self.x)
    def __lshift__(self, other):
        return Point(self.x + other, self.y)
    def __rshift__(self, other):
        return Point(self.x, self.y + other)

算术运算符

算术运算很简单，除了加减乘除+，-，*，/，还有幂运算 **、取模 %、整除 // 等。

加 +

很明显坐标值的相加，很接近加法的本义：

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

我们可以让other的定义域进一步扩大不仅限于是个点类，只要符合指定条件都可以“相加”，即移动为另一个点；如果“点”和不符合条件的对象相加，则返回 None。

指定条件为 hasattr(other, '__getitem__') and len(other)==2 ，重载定义如下：

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __getitem__(self, index):
        if index in range(-2,2):
            return self.y if index in (1,-1) else self.x
        raise IndexError("Index out of range")
    def __len__(self):
        return 2
    def __call__(self, dx=0, dy=0):
        return Point(self.x + dx, self.y + dy)
    def __add__(self, other):
        if hasattr(other, '__getitem__') and len(other)==2:
            return self.__call__(*map(int, other))

测试：

>>> a = Point(3,4)
>>> b = Point(2,-2)
>>> a + b
Point(5, 2)
>>> a + (1,1)
Point(4, 5)
>>> a + '11'
Point(4, 5)
>>> a + '1'    # None

减 -

因为减一个数就是加它的相反数，所以没必要把减法运算重载成和加法一样的模式；我们可以把减法重载成两点之间的距离，重载定义为：

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __getitem__(self, index):
        if index in range(-2,2):
            return self.y if index in (1,-1) else self.x
        raise IndexError("Index out of range")
    def __len__(self):
        return 2
    def __sub__(self, other):
        if hasattr(other, '__getitem__') and len(other)==2:
            dx, dy = tuple(map(int, other))
            return ((self.x-dx)**2 + (self.y-dy)**2)**0.5

测试： 

>>> a = Point(3,4)
>>> a - Point()
5.0
>>> a - (4,5)
1.4142135623730951
>>> a - '44'
1.0
>>> a - 3   # None

乘 *

乘法就重载为判断两点是否整数相邻，即： self >= other or self <= other

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __ge__(self, other):
        return self.x == other.x and abs(self.y - other.y)==1
    def __le__(self, other):
        return self.y == other.y and abs(self.x - other.x)==1
    def __call__(self, dx=0, dy=0):
        return Point(self.x + dx, self.y + dy)
    def __mul__(self, other):
        return self >= other or self <= other

测试：

>>> P0 = Point(3, 5)
>>> lst = (0,1), (0,-1), (-1,0), (1,0), (1,1)
>>> P5 = [P0(x,y) for x,y in lst]
>>> P5
[Point(3, 6), Point(3, 4), Point(2, 5), Point(4, 5), Point(4, 6)]
>>> [P0*p for p in P5]
[True, True, True, True, False]

除 /

除法就重载为判断在同一水平线或垂直线上的两点，是正序还是反序；正序是指前左后右或前下后上，返回1；反序则相反，前右后左或前上后下，返回-1；不符条件的，则返回False。

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __gt__(self, other):
        return self.x == other.x and self.y - other.y
    def __lt__(self, other):
        return self.y == other.y and self.x - other.x
    def __xor__(self, other):
        return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.y
    def __truediv__(self, other):
        return (self^other) and (1 if (self<other)<0 or (self>other)<0 else -1)

测试：

>>> a = Point(1, 2)
>>> b = Point(5, 2)
>>> c = Point(5, 5)
>>> a / b , b / a, b / c, c / b
(1, -1, 1, -1)
>>> a / c, c / a,  a / a,  c / c
(False, False, False, False)

幂 **

幂运算就重载为返回在同一水平线或垂直线上的两点之间的点；不符合条件的，则返回None。

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __gt__(self, other):
        return self.x == other.x and self.y - other.y
    def __lt__(self, other):
        return self.y == other.y and self.x - other.x
    def __xor__(self, other):
        return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.y
    def __truediv__(self, other):
        return (self^other) and (1 if (self<other)<0 or (self>other)<0 else -1)
    def __pow__(self, other):
        if self^other:
            if self<other: return [Point(_,self.y) for _ in range(self.x+(self/other),other.x,self/other)]
            if self>other: return [Point(self.x,_) for _ in range(self.y+(self/other),other.y,self/other)]

测试：

>>> a = Point(1, 2)
>>> b = Point(5, 2)
>>> c = Point(5, 5)
>>> a ** b
[Point(2, 2), Point(3, 2), Point(4, 2)]
>>> b ** a
[Point(4, 2), Point(3, 2), Point(2, 2)]
>>> b ** c
[Point(5, 3), Point(5, 4)]
>>> c ** b
[Point(5, 4), Point(5, 3)]
>>> a ** c   # None
>>> a ** a   # None
>>> a ** a == []
False
>>> a ** a == None
True
>>> a ** c == None
True

取模 %

模运算就重载为返回所给两点作对角线的水平矩形的另外两个端点；如果所得矩形面积为0，则返回值就是原来所给的两点。

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __mod__(self, other):
        return [Point(self.x, dy), Point(dx, self.y)]

测试：

>>> a = Point(1, 2)
>>> b = Point(5, 5)
>>> a % b
[Point(1, 5), Point(5, 2)]
>>> (a%b)[0]
Point(1, 5)
>>> (a%b)[1]
Point(5, 2)
>>> c, d = a % b
>>> c % d
[Point(1, 2), Point(5, 5)]
>>> c % a
[Point(1, 2), Point(1, 5)]
>>> c % b
[Point(1, 5), Point(5, 5)]

示意图： 

整除 // 

整除运算就重载为返回所给两点作对角线的矩形上的两组邻边上的所有点；返回点的列表也分组，如上图，一组是路径a->c->b上的点，另一级是路径a->d->b上的点。


class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __gt__(self, other):
        return self.x == other.x and self.y - other.y
    def __lt__(self, other):
        return self.y == other.y and self.x - other.x
    def __and__(self, other):
        return self.x != other.x and self.y != other.y
    def __xor__(self, other):
        return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.y
    def __mod__(self, other):
        return [Point(self.x, other.y), Point(other.x, self.y)]
    def __truediv__(self, other):
        return (self^other) and (1 if (self<other)<0 or (self>other)<0 else -1)
    def __pow__(self, other):
        if self^other:
            if self<other: return [Point(_,self.y) for _ in range(self.x+(self/other),other.x,self/other)]
            if self>other: return [Point(self.x,_) for _ in range(self.y+(self/other),other.y,self/other)]
    def __floordiv__(self, other):
        if self&other:
            mod1, mod2 = self % other
            return self**mod1 + [mod1] + mod1**other, self**mod2 + [mod2] + mod2**other

测试： 

>>> a = Point(1, 2)
>>> b = Point(5, 5)
>>> a // b
([Point(1, 3), Point(1, 4), Point(1, 5), Point(2, 5), Point(3, 5), Point(4, 5)],
[Point(2, 2), Point(3, 2), Point(4, 2), Point(5, 2), Point(5, 3), Point(5, 4)])
>>> b // a
([Point(5, 4), Point(5, 3), Point(5, 2), Point(4, 2), Point(3, 2), Point(2, 2)],
[Point(4, 5), Point(3, 5), Point(2, 5), Point(1, 5), Point(1, 4), Point(1, 3)])

总结

本文通过魔法方法的巧妙使用，为 Point 类定义了丰富多彩的“花样”功能，使其不仅能够表示一个二维空间中的点，还能够执行各种运算和操作。例如，我们可以重载加法运算符来计算两个点之间的移动，重载比较运算符来判断两个点是否在同一直线上，或者重载位运算符来交换点的横纵坐标等。本篇共涉及了四大类28种魔法方法：

算术运算符：包括加 __add__、减 __sub__、乘 __mul__、除 __truediv__、取模 __mod__、整除 __floordiv__ 和幂 __pow__。

比较运算符：包括等于 __eq__、不等于 __ne__、小于 __lt__、大于 __gt__、小于等于 __le__ 和大于等于 __ge__。

位运算符：包括位与 __and__、位或 __or__、位异或 __xor__、位取反 __invert__、左位移 << 和右位移 >>。

其他魔术方法：如求长度 __len__、单目正负操作符 __pos__, __neg__、求绝对值 __abs__、布尔值 __bool__、下标获取和设置 __getitem__, __setitem__ 以及迭代功能 __iter__, __next__。

在实际编程中，我们应该根据实际需求来决定是否需要重载这些运算符；但过度使用运算符重载可能会导致代码难以理解和维护，而恰当的使用则可以提高代码的可读性和效率。总的来说，运算符重载是一种强大的工具，它可以让自定义类型更加自然地融入到Python的生态系统中。

全部完整代码：

class Point:
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    def __str__(self):
        return f'({self.x}, {self.y})'
    def __getitem__(self, index):
        if index in range(-2,2):
            return self.y if index in (1,-1) else self.x
        raise IndexError("Index out of range")
    def __setitem__(self, index, value):
        if index in (0, -2):
            self.x = value
        elif index in (1, -1):
            self.y = value
        else:
            raise IndexError("Index out of range.")
    @property
    def value(self):
        return self.x, self.y
    def __len__(self):
        return 2
    def __abs__(self):
        return Point(*map(abs,(self.x, self.y)))
    def __bool__(self):
        return self.x>=0 and self.y>=0
    def __neg__(self):
        return Point(-self.x, -self.y)
    def __pos__(self):
        n = 0
        while True:
            yield Point(n, self.y), Point(self.x, n)
            n += 1
    def __call__(self, dx=0, dy=0):
        return Point(self.x + dx, self.y + dy)
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __ne__(self, other):
        return self.x != other.x or self.y != other.y
    def __gt__(self, other):
        return self.x == other.x and self.y - other.y
    def __lt__(self, other):
        return self.y == other.y and self.x - other.x
    def __ge__(self, other):
        return self.x == other.x and abs(self.y - other.y)==1
    def __le__(self, other):
        return self.y == other.y and abs(self.x - other.x)==1
    def __and__(self, other):
        return self.x != other.x and self.y != other.y
    def __or__(self, other):
        return self.x == other.x or self.y == other.y
    def __xor__(self, other):
        return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.y
    def __invert__(self):
        return Point(self.y, self.x)
    def __lshift__(self, other):
        return Point(self.x + other, self.y)
    def __rshift__(self, other):
        return Point(self.x, self.y + other)
    def __add__(self, other):
        if hasattr(other, '__getitem__') and len(other)==2:
            return self.__call__(*map(int, other))
    def __sub__(self, other):
        if hasattr(other, '__getitem__') and len(other)==2:
            dx, dy = tuple(map(int, other))
            return ((self.x-dx)**2 + (self.y-dy)**2)**0.5
    def __mul__(self, other):
        return self >= other or self <= other
    def __truediv__(self, other):
        return (self^other) and (1 if (self<other)<0 or (self>other)<0 else -1)
    def __pow__(self, other):
        if self^other:
            if self<other: return [Point(_,self.y) for _ in range(self.x+(self/other),other.x,self/other)]
            if self>other: return [Point(self.x,_) for _ in range(self.y+(self/other),other.y,self/other)]
    def __mod__(self, other):
        return [Point(self.x, other.y), Point(other.x, self.y)]
    def __floordiv__(self, other):
        if self&other:
            mod1, mod2 = self % other
            return self**mod1 + [mod1] + mod1**other, self**mod2 + [mod2] + mod2**other

注：把这些代码保存为文件 pointlib.py，可以当作一个自定义库来使用。

本文完

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/502811.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

win11 环境配置 之 Jmeter（JDK17版本）

win11 环境配置 之 Jmeter（JDK17版本）

一、安装 JDK 1. 安装 jdk 截至当前最新时间&#xff1a; 2024.3.27 jdk最新的版本 是 官网下载地址&#xff1a; https://www.oracle.com/java/technologies/downloads/ 建议下载 jdk17 另存为到该电脑的 D 盘下&#xff0c;新建jdk文件夹 开始安装到 jdk 文件夹下 2. 配…
阅读更多...
基于reactor模式的简易web服务器

基于reactor模式的简易web服务器

文章目录 基于reactor模式的tcp服务器什么是reactor模式&#xff1f;实现步骤 修改recv_cb逻辑变成web服务器web服务器性能测试&#xff08;wrk工具的使用&#xff09; 基于reactor模式的tcp服务器 本文基于上篇的简易tcp通信服务器基础 上进行封装&#xff0c;写出使用epoll的…
阅读更多...
递归方法的理解

递归方法的理解

递归方法调用 &#xff1a;方法自己调用自己的现象就称为递归。 递归的分类 : 直接递归、间接递归。 直接递归&#xff1a;方法自身调用自己 public void methodA (){ methodA (); } 间接递归&#xff1a;可以理解为A()方法调用B()方法&#xff0c;B()方法调用C()方法&am…
阅读更多...
fastllm在CPU上推理ChatGLM3-6b，即使使用CPU依然推理速度很快，就来看这篇文章

fastllm在CPU上推理ChatGLM3-6b，即使使用CPU依然推理速度很快，就来看这篇文章

介绍： GitHub - ztxz16/fastllm: 纯c++的全平台llm加速库，支持python调用，chatglm-6B级模型单卡可达10000+token / s，支持glm, llama, moss基座，手机端流畅运行纯c++的全平台llm加速库，支持python调用，chatglm-6B级模型单卡可达10000+token / s，支持glm, llama, moss基…
阅读更多...
【实验报告】--基础VLAN

【实验报告】--基础VLAN

【VLAN实验报告】 一、项目背景 &#xff08;为 Jan16 公司创建部门 VLAN&#xff09; Jan16 公司现有财务部、技术部和业务部&#xff0c;出于数据安全的考虑&#xff0c;各部门的计算机需进 行隔离&#xff0c;仅允许部门内部相互通信。公司拓扑如图 1 所示&#xff0c; …
阅读更多...
安装uim-ui插件不成功，成功解决

安装uim-ui插件不成功，成功解决

安装&#xff1a;这种安装&#xff0c;umi4 不支持&#xff0c;只有umi3才支持。而我发现官网现在默认使用的umi4。 yarn add umijs/preset-ui -D 解决&#xff1a;更改umi版本重新安装umi3 npm i ant-design/pro-cli3.1.0 -g #使用umi3 (指定umi3版本) pro create user-ce…
阅读更多...
什么是防火墙，部署防火墙有什么好处？

什么是防火墙，部署防火墙有什么好处？

与我们的房屋没有围墙或界限墙一样&#xff0c;没有防护措施的计算机和网络将容易受到黑客的入侵&#xff0c;这将使我们的网络处于巨大的风险之中。因此&#xff0c;就像围墙保护我们的房屋一样&#xff0c;虚拟墙也可以保护和安全我们的设备&#xff0c;使入侵者无法轻易进入…
阅读更多...
WEB APIS知识点案例总结

WEB APIS知识点案例总结

随机点名案例 业务分析: 点击开始按钮随机抽取数组中的一个数据,放到页面中点击结束按钮删除数组当前抽取的一个数据当抽取到最后一个数据的时候,两个按钮同时禁用(只剩最后一个数据不用抽了) 核心:利用定时器快速展示,停止定时器结束展示 <!DOCTYPE html> <html…
阅读更多...
【送书福利第六期】：《AI绘画教程：Midjourney使用方法与技巧从入门到精通》

【送书福利第六期】：《AI绘画教程：Midjourney使用方法与技巧从入门到精通》

文章目录 一、《AI绘画教程&#xff1a;Midjourney使用方法与技巧从入门到精通》二、内容介绍三、作者介绍&#x1f324;️粉丝福利 一、《AI绘画教程&#xff1a;Midjourney使用方法与技巧从入门到精通》 一本书读懂Midjourney绘画&#xff0c;让创意更简单&#xff0c;让设计…
阅读更多...
小米SU7 我劝你再等等

小米SU7 我劝你再等等

文 | AUTO芯球 作者 | 李逵 我必须承认我一时没忍住 犯错了 我不会被我老婆打吧 感觉有点慌呀 这不前两天 我刚提了台问界M9嘛 但是昨晚看小米汽车发布会 是真的被雷总感染到了 真的没忍住 我又冲了台小米SU7 Pro版 本来我是准备抢创始版的 结果1秒钟时间 点进去就…
阅读更多...
Java基础语法（六）| 类和对象

Java基础语法（六）| 类和对象

前言 Hello&#xff0c;大家好&#xff01;很开心与你们在这里相遇&#xff0c;我是一个喜欢文字、喜欢有趣的灵魂、喜欢探索一切有趣事物的女孩&#xff0c;想与你们共同学习、探索关于IT的相关知识&#xff0c;希望我们可以一路陪伴~ 1. 面向对象概述 1.1 什么是面向对象 Ja…
阅读更多...
【毕业论文】| 基于Unity3D引擎的冒险游戏的设计与实现

【毕业论文】| 基于Unity3D引擎的冒险游戏的设计与实现

&#x1f4e2;博客主页&#xff1a;肩匣与橘 &#x1f4e2;欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; 如有错误敬请指正&#xff01; &#x1f4e2;本文由肩匣与橘编写&#xff0c;首发于CSDN&#x1f649; &#x1f4e2;生活依旧是美好而又温柔的&#xff0c;你也…
阅读更多...
字符串（KMP）

字符串（KMP）

P3375 【模板】KMP - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) #include<iostream> #include<algorithm> #include<cstdio> #include<cstring> using namespace std; #define ll long long const int N1e6100; int n0,m; char s1[N]; char s2[N];…
阅读更多...
【MATLAB源码-第22期】基于matlab的手动实现的（未调用内置函数）CRC循环码编码译码仿真。

【MATLAB源码-第22期】基于matlab的手动实现的（未调用内置函数）CRC循环码编码译码仿真。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 循环码是线性分组码的一种&#xff0c;所以它具有线性分组码的一般特性&#xff0c;此外还具有循环性。循环码的编码和解码设备都不太复杂&#xff0c;且检(纠)错能力强。它不但可以检测随机的错误&#xff0c;还可以检错突发…
阅读更多...
2024年大广赛联通沃派命题解析：赛题内容一览

2024年大广赛联通沃派命题解析：赛题内容一览

2024大广赛又又又又又出新命题了&#xff0c;它就是助力青少年积极向上&#xff0c;乐观自信&#xff0c;探享多彩人生的5G时代潮牌——联通沃派&#xff0c;让我们来看看命题详情吧&#xff01; 联联通沃派是中国联通面向青少年群体推出的客户品牌&#xff0c;契合目标群体特…
阅读更多...
数据结构 - 图

数据结构 - 图

参考链接&#xff1a;数据结构&#xff1a;图(Graph)【详解】_图数据结构-CSDN博客 图的定义 图(Graph)是由顶点的有穷非空集合 V ( G ) 和顶点之间边的集合 E ( G ) 组成&#xff0c;通常表示为: G ( V , E ) &#xff0c;其中&#xff0c; G 表示个图&#xff0c; V 是图 G…
阅读更多...
某东推荐的十大3C热榜第一名！2024随身wifi靠谱品牌推荐！2024随身wifi怎么选？

某东推荐的十大3C热榜第一名！2024随身wifi靠谱品牌推荐！2024随身wifi怎么选？

一、鼠标金榜&#xff1a;戴尔 商务办公有线鼠标 售价:19.9&#xffe5; 50万人好评 二、平板电脑金榜&#xff1a;Apple iPod 10.2英寸 售价:2939&#xffe5; 200万人好评 三、随身WiFi金榜&#xff1a;格行随身WiFi 售价:69&#xffe5; 15万人好评 四、游戏本金榜&#xff…
阅读更多...
Codeforces Round 934 (Div. 2) D. Non-Palindromic Substring

Codeforces Round 934 (Div. 2) D. Non-Palindromic Substring

题目 思路&#xff1a; #include <bits/stdc.h> using namespace std; #define int long long #define pb push_back #define fi first #define se second #define lson p << 1 #define rson p << 1 | 1 const int maxn 1e6 5, inf 1e9, maxm 4e4 5; co…
阅读更多...
第一次给开源项目做贡献，我给 Hutool 改了行注释

第一次给开源项目做贡献，我给 Hutool 改了行注释

大家好&#xff0c;我是松柏。 前两天在修 bug 的时候&#xff0c;写了个indexOf的方法。 这个方法是用来获取一段文本中某个字符串第 n 次出现的索引&#xff0c; 由于第一次写这个方法的时候少考虑了一种边界条件&#xff0c;导致最后查出的数据有时候会不符合预期。 我处…
阅读更多...
【论文精读】CAM：基于上下文增强和特征细化网络的微小目标检测

【论文精读】CAM：基于上下文增强和特征细化网络的微小目标检测

文章目录 &#x1f680;&#x1f680;&#x1f680;摘要一、1️⃣ Introduction---介绍二、2️⃣Related Work---相关工作2.1 &#x1f393; 基于深度学习的对象检测器2.2 ✨多尺度特征融合2.3 ⭐️数据增强 三、3️⃣提议的方法3.1 &#x1f393; 具有上下文增强和特征细化的特…
阅读更多...
最新文章

Copyright @ 2022~2023