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, ydef __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, yassert(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, ydef __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.xraise IndexError("Index out of range")def __setitem__(self, index, value):if index in (0, -2):self.x = valueelif index in (1, -1):self.y = valueelse: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, yself.index = 0def __repr__(self):return f'Point({self.x}, {self.y})'def __iter__(self):self.index = 0return selfdef __next__(self):if self.index < 2:result = self.y if self.index else self.xself.index += 1return resultelse: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, ydef __repr__(self):return f'Point({self.x}, {self.y})'def __pos__(self):n = 0while 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.xreturn selfdef __pos__(self):self.y = -self.yreturn selfdef __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.5return 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, ydef __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.xraise IndexError("Index out of range")def __setitem__(self, index, value):if index in (0, -2):self.x = valueelif index in (1, -1):self.y = valueelse:raise IndexError("Index out of range.")def __len__(self):return 2def __abs__(self):return Point(*map(abs,(self.x, self.y)))def __bool__(self):return self.x>=0 and self.y>=0def __neg__(self):return Point(-self.x, -self.y)def __pos__(self):n = 0while True:yield Point(n, self.y), Point(self.x, n)n += 1def __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.ydef __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.ydef __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, ydef __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.ydef __ne__(self, other):return self.x != other.x or self.y != other.ydef __gt__(self, other):return self.x == other.x and self.y - other.ydef __lt__(self, other):return self.y == other.y and self.x - other.xdef __ge__(self, other):return self.x == other.x and abs(self.y - other.y)==1def __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.ydef __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, ydef __repr__(self):return f'Point({self.x}, {self.y})'def __and__(self, other):return self.x != other.x and self.y != other.ydef __or__(self, other):return self.x == other.x or self.y == other.ydef __xor__(self, other):return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.ydef __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, ydef __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.xraise IndexError("Index out of range")def __len__(self):return 2def __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, ydef __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.xraise IndexError("Index out of range")def __len__(self):return 2def __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, ydef __repr__(self):return f'Point({self.x}, {self.y})'def __ge__(self, other):return self.x == other.x and abs(self.y - other.y)==1def __le__(self, other):return self.y == other.y and abs(self.x - other.x)==1def __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, ydef __repr__(self):return f'Point({self.x}, {self.y})'def __gt__(self, other):return self.x == other.x and self.y - other.ydef __lt__(self, other):return self.y == other.y and self.x - other.xdef __xor__(self, other):return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.ydef __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, ydef __repr__(self):return f'Point({self.x}, {self.y})'def __gt__(self, other):return self.x == other.x and self.y - other.ydef __lt__(self, other):return self.y == other.y and self.x - other.xdef __xor__(self, other):return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.ydef __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, ydef __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, ydef __repr__(self):return f'Point({self.x}, {self.y})'def __gt__(self, other):return self.x == other.x and self.y - other.ydef __lt__(self, other):return self.y == other.y and self.x - other.xdef __and__(self, other):return self.x != other.x and self.y != other.ydef __xor__(self, other):return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.ydef __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 % otherreturn 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, ydef __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.xraise IndexError("Index out of range")def __setitem__(self, index, value):if index in (0, -2):self.x = valueelif index in (1, -1):self.y = valueelse:raise IndexError("Index out of range.")@propertydef value(self):return self.x, self.ydef __len__(self):return 2def __abs__(self):return Point(*map(abs,(self.x, self.y)))def __bool__(self):return self.x>=0 and self.y>=0def __neg__(self):return Point(-self.x, -self.y)def __pos__(self):n = 0while True:yield Point(n, self.y), Point(self.x, n)n += 1def __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.ydef __ne__(self, other):return self.x != other.x or self.y != other.ydef __gt__(self, other):return self.x == other.x and self.y - other.ydef __lt__(self, other):return self.y == other.y and self.x - other.xdef __ge__(self, other):return self.x == other.x and abs(self.y - other.y)==1def __le__(self, other):return self.y == other.y and abs(self.x - other.x)==1def __and__(self, other):return self.x != other.x and self.y != other.ydef __or__(self, other):return self.x == other.x or self.y == other.ydef __xor__(self, other):return self.x == other.x and self.y != other.y or self.x != other.x and self.y == other.ydef __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.5def __mul__(self, other):return self >= other or self <= otherdef __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 % otherreturn self**mod1 + [mod1] + mod1**other, self**mod2 + [mod2] + mod2**other

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

本文完

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

腾讯 tengine 替代 nginx

腾讯 tengine 替代 nginx

下载地址 变更列表 - The Tengine Web Server 解压 tar -xvf 安装包.gz 进入到解压目录 cd 解压目录 使用 ./configure 命令来指定安装目录,这边指定安装到 /opt/tengine/install路径下 新建install目录 ./configure --prefix/opt/tengine/install 检查是否有缺失的依…
阅读更多...
LM算法探寻——答案在022浙江大学信号与系统

LM算法探寻——答案在022浙江大学信号与系统

LM算法详解 | 宇尘 (gitee.io) 求函数最小值&#xff0c;从另一个角度理解是求误差最小值。 梯度 最陡梯度下降算法和LMS算法原理介绍及MATLAB实现_lms滤波器中的梯度下降-CSDN博客 均值即平均值 (3 封私信 / 56 条消息) FIR滤波器中的冲激响应怎么理解&#xff1f; 和滤波有…
阅读更多...
嵌入式linux学习之交叉编译器安装

嵌入式linux学习之交叉编译器安装

交叉编译器介绍 ARM 裸机、Uboot 移植、Linux 移植这些都需要在 Ubuntu 下进行编译&#xff0c;编译就需要编译器&#xff0c;在 Liux 进行 C 语言开发里面使用 GCC 编译器进行代码编译&#xff0c;但是 Ubuntu 自带的 gcc 编译器是针对 X86 架构的&#xff01;而我们现在要编…
阅读更多...
Linux安装python3

Linux安装python3

Linux安装python3 本文章中使用的安装包等相关文件&#xff1a; 链接: https://pan.baidu.com/s/1C4PTB6IqXtHM6XSOEMkefg 提取码: wyeq 1.编译环境安装 yum -y install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc mak…
阅读更多...
在 Linux 中通过 SSH 执行远程命令时，无法自动加载环境变量（已解决）

在 Linux 中通过 SSH 执行远程命令时，无法自动加载环境变量（已解决）

问题场景 目前我的环境变量都存储在 /etc/profile 文件中&#xff0c;当我通过远程 SSH 执行一些命令时&#xff0c;提示命令找不到&#xff0c;如下所示&#xff1a; 问题出现原因 这里找到了一张出自尚硅谷的图片&#xff0c;很好的解释了该问题&#xff1a; 这是由于 Linu…
阅读更多...
03---java面试八股文——mybatis-------8题

03---java面试八股文——mybatis-------8题

21、MyBatis实现一对一查询 MyBatis 有两种不同的方式加载关联&#xff1a; 嵌套 Select 查询&#xff1a;通过执行另外一个 SQL 映射语句来加载期望的复杂类型。嵌套结果映射&#xff1a;使用嵌套的结果映射来处理连接结果的重复子集。查看mybatis的关联 MyBatis是一种流行的J…
阅读更多...
乡村数字化转型：科技赋能打造智慧农村新生态

乡村数字化转型：科技赋能打造智慧农村新生态

随着信息技术的迅猛发展&#xff0c;数字化转型已成为推动社会进步的重要引擎。在乡村振兴的大背景下&#xff0c;乡村数字化转型不仅是提升乡村治理能力和治理水平现代化的关键&#xff0c;更是推动农业现代化、农村繁荣和农民增收的重要途径。本文旨在探讨乡村数字化转型的内…
阅读更多...
瑞吉外卖实战学习--5、新增员工功能

瑞吉外卖实战学习--5、新增员工功能

新增员工功能 效果图1、开发流程2、页面发送ajax请求，将新增员工的信息以json的形式提交给服务器2.1、在填写信息的时候会发现身份校验比较麻烦，可以在validate中将全局的校验方式去掉，方便填写2.3、看到接口未employee2.4、前端代码分析3、服务器接收到提交的数据并调用ser…
阅读更多...
(js)循环条件满足时终止循环

(js)循环条件满足时终止循环

(js)循环条件满足时终止循环 功能需求&#xff1a;勾选的字段中若包含“数据标注划分”则显示数据划分&#xff0c;不包含则不显示 包含&#xff1a; 不包含&#xff1a; // 标注划分显示 const markStr 数据标注划分 for (let i 0; i < value.length; i) { //value为勾选…
阅读更多...
大话设计模式之策略模式

大话设计模式之策略模式

策略模式是一种行为设计模式&#xff0c;它允许在运行时选择算法的行为。这种模式定义了一族算法&#xff0c;将每个算法都封装起来&#xff0c;并且使它们之间可以互相替换。 在策略模式中&#xff0c;一个类的行为或其算法可以在运行时改变。这种模式包含以下角色&#xff1…
阅读更多...
数字化时代多系统安全运维解决方案

数字化时代多系统安全运维解决方案

添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09; 添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09; 添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09; 添加图片注释&#xff0c;不超过 140 字&#xff08;可选&…
阅读更多...
基于springboot实现数据库的加解密

基于springboot实现数据库的加解密

项目地址 https://github.com/Chenchicheng/spring-ibatis-encryption 功能说明 支持使用注解的方式目标类进行加解密支持同一个类多个字段分别使用不同的加密方式支持自定义加密方法 本地调试 pull代码到本地&#xff0c;更换application.yml中的数据库用户名和密码&…
阅读更多...
Facebook Horizon Worlds：打造数字世界的社交乐园

Facebook Horizon Worlds：打造数字世界的社交乐园

在数字化时代&#xff0c;社交媒体平台已经成为人们日常生活中不可或缺的一部分。而随着科技的不断发展&#xff0c;人们对于社交体验的需求也在不断演变。在这样的背景下&#xff0c;Facebook推出了全新的虚拟现实社交平台——Facebook Horizon Worlds&#xff0c;旨在打造一个…
阅读更多...
【MATLAB源码-第22期】基于matlab的手动实现的（未调用内置函数）CRC循环码编码译码仿真。

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

操作环境&#xff1a; MATLAB 2022a 1、算法描述 循环码是线性分组码的一种&#xff0c;所以它具有线性分组码的一般特性&#xff0c;此外还具有循环性。循环码的编码和解码设备都不太复杂&#xff0c;且检(纠)错能力强。它不但可以检测随机的错误&#xff0c;还可以检错突发…
阅读更多...
ARP协议定义及工作原理

ARP协议定义及工作原理

ARP的定义 地址解析协议(Address Resolution Protocol&#xff0c;ARP)&#xff1a;ARP协议可以将IPv4地址(一种逻辑地址)转换为各种网络所需的硬件地址(一种物理地址)。换句话说&#xff0c;所谓的地址解析的目标就是发现逻辑地址与物理地址的映射关系。 ARP仅用于IPv4协议&a…
阅读更多...
案例研究｜DataEase实现物业数据可视化管理与决策支持

案例研究｜DataEase实现物业数据可视化管理与决策支持

河北隆泰物业服务有限责任公司&#xff08;以下简称为“隆泰物业”&#xff09;创建于2002年&#xff0c;总部设在河北省高碑店市&#xff0c;具有国家一级物业管理企业资质&#xff0c;通过了质量体系、环境管理体系、职业健康安全管理体系等认证。自2016年至今&#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…
阅读更多...
MyBatis 初识简单操作

MyBatis 初识简单操作

前言 上一期我们讲完Spring的配置文件以及日志的设置,这一期我们就来谈谈mybatis操作数据库的一些操作,使用这个框架可以极大地简化JDBC的冗长代码,大大增强了生产力,只需我们提供简单的sql语句以及对应的注解就可以操作数据库 我们说web应用程序主要分为三层 Controller Serv…
阅读更多...
vue3封装Element分页

vue3封装Element分页

配置当前页 配置每页条数 页面改变、每页条数改变都触发回调 封装分页 Pagination.vue <template><el-paginationbackgroundv-bind"$attrs":page-sizes"pageSizes"v-model:current-page"page"v-model:page-size"pageSize":t…
阅读更多...
HarmonyOS 应用开发之Stage模型绑定FA模型ServiceAbility

HarmonyOS 应用开发之Stage模型绑定FA模型ServiceAbility

本小节介绍Stage模型的两种应用组件如何绑定FA模型ServiceAbility组件。 UIAbility关联访问ServiceAbility UIAbility关联访问ServiceAbility和UIAbility关联访问ServiceExtensionAbility的方式完全相同。 import common from ohos.app.ability.common; import hilog from o…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发