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.mzph.cn/news/781723.shtml

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

相关文章

git最常用的命令与快捷操作说明

git最常用的命令与快捷操作说明

git最常用的命令与快捷操作说明 最常用的git三条命令1、git add .2、git commit -m "推送注释"3、git push origin 远程分支名:本地分支名 其他常用命令本地创建仓库分支删除本地指定分支切换本地分支合并本地分支拉取远程仓库指定分支代码过来合并推送代码到远程分支…
阅读更多...
Android客户端自动化UI自动化airtest从0到1搭建macos+脚本设计demo演示+全网最全最详细保姆级有步骤有图

Android客户端自动化UI自动化airtest从0到1搭建macos+脚本设计demo演示+全网最全最详细保姆级有步骤有图

iOS客户端自动化UI自动化airtest从0到1搭建macosdemo演示-CSDN博客 一、基础环境 1. 安装jdk 选择jdk8 如果下载高版本 可能不匹配会失败 下载.dmg文件 苹果电脑 &#xff5c; macOS &#xff5c; jdk1.8 &#xff5c; 环境变量配置_jdk1.8 mac-CSDN博客 Java Downloads …
阅读更多...
【面试题】数据底层原理：Elasticsearch写入流程解析

【面试题】数据底层原理：Elasticsearch写入流程解析

前言&#xff1a;本篇博客将介绍Elasticsearch的数据底层原理&#xff0c;涉及数据写入的过程以及相关概念。我们将深入探讨buffer、translog、refresh、commit、flush和merge等核心概念&#xff0c;帮助您更好地理解Elasticsearch的数据存储机制。 写入数据的基本过程 Elast…
阅读更多...
vue 内嵌第三方网页

vue 内嵌第三方网页

需要将另一个系统嵌套到当前网页中 一、frame 方法一就是通过html的标签 iframe 实现网页中嵌入其他网站 标签属性 属性含义src嵌套的网页地址width设置嵌套网页的宽度&#xff0c;单位为像素height设置嵌套网页的高度&#xff0c;单位为像素frameborder控制嵌套的网页是否…
阅读更多...
＜QT基础(2)＞QScrollArea使用笔记

＜QT基础(2)＞QScrollArea使用笔记

项目需要设置单个检查的序列图像预览窗口&#xff0c;采用QScrollArea中加入QWidget窗口&#xff0c;每个窗口里面用Qlabel实现图像预览。 过程涉及两部分内容 引入QWidget 引入label插入图像&#xff08;resize&#xff09; 引入布局 组织 scrollArea内部自带Qwidget&#…
阅读更多...
[项目实践]---RSTP生成树

[项目实践]---RSTP生成树

[项目实践] 目录 [项目实践] 一、项目环境 二、项目规划 三、项目实施 四、项目测试 |验证 ---RSTP生成树 一、项目环境 Jan16 公司为提高网络的可靠性&#xff0c;使用了两台高性能交换机作为核心交换机&#xff0c;接入层交 换机与核心层交换机互联&#xff0c;形成冗…
阅读更多...
MATLAB 统计滤波（去除点云噪声）（55）

MATLAB 统计滤波（去除点云噪声）（55）

MATLAB 统计滤波法（去除点云噪声）（55） 一、算法介绍二、算法实现1.原理2.代码一、算法介绍 点云统计滤波，是一种常用的去噪点方法，原始的点云数据中包含多种噪点，无法直接使用，往往需要通过一些方法去除噪点，而统计滤波在这方面的使用非常广泛常见，下面是去噪点后的…
阅读更多...
P21：public class和class的区别

P21：public class和class的区别

在一个Java源文件中&#xff0c;可以定义多个class 每个class类会生成对应的xxx.class字节码文件 在Java源文件中&#xff0c;public class不是必须的 当Java源文件中有public class类时&#xff0c;public class类只能有一个&#xff0c;并且该源文件的名字必须与公开类名…
阅读更多...
STM32CubeIDE基础学习-USART串口通信实验（中断方式）

STM32CubeIDE基础学习-USART串口通信实验（中断方式）

STM32CubeIDE基础学习-USART串口通信实验&#xff08;中断方式&#xff09; 文章目录 STM32CubeIDE基础学习-USART串口通信实验&#xff08;中断方式&#xff09;前言第1章 硬件介绍第2章 工程配置2.1 工程外设配置部分2.2 生成工程代码部分 第3章 代码编写第4章 实验现象总结 …
阅读更多...
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…
阅读更多...
AP5199S LED平均电流型恒流驱动IC 0.01调光 景观舞台汽车灯驱动照明

AP5199S LED平均电流型恒流驱动IC 0.01调光 景观舞台汽车灯驱动照明

说明 AP5199S 是一款外围电路简单的多功能平均电流型 LED 恒流驱动器&#xff0c;适用于宽电压范围的非隔离式大功率恒流 LED 驱动领域。芯片 PWM 端口支持超小占空比的 PWM 调光&#xff0c;可响应 60ns 脉宽。为客户提供解决方案&#xff0c;限度地发挥灯具优势&#xff0c;…
阅读更多...
商品说明书的制作工具来啦，用这几个就够了！

商品说明书的制作工具来啦，用这几个就够了！

商品说明书是用户了解产品特性、性能、使用方法的重要途径。一个明确、易懂的商品说明书&#xff0c;可以显著提升用户体验&#xff0c;进而提升产品的销量。但我们都知道&#xff0c;制作一份高质量的说明书并不容易&#xff0c;需要仔细设计、计划和撰写。幸运的是&#xff0…
阅读更多...
rabbitMQ的基础操作与可视化界面

rabbitMQ的基础操作与可视化界面

当你安装好RabbitMq时&#xff0c;可以 尝试一下&#xff0c;这些命令 启动rabbitMQ服务 #启动服务 systemctl start rabbitmq-server #查看服务状态 systemctl status rabbitmq-server #停止服务 systemctl stop rabbitmq-server #开机启动服务 systemctl enable rabbitmq-…
阅读更多...
在Arduino IDE中使用文件夹组织源文件和头文件

在Arduino IDE中使用文件夹组织源文件和头文件

在Arduino IDE中使用文件夹组织源文件和头文件 如果你是一名Arduino爱好者&#xff0c;你可能会发现随着项目的复杂度增加&#xff0c;代码的管理变得越来越困难。在Arduino IDE中&#xff0c;你可以通过使用文件夹来更好地组织你的源文件和头文件&#xff0c;使得代码更加清晰…
阅读更多...
深度学习导论

深度学习导论

具有非常详尽的数学推导过程 概述 定位 比较传统机器学习深度学习特征人工定义机器生成模型决策树、SVM、贝叶斯等&#xff08;具有不同数学原理&#xff09;神经网络 概率论 联合概率 P ( X , Y ) P ( X ∣ Y ) P ( Y ) P ( Y ∣ X ) P ( X ) P(X,Y)P(X|Y)P(Y)P(Y|X)P(X…
阅读更多...
【免费获取】【下片神器】IDM非主流网站视频免费下载神器IDM+m3u8并解决idm下载失败问题 idm下载器超长免费试用

【免费获取】【下片神器】IDM非主流网站视频免费下载神器IDM+m3u8并解决idm下载失败问题 idm下载器超长免费试用

当你浏览一个网站&#xff0c;看到一个喜欢的视频&#xff0c;不知道如何下载的时候&#xff0c;本教程或许可以帮你点小忙。大部分的主流网站都有专门的下载工具&#xff0c;本篇教程主要针对的是一些非主流的小网站。 我们的下载方法就是利用IDM&#xff08;Internet Downlo…
阅读更多...
web练习仿小米页面

web练习仿小米页面

效果图&#xff1a; HTML代码&#xff1a; <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>Document…
阅读更多...
江苏开放大学2024年春《液压与气压传动060246》第2形考作业占形考成绩的25％参考答案

江苏开放大学2024年春《液压与气压传动060246》第2形考作业占形考成绩的25％参考答案

​答案&#xff1a;更多答案&#xff0c;请关注【电大搜题】微信公众号 答案&#xff1a;更多答案&#xff0c;请关注【电大搜题】微信公众号 答案&#xff1a;更多答案&#xff0c;请关注【电大搜题】微信公众号 电大搜题 多的用不完的题库&#xff0c;支持文字、图片搜题&…
阅读更多...
python--冒泡排序和main函数

python--冒泡排序和main函数

1.判断是不是回文数&#xff1a; x int(input("请输入一个正整数&#xff1a;")) x str(x) if x x[::-1]:print("是回文数。") else:print("不是回文数。") 2.冒泡排序 # 冒泡排序: # [30&#xff0c;8&#xff0c;-10&#xff0c; 50&am…
阅读更多...
[OAuth2]authorization_request_not_found

[OAuth2]authorization_request_not_found

最近在写一套OAuth2s授权认证&#xff0c;当在oauth2-client调用oauth2-server&#xff0c;并且在点击授权以后&#xff0c;oauth2-client却显示【authorization_request_not_found】&#xff0c;并跳到了登陆页面。 经过调试发现&#xff0c;【authorization_request_not_fou…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023