在前面第十章以及第一章的时候介绍了Vector对象的运算符重载。第十三章专门介绍运算符重载。这里我们看几个之前没讲过的运算符__neg__,__pos__,__invert__

class Vector(object):

    def __init__(self,x):

        self.x=x

    def __neg__(self):

        return "Vector(%d)" % (-self.x)

    def __str__(self):

        return "Vector(%s)" % (str(self.data))

    def __iter__(self):

        return iter(self.data)

    def __pos__(self):

        return "Vector(%d)" % (self.x+1)

    def __invert__(self):

        return "Vector(%d)" % (~self.x)



if __name__=="__main__":

    v=Vector(1)

    print -v

    print +v

    print ~v

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

Vector(-1)

Vector(2)

Vector(-2)

__neg__是在-v的时候调用

__pos__是在+v的时候调用

__invert__是在~v的时候调用

下面我们重新来看下+运算符。我们想实现两个向量想加Vector([1,2,3])+Vector([1,2,3])得到[2,4,6].代码如下

class Vector(object):

    def __init__(self,x):

        self.x=x

    def __add__(self, other):

        return [a+b for a,b in zip(self.x,other.x)]

if __name__=="__main__":

    v1=Vector([1,2,3])

    v2=Vector([1,2,3])

    print v1+v2

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

[2, 4, 6]

在前面的例子中通过zip函数对两个列表进行配对得到元组。[(1,1),(2,2),(3,3)]然后迭代进行加法运算最终得到结果[2,4,6]

但是如果两个向量的格式变化一下。变成Vector([1,2,3])+Vector([1,2,3,4]).我们期望得到Vector([2,4,,6,4]), 向量Vector([1,2,3,4])由于比Vector([1,2,3])多一个数字，想加的时候最好是用零填充较短的那个向量。那么实际结果如何呢

if __name__=="__main__":

    v1=Vector([1,2,3])

    v2=Vector([1,2,3,4])

    print v1+v2

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

[2, 4, 6]

我们看到结果和上次一样还是[2,4,6]和我们预想的[2,4,6,4]相差太大。原因在于zip得到的结果是[(1, 1), (2, 2), (3, 3)]，并没有包含多出来的4。这种情况下我们就需要用到itertools.izip_lonest，这个方法会自动填充缺失的向量元素

class Vector(object):

    def __init__(self,x):

        self.x=x

    def __add__(self, other):

        pairs=itertools.izip_longest(self.x,other.x,fillvalue=0)

        return [a+b for a,b in pairs]

if __name__=="__main__":

    v1=Vector([1,2,3])

    v2=Vector([1,2,3,4])

    print v1+v2

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

[2, 4, 6, 4]

在izip_longest中,fillvalue代表填充的值。本次例子中设置的是0.因此最后一位是0+4=4

接下来我们的需求继续变下。我们想实现Vector([1,2,3])+[1,2,3]也就是向量类和列表相加

class Vector(object):

    def __init__(self,x):

        self.x=x

    def __add__(self, other):

        if type(other) == list:

            pairs=itertools.izip_longest(self.x,other,fillvalue=0)

        else:

            pairs=itertools.izip_longest(self.x,other.x,fillvalue=0)

        return [a+b for a,b in pairs]

if __name__=="__main__":

    v1=Vector([1,2,3])

    v2=Vector([1,2,3,4])

    print v1+[1,2,3,4]

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

[2, 4, 6, 4]

首先在__add__中判断other的属性，然后针对性的得到pairs

那如果是[1,2,3,4]+v1的结果会是什么呢？运行报错。

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

Traceback (most recent call last):

  File "E:/py_prj/fluent_python/chapter13.py", line 27, in <module>

    print [1,2,3,4]+v1

TypeError: can only concatenate list (not "Vector") to list

这是因为[1,2,3,4]并没有add方法，只有Vector才有，这种场景需要用到__radd__方法

具体的运算流程图如下：

1 如果a有__add__方法，则进行a.__add__(b)运算，否则返回Notimplemented然后检查b有没有__radd__方法。如果有，则调用b.__radd__(a)，否则返回Notimplemented

我们在Vector中增加__radd__方法：

def __radd__(self, other):

    return self+other

__radd__直接委托__add__进行运算。代码也很简单。这下运算结果正确了。

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

[2, 4, 6, 4]

同样的方法也适用于乘法运算符__mul__和__rmul__。

下面来看下比较运算符以及反向比较在__eq__的作用。

首先定义__eq__的代码，首先比较长度，然后比较对应的元素，如果都相等则返回True，否则返回False

def __eq__(self, other):

    if type(other) == list or type(other)==tuple:

        pairs=itertools.izip_longest(self.x,other,fillvalue=0)

        length=len(other)

    else:

        pairs=itertools.izip_longest(self.x,other.x,fillvalue=0)

        length=len(other.x)

    return (len(self.x)==length) and all(a==b for a,b in pairs)

if __name__=="__main__":

    v1=Vector([1.0,2.0,3.0])

    v2=Vector(range(1,4))

    print 'v1 compare v2 %s' % (v1==v2)

    v3=(1,2,3)

    print 'v1 compare v3 %s' % (v1==v3)

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

v1 compare v2 True

v1 compare v3 True 

v1和v2相等这个没啥疑问，但是当用元组(1,2,3)和向量v1相比的时候，得到的结果也是True，我们如果用[1,2]==(1,2)得到的结果为False，因为列表和元组不是一个类型。那么为什么向量和元组相比却是相等的呢？ 这就是问题所在了。在比较的时候并没有比较类型。代码更新如下：

def __eq__(self, other):

    if type(other) == list or type(other)==tuple:

        pairs=itertools.izip_longest(self.x,other,fillvalue=0)

        length=len(other)

    else:

        pairs=itertools.izip_longest(self.x,other.x,fillvalue=0)

        length=len(other.x)

    if isinstance(other,Vector): #在这里判断是否属于向量类

        return (len(self.x)==length) and all(a==b for a,b in pairs)

    else:

        return NotImplemented

再继续看一个例子，增加一个Vector2d向量：

class Vector2d(object):

    def __init__(self,x):

        self.x=x

    def __eq__(self, other):

        return tuple(self.x) ==  tuple(other.x)

if __name__=="__main__":

    v1=Vector([1.0,2.0,3.0])

v4=Vector2d([1,2,3])

print v1==v4

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

True

得到的结果为True. Vector2d不属于Vector的实例呢。为什么会相等呢。这里用到了反向比较的方法

(1)首先Vector.__eq__(v1,v4)，v4不是Vector的实例。返回Notimplemented。然后尝试调用Vector2d.__eq__(v4.v1)

(2)Vector2d.__eq__(v4.v1)把两个操作数都变成元组。然后比较。结果为True。

其实在用Vector和元组进行比较的时候，也是一样的首先Vector.__eq__(v1,v4)，返回Notimplemented。接着开始调用tuple.__eq__(v3,v1),但是tuple不知道vector是什么，因此返回Notimplemented。对于==来说，如果反向调用也是Notimplemented，则会进行最后的尝试，比较对象的ID，如果仍然不相等则返回False。

接下来我们看下!=运算符

print v1!=v4

得到的结果是True，但是我们并没有实现__neq__的方法，也能得到对应的结果，其实__neq__不用实现，只要定义了__eq__的方法，__neq__则会自动对__eq__的结果取反。

最后来看下增量赋值运算符：

if __name__=="__main__":

    v1=Vector([1.0,2.0,3.0])

    print id(v1)⑴

    v2=Vector(range(1,4))

    v1+=v2⑵

    print v1

    print id(v1)⑶

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

25012400

[2.0, 4.0, 6.0]

25005672

在(1)中，得到的id(v1)=25012400。 

在(2)中，经过v1+=v2后。在(3)中打印id(v1)等于25005672.和之前第一步的不一样了，也就是创建了新的实例。

如果我们想实现就地运算，不生成新的实例，就在v1的基础上想加呢。这就需要实现__iadd__方法。当执行+=的时候会自动调用__iadd__方法，而如果没有实现__iadd__方法，则会自动调用__add__方法

def __iadd__(self, other):

    if type(other) == list:

        pairs=itertools.izip_longest(self.x,other,fillvalue=0)

    else:

        pairs=itertools.izip_longest(self.x,other.x,fillvalue=0)

    i=0

    for p in pairs:

        self.x[i]=p[0]+p[1]

        i+=1

    return self

在__iadd__方法中，返回的是self. 再来看下执行结果：

E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter13.py

25274544

Vector([2.0, 4.0, 6.0])

25274544

得到的实例是同一样