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。
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)]
示意图:
![](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)