13.1运算符重载基础
1、不能重载内置类型的运算符
2、不能新建运算符，只能重载现有的
3、某些运算符不能重载-----is、and、or、not（不过位运算符&、|和~可以）
13.2 一元运算符
- __neg__
+ __poes__
~ __invert__
一元操作符要符合一个原则，返回一个新对象，不能修改self。
from array import array
import math
import reprlib
import numbers
import functools
from operator import xor
class Vector:
typecode = 'd'
def __init__(self, components):
self._components = array(self.typecode, components)
def __iter__(self): # 返回一个迭代器，对象拥有__next__属性
'''有了__iter__属性，不仅可以多变量取值，还可以被for循环使用'''
return iter(self._components)
def __repr__(self):
components = reprlib.repr(self._components) # 数量太多可以用...代替
# print(components)
components = components[components.find('['): -1]
return f'{self.__class__.__name__}({components})'
def __str__(self):
return str(tuple(self))
def __bytes__(self):
return (bytes([ord(self.typecode)]) +
bytes(self._components))
def __abs__(self): # abs返回一个直角三角形斜边长
return math.sqrt(sum(x * x for x in self))
def __neg__(self): # 返回一个负数
return Vector(-x for x in self)
def __pos__(self): # 构建一个新的副本
return Vector(self)
def __bool__(self): # 直接调用对象的abs值，然后用bool取值
return bool(abs(self))
def __getitem__(self, index):
print('getitem')
cls = type(self)
if isinstance(index, slice):
print(1)
return cls(self._components[index])
elif isinstance(index, numbers.Integral):
print('index', index)
return self._components[index]
else:
msg = '{cls.__name__} indices must be integers'
raise TypeError(msg.format(cls = cls))
shortcut_name = 'xyzt' # 定义在__getattr__里面也可以，定义在外面就可以修改了
def __getattr__(self, index):
if len(index) == 1:
pos = self.shortcut_name.find(index)
if 0 <= pos < len(self._components):
return self._components[pos]
msg = '{.__name__!r} object has no attribute {!r}'
raise AttributeError(msg.format(self.__class__, index))
def __setattr__(self, key, value):
cls = type(self) # 取出类
if len(key) == 1: # 字符串不是一个字符都可以设置属性
if key in cls.shortcut_name: # 在定义的名单里面
error = 'readonly attribute {attr_name!r}'
elif key.islower(): # 小写字符不行
error = "can't set attribute 'a' to 'z' in {cls_name!r}"
else: # 另外的就是大写字符可以的
error = ''
if error:
msg = error.format(cls_name=cls, attr_name=key)
raise AttributeError(msg)
super(Vector, self).__setattr__(key, value)
def __len__(self):
return len(self._components)
def __hash__(self):
return functools.reduce(xor, (hash(i) for i in self._components), 0)
def __eq__(self, other):
return len(self) == len(other) and all(a == b for a, b in zip(self, other))
# 这个写的很漂亮，先判断len，在判断里面的每组元素，都用到了Python的短路原则
@classmethod
def frombytes(cls, octets):
typecode = chr(octets[0]) # 先读取array的typecode
menv = memoryview(octets[1:]).cast(typecode)
print(menv)
return cls(menv)
v = Vector([1, 2])
print(Vector(v))
运行结果：
In [292]: v Out[292]: Vector([1.0, 2.0]) In [293]: -v Out[293]: Vector([-1.0, -2.0]) In [294]: +v Out[294]: Vector([1.0, 2.0]) In [295]: +v is v Out[295]: False
+返回的不是实例本身特例：Counter模块，添加+返回的是统计为大于0的数值
In [300]: from collections import Counter
In [301]: dd = Counter('hello world')
In [302]: dd
Out[302]: Counter({'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
In [303]: dd['r'] = -5
In [304]: dd
Out[304]: Counter({'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': -5, 'd': 1})
In [305]: +dd
Out[305]: Counter({'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'd': 1})
In [306]:
13.3重载向量加法运算符+
+ __add__
__radd__反向加法。
添加方法如下：
def __add__(self, other): # 两个数字相加遇到+号调用
pairs = zip_longest(self, other, fillvalue=0.0)
return Vector(a + b for a, b in pairs)
In [310]: v1 = Vector([3,4]) In [311]: v+v1 Out[311]: Vector([4.0, 6.0]) In [312]: v + [1,2,3,4] Out[312]: Vector([2.0, 4.0, 3.0, 4.0])
通过zip_longest可以把缺省的位置用0.0替补。
当反着操作时候：
In [316]: range(3) + v1 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-316-681cbdc03217> in <module> ----> 1 range(3) + v1 TypeError: unsupported operand type(s) for +: 'range' and 'Vector'
直接报错了。
再使用中缀运算符时，拿__add__来说，a+b好了，如果a对象有__add__方法，且返回的值不是NotImplemented,那就调用a.__add__(b),然后返回正确的结果。
如果a没有__add__方法，或者调用__add__返回的是NotImplemented,就会去检查b有没有__radd___方法，，如果有且不返回NotImplemented，那就调用b.__radd__(a),返回结果。
如果b没有__radd__方法或者__radd__方法返回NotImplemented，就抛出TypeError，并再错误消息中致命操作数类型不支持。
def __radd__(self, other):
return self +other # 返回__add__的方法，可以理解为如果a+b中，a没有__add__或者返回NotImolemented，调用b+a
添加__radd__方法
In [318]: range(3) + v Out[318]: Vector([1.0, 3.0, 2.0]) In [319]: [1,2,3,4,5] + v Out[319]: Vector([2.0, 4.0, 3.0, 4.0, 5.0])
其实调用了__radd__后面操作了就是 v + range(3) 和 v+[1,2,3,4,5]
In [320]: v + 'abc'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-320-aa871239e6fa> in <module>
----> 1 v + 'abc'
<ipython-input-317-a17db2e69df8> in __add__(self, other)
199 def __add__(self, other): # 两个数字相加遇到+号调用
200 pairs = zip_longest(self, other, fillvalue=0.0)
--> 201 return Vector(a + b for a, b in pairs)
202
203 def __radd__(self, other):
<ipython-input-317-a17db2e69df8> in __init__(self, components)
120
121 def __init__(self, components):
--> 122 self._components = array(self.typecode, components)
123
124 def __iter__(self): # 返回一个迭代器，对象拥有__next__属性
<ipython-input-317-a17db2e69df8> in <genexpr>(.0)
199 def __add__(self, other): # 两个数字相加遇到+号调用
200 pairs = zip_longest(self, other, fillvalue=0.0)
--> 201 return Vector(a + b for a, b in pairs)
202
203 def __radd__(self, other):
TypeError: unsupported operand type(s) for +: 'float' and 'str'
当我们执行v + 'abc'的时候，在return Vector(a + b for a, b in pairs)这个地方出错了，直接返回了TypeError没有去尝试调用对方的__radd__的方法，应该返回NotImplemented，去尝试调用对象的__radd__才是正确的。
def __add__(self, other): # 两个数字相加遇到+号调用
try:
pairs = zip_longest(self, other, fillvalue=0.0)
return Vector(a + b for a, b in pairs)
except TypeError:
return NotImplemented
对__add__进行了修改。
In [334]: 'abc' + v
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-334-866db194f057> in <module>
----> 1 'abc' + v
<ipython-input-329-e69055f2613c> in __radd__(self, other)
97
98 def __radd__(self, other):
---> 99 return self +other # 返回__add__的方法，可以理解为如果a+b中，a没有__add__或者返回NotImolemented，调用b+a
100
101 @classmethod
TypeError: unsupported operand type(s) for +: 'Vector' and 'str'
In [335]: v + 'abc'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-335-aa871239e6fa> in <module>
----> 1 v + 'abc'
TypeError: unsupported operand type(s) for +: 'Vector' and 'str'
In [336]:
我分别操作了两次，第一次'abc' + v：
先调用'abc'的__add__不行，返回调用v.__radd__，最后执行的还是v+'abc'，报错。
v + 'abc'：
先调用v.__add__不行，去寻找'abc'的__radd__，没有这个属性，直接报错。
两次执行的虽然最后都是执行v + 'abc'，但由于过程不一样，中间的不错形式有点不同。
13.4重载标量乘法运算符。
def __mul__(self, other):
return Vector(n * other for n in self)
def __rmul__(self, other):
return self * other
同样添加了*操作，本来可以跟前面一样通过try来实现__mul__的异常捕获，但书中准备用"白鹅类型"，通过isinstance来检测other的属性。
def __mul__(self, other):
if isinstance(other, numbers.Real): # numbers.Real包含的数字范畴很广了，包含了小数，分数等
return Vector(n * other for n in self)
else:
return NotImplemented # 不符合数字要求调用对方的__rmul__
def __rmul__(self, other):
return self * other
上面是经过完全修改过的。
In [340]: v Out[340]: Vector([1.0, 2.0]) In [341]: 14 * v Out[341]: Vector([14.0, 28.0]) In [342]: v * 3.2 Out[342]: Vector([3.2, 6.4]) In [344]: v * False Out[344]: Vector([0.0, 0.0]) In [345]: from fractions import Fraction In [346]: v * Fraction(1,3) Out[346]: Vector([0.3333333333333333, 0.6666666666666666])
中缀运算符有很多
简单的加减乘除，地板除，取余。
+ __add__
- __sub__
* __mul__
/ __truediv__
// __floordiv__
% __mod__
反向操作符加一个r，就地操作符加一个i
等等还有不少。
13.5 众多比较运算符
分组 中缀运算符 正向方法调用 反向方法调用 后备机制
相等性 a == b a.__eq__(b) b.__eq__(a) 返回id(a) == id(b)
a != b a.__ne__(b) b.__ne__(a) 返回 not (a == b)
排序 a > b a.__gt__(b) b.__lt__(a) 抛出TypeError
a <b a.__lt__(b) b.__gt__(a) 抛出TypeError
a >=b a.__ge__(b) b.__le__(a) 抛出TypeError
a <=b a.__le__(b) b.__ge__(a) 抛出TypeError
当自己的调用，返回NotImplemented后，调用对象的反向方法，只有==与！=不会报错，因为==最后会对比双方的ID
在Python3中定义了__eq__，不需要重复定义__ne__
def __eq__(self, other):
return len(self) == len(other) and all(a == b for a, b in zip(self, other))
执行结果：
In [348]: v Out[348]: Vector([1.0, 2.0]) In [349]: v == (1,2) Out[349]: True In [350]: v == [1,2] Out[350]: True In [351]: v == range(1,3) Out[351]: True In [352]: (1,2) == range(1,3) Out[352]: False In [353]:
从结果看出，定义这个不合适，这个判断不准确。
def __eq__(self, other):
if isinstance(other, Vector): # 先进行判断是不是同一个类型的，不是同一个类型的调用对方的__eq__
return len(self) == len(other) and all(a == b for a, b in zip(self, other))
else:
return NotImplemented
修改后的代码：
from array import array
import math
class Vector2d:
typecode = 'd'
__slots__ = ['__x', '__y', '__dict__']
def __init__(self, x, y):
self.__x = x # 转换成私有变量
self.__y = y
@property #把方法变成属性，而且是只读的
def x(self):
return self.__x
@property
def y(self):
return self.__y
def __iter__(self): # 返回一个迭代器，对象拥有__next__属性
'''有了__iter__属性，不仅可以多变量取值，还可以被for循环使用'''
return (i for i in (self.x, self.y))
def __repr__(self):
class_name = type(self).__name__
return '{}({!r},{!r})'.format(class_name, *self)
def __str__(self):
return str(tuple(self))
def __bytes__(self):
return (bytes([ord(self.typecode)]) +
bytes(array(self.typecode, self)))
def __eq__(self, other):
return tuple(self) == tuple(other)
def __abs__(self): # abs返回一个直角三角形斜边长
return math.hypot(self.x, self.y)
def __bool__(self): # 直接调用对象的abs值，然后用bool取值
return bool(abs(self))
def __format__(self, format_spec=''):
components = (format(c, format_spec) for c in self) # 使用生成器，用format处理属性
return '({},{})'.format(*components) # 解包后格式化输出
def __hash__(self): # 通过异或的方式，混合双方的哈希值。
return hash(self.x) ^ hash(self.y)
@classmethod
def frombytes(cls, octets):
typecode = chr(octets[0]) # 先读取array的typecode
menv = memoryview(octets[1:]).cast(typecode)
print(menv)
return cls(*menv)
v = Vector2d(1, 2)
上一个老的2d版本的，到时候需要进行对比：
In [355]: v1 = Vector(range(1,3)) In [356]: v2 = Vector2d(1,2) In [358]: v1 Out[358]: Vector([1.0, 2.0]) In [359]: v2 Out[359]: Vector2d(1,2) In [360]: v1 == v2 Out[360]: True In [361]: v1 == range(1,3) Out[361]: False
这里最有意思的是，为什么v1等于v2，明显v2不属于Vector,所以return NotImplemented
这下要执行v2的__eq__
def __eq__(self, other):
return tuple(self) == tuple(other)
执行这个就是执行Vector2d.__eq__(v2,v1)，这个返回就是true了
假如执行对象的__eq__还是返回NotImplemented，就会执行返回id(v1) == id(v2),最后的大招。
所以==从来不会报错，不管你用什么对象比较。
13.6 增量赋值运算符。
增量赋值远算符 +=，-=，*=，/=，//=等等
增量赋值不会修改不可变目标。
所以不可变目标在用使用增量运算符：
比如 a += 3 就是a = a + 3
In [369]: id(v1) Out[369]: 4646331600 In [370]: v1 Out[370]: Vector([2.0, 4.0, 3.0]) In [371]: v1 *= 3 In [372]: v1 Out[372]: Vector([6.0, 12.0, 9.0]) In [373]: id(v1) Out[373]: 4650011152
对v1进行了*=操作，返现返回的是一个全新的对象，内部执行的是v1 = v1 *3
调用了v1的__mul__方法
书中对前期的一个binggo代码进行了重构。
# binggo
import random
from tombola import Tombila
class BingoCage(Tombila):
def __init__(self, item):
self._randomizer = random.SystemRandom()
self._items =[]
self.load(item) # 调用load方法来实现初始化
def load(self, iterable):
self._items.extend(iterable)
self._randomizer.shuffle(self._items)
def __add__(self, other):
if isinstance(other, Tombila): # 返回两个对象的检查结果元祖相加，重新实例出一个对象
return BingoCage(self.inspect() + other.inspect())
else:
return NotImplemented
def __iadd__(self, other):
if isinstance(other, Tombila):
other_iterable = other.inspect() # 如果是Tombila的实例必定可以返回检测的元祖
else:
try:
other_iterable = iter(other) # 检测other是否为可迭代对象
except TypeError:
self_cls = type(self).__name__
msg = f'right operand in += must be {self_cls!r} or an iterable'
raise TypeError(msg)
self.load(other_iterable) # 调用自身的load方法，load里面用extend
return self
def pick(self):
try:
return self._items.pop()
except IndexError: # 没有数据可以弹出报错，接收IndexError，上报Look错误
raise LookupError('pick from empty BingoCage')
def __call__(self, *args, **kwargs): # 对象变成可调用的
return self.pick() # 书中没有return，我自己加的，要不然执行对象没有返回值
if __name__ == '__main__':
bingo = BingoCage('hello')
print(bingo.inspect(), id(bingo))
bingo += 'abc'
print(bingo.inspect(), id(bingo))
bingo1 = BingoCage('滚了')
bingo = bingo + bingo1
print(bingo.inspect(), id(bingo))
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第十三章/bingo.py
('e', 'h', 'l', 'l', 'o') 4310112080
('a', 'b', 'c', 'e', 'h', 'l', 'l', 'o') 4310112080
('a', 'b', 'c', 'e', 'h', 'l', 'l', 'o', '了', '滚') 4311485328
Process finished with exit code 0
最后根据书中说明跟本人理解，中缀运算符，如果正向方法只能与自身同类实例进行操作
那就没必要设置反向方法。
因为你只能与自身同类的进行操作，如果对方跟你是同类，会调用你的方法，返回NotImplemented，调用对方的反向方法。
如果对方与你进行操作，对方不能执行自身的正向方法，说明对方肯定不跟你是同一类，既然不是同一类，你设置了反向方法又有什么意思呢？反向方法最后还不是调用自身的正向方法。