Python 妙用运算符重载——玩出“点”花样来(1)-程序员宅基地

        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)] 


这种设计返回的点太多，使用并不方便。有必要改成只返回上下左右相邻的四个点：

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):
return Point(self.x, self.y+1), Point(self.x, self.y-1), Point(self.x-1, self.y), Point(self.x+1, self.y)


#### \_\_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


注：一旦定义了\_\_call\_\_这个方法，\_\_pos\_\_方法就能改进得更简洁。

class Point:
def init(self, r=0, c=0):
self.x, self.y = r, c
def repr(self):
return f’Point({self.x}, {self.y})’
def pos(self):
return self(0, 1), self(0, -1), self(-1), self(1)
def call(self, dx=0, dy=0):
return Point(self.x + dx, self.y + dy)


测试：


 >>> a=Point()  
 >>> +a  
 (Point(0, 1), Point(0, -1), Point(-1, 0), Point(1, 0))  
 >>> +Point()   # 直接返回上下左右四个方向  
 (Point(0, 1), Point(0, -1), Point(-1, 0), Point(1, 0))  
 >>> b = Point(7, 8)  
 >>> +b  
 (Point(7, 9), Point(7, 7), Point(6, 8), Point(8, 8))


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

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):
return self(0, 1), self(0, -1), self(-1), self(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


**位移运算重载后，同时位移并赋值功能也生效，即 >>= 和 <<= 也同时被重载。** 这种赋值功能也可以用 \_\_ilshift\_\_(self, other)，\_\_irshift\_\_(self, other)；大部分方法都有字母 **i** 开头对应的运算并赋值的方法，如\_\_iadd\_\_、\_\_isub\_\_、\_\_imul\_\_、\_\_ior\_\_......等等。


与\_\_call\_\_方法调用的比较：\_\_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


与调用\_\_call\_\_方法的比较：


>>> p = Point(5, 5)  
 >>> d = Point(2, 3)  
 >>> p + d  
 Point(7, 8)  
 >>> p(d.x, d.y)  
 Point(7, 8)  
 >>> p(2, 3)  
 Point(7, 8)  
 >>> p  
 Point(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 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(float, 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。


测试：


>>> 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)]


示意图： 


![](https://img-blog.csdnimg.cn/direct/8222a19f9b13459fa55a1d9232e61c93.png)


##### 整除 //


**整除**运算就重载为返回所给两点作对角线的矩形上的两组邻边上的所有点；返回点的列表也分组，如上图，一组是路径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 selfmod1 + [mod1] + mod1other, selfmod2 + [mod2] + mod2other


测试： 


>>> 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)])


##### 右加 +


大部分运算符都有对应的右侧运算操作，由字母 **r** 开头，如右加\_\_radd\_\_、右减\_\_rsub\_\_、右乘\_\_rmul\_\_......等等；只有当自定义对象位于运算符号的右侧时，右运算方法才会被调用。与普通的加法相比，\_\_radd\_\_(self, other) 方法只有当 other 在加号+的左边，对象在加号+的右边才会被调用。


我们把**右加**方法重载成单目运算+差不多的规则，只是多了距离n，不一定是相邻的四点：

def __radd__(self, n):
    return self(0, n), self(0, -n), self(-n), self(n)


测试： 


>>> a = Point(1,2); b = Point(); n = 2  
 >>> a + b  
 Point(1, 2)  
 >>> b + a  
 Point(1, 2)  
 >>> a + n   
Traceback (most recent call last):  
   File "<pyshell#29>", line 1, in <module>  
     a + n  
 AttributeError: 'int' object has no attribute 'x'  
 >>> n + a  
 (Point(1, 4), Point(1, 0), Point(-1, 2), Point(3, 2))  
 >>> n + b  
 (Point(0, 2), Point(0, -2), Point(-2, 0), Point(2, 0))  
 >>> 1 + b  # 当n==1就返回上下左右相邻的四个点  
 (Point(0, 1), Point(0, -1), Point(-1, 0), Point(1, 0))  
 >>> 1 + b == +b  
 **自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

![img](https://img-blog.csdnimg.cn/img_convert/90bf07ee269d6c3dd96a81ffb10e9532.png)

![img](https://img-blog.csdnimg.cn/img_convert/2dad4e2456fdedc41c75fba245b0401d.png)

![img](https://img-blog.csdnimg.cn/img_convert/67b76c0f129d23225680b45ea8ccb78a.png)

![img](https://img-blog.csdnimg.cn/img_convert/290b211b67d19306d20ef64fff191cef.png)

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**

  
 AttributeError: 'int' object has no attribute 'x'  
 >>> n + a  
 (Point(1, 4), Point(1, 0), Point(-1, 2), Point(3, 2))  
 >>> n + b  
 (Point(0, 2), Point(0, -2), Point(-2, 0), Point(2, 0))  
 >>> 1 + b  # 当n==1就返回上下左右相邻的四个点  
 (Point(0, 1), Point(0, -1), Point(-1, 0), Point(1, 0))  
 >>> 1 + b == +b  
 **自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

[外链图片转存中...(img-rk1SAvFo-1713607965794)]

[外链图片转存中...(img-BeYpMH0D-1713607965795)]

[外链图片转存中...(img-ZDYCeyty-1713607965796)]

[外链图片转存中...(img-hH8RsKtR-1713607965797)]

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**

![](https://img-blog.csdnimg.cn/img_convert/5e65458bec4b911142bd01b2fe8000b5.jpeg)

本文链接：https://blog.csdn.net/lingyued/article/details/138006505

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

while循环&CPU占用率高问题深入分析与解决方案_main函数使用while(1)循环cpu占用99-程序员宅基地

文章浏览阅读3.8k次，点赞9次，收藏28次。直接上一个工作中碰到的问题，另外一个系统开启多线程调用我这边的接口，然后我这边会开启多线程批量查询第三方接口并且返回给调用方。使用的是两三年前别人遗留下来的方法，放到线上后发现确实是可以正常取到结果，但是一旦调用，CPU占用就直接100%(部署环境是win server服务器)。因此查看了下相关的老代码并使用JProfiler查看发现是在某个while循环的时候有问题。具体项目代码就不贴了，类似于下面这段代码。while(flag) {//your code;}这里的flag._main函数使用while(1)循环cpu占用99

【无标题】jetbrains idea shift f6不生效_idea shift +f6快捷键不生效-程序员宅基地

文章浏览阅读347次。idea shift f6 快捷键无效_idea shift +f6快捷键不生效

node.js学习笔记之Node中的核心模块_node模块中有很多核心模块,以下不属于核心模块,使用时需下载的是-程序员宅基地

文章浏览阅读135次。Ecmacript 中没有DOM 和 BOM核心模块Node为JavaScript提供了很多服务器级别，这些API绝大多数都被包装到了一个具名和核心模块中了，例如文件操作的 fs 核心模块，http服务构建的http 模块 path 路径操作模块 os 操作系统信息模块// 用来获取机器信息的var os = require('os')// 用来操作路径的var path = require('path')// 获取当前机器的 CPU 信息console.log(os.cpus._node模块中有很多核心模块,以下不属于核心模块,使用时需下载的是

数学建模【SPSS 下载-安装、方差分析与回归分析的SPSS实现(软件概述、方差分析、回归分析)】_化工数学模型数据回归软件-程序员宅基地

文章浏览阅读10w+次，点赞435次，收藏3.4k次。SPSS 22 下载安装过程7.6 方差分析与回归分析的SPSS实现7.6.1 SPSS软件概述1 SPSS版本与安装2 SPSS界面3 SPSS特点4 SPSS数据7.6.2 SPSS与方差分析1 单因素方差分析2 双因素方差分析7.6.3 SPSS与回归分析SPSS回归分析过程牙膏价格问题的回归分析_化工数学模型数据回归软件

利用hutool实现邮件发送功能_hutool发送邮件-程序员宅基地

文章浏览阅读7.5k次。如何利用hutool工具包实现邮件发送功能呢？1、首先引入hutool依赖<dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.7.19</version></dependency>2、编写邮件发送工具类package com.pc.c..._hutool发送邮件

docker安装elasticsearch，elasticsearch-head，kibana，ik分词器_docker安装kibana连接elasticsearch并且elasticsearch有密码-程序员宅基地

文章浏览阅读867次，点赞2次，收藏2次。docker安装elasticsearch，elasticsearch-head，kibana，ik分词器安装方式基本有两种，一种是pull的方式，一种是Dockerfile的方式，由于pull的方式pull下来后还需配置许多东西且不便于复用，个人比较喜欢使用Dockerfile的方式所有docker支持的镜像基本都在https://hub.docker.com/docker的官网上能找到合..._docker安装kibana连接elasticsearch并且elasticsearch有密码

随便推点

Python 攻克移动开发失败！_beeware-程序员宅基地

文章浏览阅读1.3w次，点赞57次，收藏92次。整理 | 郑丽媛出品 | CSDN（ID：CSDNnews）近年来，随着机器学习的兴起，有一门编程语言逐渐变得火热——Python。得益于其针对机器学习提供了大量开源框架和第三方模块，内置..._beeware

Swift4.0_Timer 的基本使用_swift timer 暂停-程序员宅基地

文章浏览阅读7.9k次。//// ViewController.swift// Day_10_Timer//// Created by dongqiangfei on 2018/10/15.// Copyright 2018年飞飞. All rights reserved.//import UIKitclass ViewController: UIViewController { ..._swift timer 暂停

元素三大等待-程序员宅基地

文章浏览阅读986次，点赞2次，收藏2次。1.硬性等待让当前线程暂停执行，应用场景：代码执行速度太快了，但是UI元素没有立马加载出来，造成两者不同步，这时候就可以让代码等待一下，再去执行找元素的动作线程休眠，强制等待 Thread.sleep(long mills)package com.example.demo;import org.junit.jupiter.api.Test;import org.openqa.selenium.By;import org.openqa.selenium.firefox.Firefox.._元素三大等待