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

news2024/11/27 10:45:22

目录

运算符重载

主角点类

魔法方法

__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，可以当作一个自定义库来使用。

本文完

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

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

相关文章

这样使用ChatGPT，效率翻倍不是梦！四大秘诀公开

这样使用ChatGPT，效率翻倍不是梦！四大秘诀公开

随着ChatGPT技术的不断革新&#xff0c;它在我们日常工作中扮演着越来越重要的角色。那么&#xff0c;我们该如何利用ChatGPT来解决工作难题呢&#xff1f; Q1&#xff1a;想要迅速获得ChatGPT的帮助&#xff0c;我们应如何提出问题&#xff1f; 以下是几条高效提问的建议&…
阅读更多...
关于v114之后的chromedriver及存放路径

关于v114之后的chromedriver及存放路径

使用selenium调用浏览器时&#xff0c;我一直调用谷歌浏览器&#xff0c;可浏览器升级后&#xff0c;就会再次遇到以前遇到过的各种问题&#xff0c;诸如&#xff1a;1、怎么关闭浏览器更新&#xff1b;2、去哪儿下载chromedriver&#xff1b;3、114版本之后的驱动去哪儿下载&a…
阅读更多...
我于窗中窥月光，恰如仰头见“链表”（Java篇）

我于窗中窥月光，恰如仰头见“链表”（Java篇）

本篇会加入个人的所谓‘鱼式疯言’ ❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言 而是理解过并总结出来通俗易懂的大白话, 小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的. &#x1f92d;&#x1f92d;&#x1f92d;可能说的不是那么严谨.但小编初心是能让更多人…
阅读更多...
嵌入式|蓝桥杯STM32G431（HAL库开发）——CT117E学习笔记15：PWM输出

嵌入式|蓝桥杯STM32G431（HAL库开发）——CT117E学习笔记15：PWM输出

系列文章目录 嵌入式|蓝桥杯STM32G431&#xff08;HAL库开发&#xff09;——CT117E学习笔记01&#xff1a;赛事介绍与硬件平台 嵌入式|蓝桥杯STM32G431&#xff08;HAL库开发&#xff09;——CT117E学习笔记02&#xff1a;开发环境安装 嵌入式|蓝桥杯STM32G431&#xff08;…
阅读更多...
线程安全(二)--死锁

线程安全(二)--死锁

TOC 一:什么是死锁??? public class Demo1 {public static void main(String[] args) {Object lockernew Object();Thread threadnew Thread(()->{synchronized(locker){synchronized (locker){System.out.println("hello thread");}}});thread.start();} }上…
阅读更多...
Facebook Horizon Worlds：打造数字世界的社交乐园

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

在数字化时代&#xff0c;社交媒体平台已经成为人们日常生活中不可或缺的一部分。而随着科技的不断发展&#xff0c;人们对于社交体验的需求也在不断演变。在这样的背景下&#xff0c;Facebook推出了全新的虚拟现实社交平台——Facebook Horizon Worlds&#xff0c;旨在打造一个…
阅读更多...
3D数据格式导出工具HOOPS Publish如何生成高质量3D PDF？

3D数据格式导出工具HOOPS Publish如何生成高质量3D PDF？

在当今数字化时代&#xff0c;从建筑设计到制造业&#xff0c;从医学领域到电子游戏开发&#xff0c;3D技术已经成为了不可或缺的一部分。在这个进程中&#xff0c;将3D模型导出为3D PDF格式具有重要的意义。同时&#xff0c;HOOPS Publish作为一个领先的解决方案&#xff0c;为…
阅读更多...
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 …
阅读更多...
08-研发流程设计（上）：如何设计Go项目的开发流程？

08-研发流程设计（上）：如何设计Go项目的开发流程？

在Go 项目开发中&#xff0c;我们不仅要完成产品功能的开发&#xff0c;还要确保整个过程是高效的&#xff0c;代码是高质量的。 所以&#xff0c;Go 项目开发一定要设计一个合理的研发流程&#xff0c;来提高开发效率、减少软件维护成本。研发流程会因为项目、团队和开发模式…
阅读更多...
Android 自定义坐标曲线图（二）

Android 自定义坐标曲线图（二）

Android 自定义坐标曲线图_android 自定义曲线图-CSDN博客 继上一篇文章&#xff0c;点击折线图上的点&#xff0c;显示提示信息进行修改&#xff0c;之前通过回调&#xff0c;调用外部方法&#xff0c;使用popupwindow或dialog来显示&#xff0c;但是这种方法对于弹框显示的位…
阅读更多...
【No.21】蓝桥杯组合数学|数位排序|加法计数原理|乘法计数原理|排列数|组合数|抽屉原理|小蓝吃糖果|二项式定理|杨辉三角|归并排序(C++)

【No.21】蓝桥杯组合数学|数位排序|加法计数原理|乘法计数原理|排列数|组合数|抽屉原理|小蓝吃糖果|二项式定理|杨辉三角|归并排序(C++)

组合数学 数位排序 【问题描述】 小蓝对一个数的数位之和很感兴趣,今天他要按照数位之和给数排序。当两个数各个数位之和不同时,将数位和较小的排在前面,当数位之和相等时,将数值小的排在前面。 例如,2022 排在 409 前面, 因为 2022 的数位之和是 6,小于 409 的数位 之和 13。…
阅读更多...
Linux 系统快速安装 nginx (新手版)

Linux 系统快速安装 nginx (新手版)

1、安装所需依赖 yum -y install pcre pcre-devel gcc openssl openssl-devel zlib zlib-devel &#xff08;pcre&#xff1a; 包括 perl 兼容的正则表达式库 openssl&#xff1a; 支持安全传输协议https(和财务有关系的请求会走的协议) 创建运行用户、组 useradd -M -…
阅读更多...
Docker实例

Docker实例

华子目录 docker实例1.为Ubuntu镜像添加ssh服务2.Docker安装mysql docker实例 1.为Ubuntu镜像添加ssh服务 (1)访问https://hub.docker.com&#xff0c;寻找合适的Ubuntu镜像 (2)拉取Ubuntu镜像 [rootserver ~]# docker pull ubuntu:latest latest: Pulling from library/ub…
阅读更多...
JAVAEE之网络原理

JAVAEE之网络原理

1.IP地址 IP地址主要用于标识网络主机、其他网络设备&#xff08;如路由器&#xff09;的网络地址。简单说&#xff0c;IP地址用于定位主机的网络地址。 格式 IP地址是一个32位的二进制数&#xff0c;通常被分割为4个“8位二进制数”&#xff08;也就是4个字节&#xff09;&…
阅读更多...
用户登录.java

用户登录.java

分析&#xff1a; 1&#xff0c;用String来定义两个变量&#xff0c;记录正确的用户名和密码----->直接赋值得来 2&#xff0c;键盘录入用户名和密码------>new开辟空间得来&#xff0c;存的是地址值 他们直接用比较大小,必定不相同&#xff0c;需要用到String里面的方…
阅读更多...
STM32CubeIDE基础学习-USART串口通信实验（中断方式）

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

STM32CubeIDE基础学习-USART串口通信实验&#xff08;中断方式&#xff09; 文章目录 STM32CubeIDE基础学习-USART串口通信实验&#xff08;中断方式&#xff09;前言第1章 硬件介绍第2章 工程配置2.1 工程外设配置部分2.2 生成工程代码部分 第3章 代码编写第4章 实验现象总结 …
阅读更多...
python--os和os.path模块

python--os和os.path模块

>>> import os >>> #curdir #获取当前脚本的绝对路径 >>> os.curdir . >>> import os.path >>> #获取绝对路径 >>> os.path.abspath(os.curdir) C:\\Users\\GUOGUO>>> #chdir #修改当前目录 >&g…
阅读更多...
【Python使用】python高级进阶知识md总结第6篇：线程执行带有参数的任务,1. 线程执行带有参数的任务的介绍【附代码文档】

【Python使用】python高级进阶知识md总结第6篇：线程执行带有参数的任务,1. 线程执行带有参数的任务的介绍【附代码文档】

python高级进阶全知识知识笔记总结完整教程&#xff08;附代码资料&#xff09;主要内容讲述&#xff1a;操作系统&#xff0c;虚拟机软件。ls命令选项&#xff0c;mkdir和rm命令选项。压缩和解压缩命令&#xff0c;文件权限命令。编辑器 vim&#xff0c;软件安装。获取进程编号…
阅读更多...
MATLAB 自定义均值滤波 （53）

MATLAB 自定义均值滤波 （53）

MATLAB 自定义均值滤波 （53） 一、算法介绍二、算法实现1.原理2.代码一、算法介绍 均值滤波，是一种常见的点云平滑算法，改善原始点云的数据质量问题，MATLAB自带的工具似乎不太友好，这里提供自定义实现的点云均值滤波算法，具体效果如下所示： 均值滤波前： 均值滤波后：…
阅读更多...
[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