python 重心法 python重载加法

转载

mob64ca140fd7c1 2024-02-22 16:58:47

文章标签 python 重心法 python 运算符重载单链表加减乘除 文章分类 Python 后端开发

通过前几篇的积累，节点类添加了创建、拼接和删除的功能，本篇尝试一下使用这些已定义过的函数方法快速重载链表间的算术运算：

加法

相当于用之前的 push,append,cat 方法重载加法，也是非常恰当的。

加法重载的约定

当两个“加数”都为链表或节点时，后者拼接到前者尾部；当有一个非节点“加数”时，作为追加元素来处理。头插法为左加，追加法为右加，左、右加法分别用 __add__() 和 __radd__() 方法来重载。没有重载前，对Node类型做加法会报错的；如果只重载左加法不重载右加法，python 也只能识别 “node + 1” 为把1追加到node尾部；但不能识别出 “1 + node” 的用意，不支持的类型加法，并报错：TypeError: unsupported operand type(s) for +: 'int' and 'Node' 。

左加法

先增加一个左加法重载，用Node.build快速实现，不别写代码了：

def __add__(self,*data):
if self.val is None:
return Node.build(*data)
return

完成的代码如下：

class Node():
    def __init__(self, value=None, Next=None):
        self.val = value
        self.next = Next
        if type(self.next)==Node and self.next.val==None:
            self.next=None
 
    def __repr__(self):
        return f'Node({self.val}->{self.next})'
    
    def __str__(self):
        return f'{self.val}->{self.next}'
 
    def __len__(self):
        if self.val is None:
            return 0
        length,ptr = 0,self
        while ptr is not None:
            length += 1
            ptr = ptr.next
        return length 
 
    def __eq__(self, other):
        ptr1,ptr2 = self,other
        if len(ptr1)!=len(ptr2):
            return False
        while ptr1 is not None:
            if ptr1.val!=ptr2.val:
                return False
            ptr1 = ptr1.next
            ptr2 = ptr2.next
        else:
            return True
 
    def size(self):
        return self.__len__()
 
    @property
    def length(self):
        return self.size()
 
    @property
    def value(self):
        return self.val
 
    @property
    def values(self):
        ret,ptr = [],self
        while ptr is not None:
            ret.append(ptr.val)
            ptr = ptr.next
        return ret
 
    def pprint(self):
        items = [str(i) for i in self.values]
        if items==[]:
            print('None->None')
        elif len(items)==1:
            print(f'{items[0]}->None')
        else:
            print('->'.join(items)+'->None')
 
    def isNode(node):
        return isinstance(node,Node) and isinstance(node.next,(Node,type(None)))
 
    def build(*data, split=True):
        '''把数据转换成节点链表'''
        lst,ret = [],Node()
        for val in data:
            if type(val) is str:
                if not split:
                    lst.append(val)
                    continue
                if str=='':
                    continue
                try:
                    num = int(val)
                    lst.extend([int(_) for _ in val])
                except:
                    lst.extend([_ for _ in val])
            elif hasattr(val,'__iter__'):
                lst.extend([_ for _ in val])
            elif type(val) is Node:
                if val is not None:
                    lst.extend(val.values)
            else:
                lst.append(val)
        ret = Node()
        for i in lst[::-1]:
            ret = Node(i, ret)
        return ret
 
    def copy(node):
        ret = Node()
        ptr1,ptr2 = node,ret
        while ptr1 is not None:
            ptr2.next = Node(ptr1.val)
            ptr1,ptr2 = ptr1.next,ptr2.next
        return ret.next

    def __add__(self,*data):
        if self.val is None:
            return Node.build(*data)
        return Node.build(self,*data)

测试结果：

'''
>>> Node(1)+Node(2)
Node(1->2->None)
>>> Node(1)+Node(2)+3
Node(1->2->3->None)
>>> Node(1)+Node(2)+3+4
Node(1->2->3->4->None)
>>> 1+Node(2)
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
1+Node(2)
TypeError: unsupported operand type(s) for +: 'int' and 'Node'
>>>
'''

右加法

当节点在右面做加法时会报错，所以要增加一个右加法，再看效果：

def __radd__(self,*data):
return
'''
>>> 1+Node(2)
Node(1->2->None)
>>> 1+Node(2,Node(3))
Node(1->2->3->None)
>>> 1+2+Node(3)
Node(3->3->None)
>>> (1,2)+Node(3)
Node(1->2->3->None)
>>>
"'

可以成功实现，但要注意：加法是从左到右逐个计算的，如上红色标注的会先计算1+2的；所以使用右加法时，想在左边用头插法追加多个元素时，一定要用括号把后面的先加；或者选用元组或列表等可迭代的对象作追加元素的容器；或者索性在最左边给个空节点，变回到左加法。如下三种方式都可以：

>>> 1+(2+(3+Node(4)))
Node(1->2->3->4->None)
>>> [1,2,3]+Node(4)
Node(1->2->3->4->None)
>>> Node()+1+2+3+Node(4)
Node(1->2->3->4->None)
>>>

注意：左加法指“被加数”在左边，要加的“数”在右边；右加法反之。

自加法

即重载 __iadd__() 方法，默认的话自动继承自左加法，直接看测试：

>>> (1,2)+Node(3)
Node(1->2->3->None)
>>> node = (1,2)+Node(3)
>>> node += 4
>>> node
Node(1->2->3->4->None)
>>>

若要把它重载成右加法，则在类里__radd__后加一行“__iadd__ = __radd__”：

def __radd__(self,*data):
        return Node.build(*data,self)

    __iadd__ = __radd__

'''
>>> node = (1,2)+Node(3)
>>> node += 4
>>> node
Node(4->1->2->3->None)
>>>
'''

减法

相当于前几篇中定义的删除方法，但重载减法之前要检测一下“被减数”中包不包含“减数”。

包含运算 in

直接调用.values属性来“伪实现”这个功能。

def __contains__(self, other):
        if type(other) is not Node:
            return other in self.values
        sub,subs = other.values,self.values
        if len(sub)>len(subs): return False
        subs=[subs[i:i+len(sub)] for i in range(len(subs)-len(sub)+1)]
        return sub in subs

测试结果：
>>> node = Node()+1+2+3+4+5
>>> 1 in node
True
>>> 2 in node
True
>>> 5 in node
True
>>> 0 in node
False
>>> n1 = Node(2,Node(3))
>>> n2 = Node(2,Node(4))
>>> n1 in node
True
>>> n2 in node
False
>>>

左减法

链表间的减法就不像加法一样还要分左右，只有“被减数”减去“减数”，重载 __sub__即可：

def __sub__(self, other):
        if other not in self:
            raise BaseException("A-B Error:B not in A")
        subs = self.values
        if type(other) is not Node:
            idx = subs.index(other)
            subs = subs[:idx]+subs[idx+1:]
            return Node.build(subs)
        sub = other.values
        tmp = [subs[i:i+len(sub)] for i in range(len(subs)-len(sub)+1)]
        idx = tmp.index(sub)
        subs = subs[:idx]+subs[idx+len(sub):]
        return Node.build(subs)

'''
>>> a = Node()+range(1,10)
>>> a
Node(1->2->3->4->5->6->7->8->9->None)
>>> a - 2 -3 - 5 - 7
Node(1->4->6->8->9->None)
>>> a
Node(1->2->3->4->5->6->7->8->9->None)
>>> a - Node.build(3,4,5,6)
Node(1->2->7->8->9->None)
>>> a
Node(1->2->3->4->5->6->7->8->9->None)
>>> a -= Node.build(3,4,5,6)
>>> a
Node(1->2->7->8->9->None)
>>>

注：直接调用build()函数和values属性伪实现了减法效果。做减法前需要先判断一下“被减数”是否包含“减数”，包含则减去，不包含则会报错。

自减法

自减法__iadd__自动继承__add__不用另行写代码。

乘法

左乘法

乘法约定为数乘，即乘以一个整数n，链表的长度扩大n倍；另外尝试一下非数乘的情况：即当两个链表相乘时，用它们的数据域对应相乘的积做各节点的值。

def __mul__(self, other):
        if type(other) is Node:
            n1,n2 = self.values,other.values
            product = [p[0]*p[1] for p in zip(n1,n2)]
            return Node.build(product)
        if other<0 or type(other) is not int:
            raise TypeError("other is a non-negetive Integer")
        if other==0:return Node()
        ret = self.copy()
        for _ in range(1,other):
            self += ret
        return self

    __rmul__ = __mul__


'''
>>> a = Node() + range(1,3)
>>> a * 0
Node(None->None)
>>> a * 1
Node(1->2->None)
>>> a * 2
Node(1->2->1->2->None)
>>> a * 5
Node(1->2->1->2->1->2->1->2->1->2->None)
>>> 
>>> 3 * a
Node(1->2->1->2->1->2->None)
>>> a
Node(1->2->None)
>>> a *= 5
>>> a
Node(1->2->1->2->1->2->1->2->1->2->None)
>>> 
>>> 
>>> a = Node() + range(1,8)
>>> b = Node(2) * 7
>>> a * b
Node(2->4->6->8->10->12->14->None)
>>> b * a
Node(2->4->6->8->10->12->14->None)
>>> 
'''

右乘法

右乘也要重载，否则右乘时number * Node 会报错，添加一行：__rmul__ = __mul__ 即可。

自乘法

自乘法__imul__自动继承__mul__不用另行写代码。

除法

除法有两种：除和整除，分别是 __truediv__ 、__floordiv__，暂且把两种除法都看作是和整数作运算，并约定：链表除以一个整数n，即长度变为原来1/n。

def __truediv__(self, i):
        if i<0 or type(i) is not int:
            raise TypeError("i must be a positive Integer")
        if i==1: return self
        if self.next is None: return Node()
        num = self.values
        num = num[:len(num)//i]
        return Node.build(num)
    
    __floordiv__ = __truediv__


'''
>>> a = Node()+range(1,3)
>>> a *= 5
>>> a / 5
Node(1->2->None)
>>> a
Node(1->2->1->2->1->2->1->2->1->2->None)
>>> a/3
Node(1->2->1->None)
>>> a = Node()+range(1,3)
>>> a *= 6
>>> a
Node(1->2->1->2->1->2->1->2->1->2->1->2->None)
>>> a / 2
Node(1->2->1->2->1->2->None)
>>> a
Node(1->2->1->2->1->2->1->2->1->2->1->2->None)
>>> a // 3
Node(1->2->1->2->None)
>>> a
Node(1->2->1->2->1->2->1->2->1->2->1->2->None)
>>> a /= 3
>>> a
Node(1->2->1->2->None)
>>> a /= 2
>>> a
Node(1->2->None)
>>> 
'''

同样 __itruediv__、__ifloordiv__ 自动继承不用另行写代码。

左移和右移

对一个整数来说，有按二进制位进行左移和右移的运算，相当于一个整数乘以或除以2；

对一个链表来说，调用上篇的 rotate(n) 方法来重载左移、右移运算（对应的内置方法 __lshift__ 和 __rshift__ ），模仿出来的效果还是蛮逼真的：

def __lshift__(self, n):
        return self.rotate(n)

    def __rshift__(self, n):
        return self.rotate(-n)

测试效果：

>>> a = Node()+1+2+3+4+5
>>> a
Node(1->2->3->4->5->None)
>>> a>>1
Node(5->1->2->3->4->None)
>>> a
Node(1->2->3->4->5->None)
>>> a>>3
Node(3->4->5->1->2->None)
>>> a
Node(1->2->3->4->5->None)
>>>

参与运算的链表不发生变化，如要改变值的用 >>= 或 <<= 来赋值：

>>> b = Node()+1+2+3+4+5
>>> b
Node(1->2->3->4->5->None)
>>> b >>= 2
>>> b
Node(4->5->1->2->3->None)
>>> b >>= 1
>>> b
Node(3->4->5->1->2->None)
>>>

或者直接在代码中加入覆盖原链表的代码：

def __lshift__(self, n):
        ret = self.rotate(n)
        self.val,self.next = ret.val,ret.next
        return ret

    def __rshift__(self, n):
        ret = self.rotate(-n)
        self.val,self.next = ret.val,ret.next
        return ret

'''
>>> node = Node.build(1,2,3,4,5)
>>> node
Node(1->2->3->4->5->None)
>>> node >> 1
Node(5->1->2->3->4->None)
>>> node >> 2
Node(3->4->5->1->2->None)
>>> node >> 3
Node(5->1->2->3->4->None)
>>> node
Node(5->1->2->3->4->None)
>>> node << 6
Node(1->2->3->4->5->None)
>>> node << 1
Node(2->3->4->5->1->None)
>>> node << 1
Node(3->4->5->1->2->None)
>>> node >> 2
Node(1->2->3->4->5->None)
>>> node
Node(1->2->3->4->5->None)
>>>
'''

本篇的内容纯粹是为了学习如何实现运算符的重载，除了包含运算in比较有用，其它都没什么实用性，可以试着用正规的遍历方法来实现它的功能。另外还有一些__neg__、 __pos__、 __abs__、__mod__、__divmod__、__pow__、__round__、__invert__、__and__ 、 __or__ 、 __xor__，以及众多的比较运算符，都可以用来重载对应的功能。

——*** 本篇完 ***——

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。