【转】Python3 操作符重载方法

Python3 操作符重载方法

本文由 Luzhuo 编写,转发请保留该信息.
原文: http://blog.csdn.net/Rozol/article/details/70769628
以下代码以Python3.6.1为例
Less is more!
操作符重载方法: 类(class)通过使用特殊名称的方法(len(self))来实现被特殊语法(len())的调用
#coding=utf-8
# specialfuns.py 操作符重载方法
# 类(class)通过使用特殊名称的方法(__len__(self))来实现被特殊语法(len())的调用

# 构造 与 析构 方法
class demo1:

    # 构造方法, 对象实例化时调用
    def __init__(self):
        print("构造方法")

    # 析构方法, 对象被回收时调用
    def __del__(self):
        print("析构方法")


# new
class demo2(object):
    # __init__之前调用, 一般用于重写父类的__new__方法, 具体使用见 类 文章的 元类 代码部分(http://blog.csdn.net/rozol/article/details/69317339)
    def __new__(cls):
        print("new")
        return object.__new__(cls)


# 算术运算
class demo3:
    def __init__(self, num):
        self.data = num
    # +
    def __add__(self, other):
        return self.data + other.data
    # -
    def __sub__(self, other):
        return self.data - other.data
    # *
    def __mul__(self, other):
        return self.data * other.data
    # /
    def __truediv__(self, other):
        return self.data / other.data
    # //
    def __floordiv__(self, other):
        return self.data // other.data
    # %
    def __mod__(self, other):
        return self.data % other.data
    # divmod()
    def __divmod__(self, other):
        # 商(10/5),余数(10%5)
        return self.data / other.data, self.data % other.data
    # **
    def __pow__(self, other):
        return self.data ** other.data
    # <<
    def __lshift__(self, other):
        return self.data << other.data
    # >>
    def __rshift__(self, other):
        return self.data >> other.data
    # &
    def __and__(self, other):
        return self.data & other.data
    # ^
    def __xor__(self, other):
        return self.data ^ other.data
    # |
    def __or__(self, other):
        return self.data | other.data


class none:
    def __init__(self, num):
        self.data = num
# 反算术运算符(a+b, 若a不支持算术运算符,则寻找b的算术运算符)(注:位置变换, 在原始函数名前+r)
class demo4:
    def __init__(self, num):
        self.data = num
    # +
    def __radd__(self, other):
        return other.data + self.data
    # -
    def __rsub__(self, other):
        return other.data - self.data
    # *
    def __rmul__(self, other):
        return other.data * self.data
    # /
    def __rtruediv__(self, other):
        return other.data / self.data
    # //
    def __rfloordiv__(self, other):
        return other.data // self.data
    # %
    def __rmod__(self, other):
        return other.data % self.data
    # divmod()
    def __rdivmod__(self, other):
        return other.data / self.data, other.data % self.data
    # **
    def __rpow__(self, other):
        return other.data ** self.data
    # <<
    def __rlshift__(self, other):
        return other.data << self.data
    # >>
    def __rrshift__(self, other):
        return other.data >> self.data
    # &
    def __rand__(self, other):
        return other.data & self.data
    # ^
    def __rxor__(self, other):
        return other.data ^ self.data
    # |
    def __ror__(self, other):
        return other.data | self.data


# 增量赋值运算,(注:位置同原始函数,在原始函数名前+i)
class demo5():
    def __init__(self, num):
        self.data = num
    # +=
    def __iadd__(self, other):
        return self.data + other
    # -=
    def __isub__(self, other):
        return self.data - other
    # *=
    def __imul__(self, other):
        return self.data * other
    # /=
    def __itruediv__(self, other):
        return self.data / other
    # //=
    def __ifloordiv__(self, other):
        return self.data // other
    # %=
    def __imod__(self, other):
        return self.data % other
    # **=
    def __ipow__(self, other):
        return self.data ** other
    # <<=
    def __ilshift__(self, other):
        return self.data << other
    # >>=
    def __irshift__(self, other):
        return self.data >> other
    # &=
    def __iand__(self, other):
        return self.data & other
    # ^=
    def __ixor__(self, other):
        return self.data ^ other
    # |=
    def __ior__(self, other):
        return self.data | other

# 比较运算符
class demo6:
    def __init__(self, num):
        self.data = num
    # <
    def __lt__(self, other):
        return self.data < other.data
    # <=
    def __le__(self, other):
        return self.data <= other.data
    # ==
    def __eq__(self, other):
        return self.data == other.data
    # !=
    def __ne__(self, other):
        return self.data != other.data
    # >
    def __gt__(self, other):
        return self.data > other.data
    # >=
    def __ge__(self, other):
        return self.data >= other.data


# 一元操作符
class demo7:
    def __init__(self, num):
        self.data = num
    # + 正号
    def __pos__(self):
        return +abs(self.data)
    # - 负号
    def __neg__(self):
        return -abs(self.data)
    # abs() 绝对值
    def __abs__(self):
        return abs(self.data)
    # ~ 按位取反
    def __invert__(self):
        return ~self.data
    # complex() 字符转数字
    def __complex__(self):
        return 1+2j
    # int() 转为整数
    def __int__(self):
        return 123
    # float() 转为浮点数
    def __float__(self):
        return 1.23
    # round()  近似值
    def __round__(self):
        return 1.123


# 格式化
class demo8:
    # print() 打印
    def __str__(self):
        return "This is the demo."
    # repr() 对象字符串表示
    def __repr__(self):
        return "This is a demo."
    # bytes() 对象字节字符串表现形式
    def __bytes__(self):
        return b"This is one demo."
    # format() 格式化
    def __format__(self, format_spec):
        return self.__str__()



# 属性访问
class demo9:
    # 获取(不存在)属性
    def __getattr__(self):
        print ("访问的属性不存在")
    # getattr() hasattr() 获取属性
    def __getattribute__(self, attr):
        print ("访问的属性是%s"%attr)
        return attr
    # setattr() 设置属性
    def __setattr__(self, attr, value):
        print ("设置 %s 属性值为 %s"%(attr, value))
    # delattr() 删除属性
    def __delattr__(self, attr):
        print ("删除 %s 属性"%attr)

# ===================================================================
# 描述器(类(test1)的实例出现在属主类(runtest)中,这些方法才会调用)(注:函数调用,这些方法不会被调用)
class test1:
    def __init__(self, value = 1):
        self.value = value * 2
    def __set__(self, instance, value):
        print("set %s %s %s"%(self, instance, value))
        self.value = value * 2
    def __get__(self, instance, owner):
        print("get %s %s %s"%(self, instance, owner))
        return self.value
    def __delete__(self, instance):
        print("delete %s %s"%(self, instance))
        del self.value

class test2:
    def __init__(self, value = 1):
        self.value = value + 0.3
    def __set__(self, instance, value):
        print("set %s %s %s"%(self, instance, value))
        instance.t1 = value + 0.3
    def __get__(self, instance, owner):
        print("get %s %s %s"%(self, instance, owner))
        return instance.t1
    def __delete__(self, instance):
        print("delete %s %s"%(self, instance))
        del self.value

class runtest:
    t1 = test1()
    t2 = test2()

# ---

# 自定义property
class property_my:
    def __init__(self, fget=None, fset=None, fdel=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
    # 对象被获取(self自身, instance调用该对象的对象(demo9), owner调用该对象的对象类对象(demo9))
    def __get__(self, instance, owner):
        print("get %s %s %s"%(self, instance, owner))
        return self.fget(instance)
    # 对象被设置属性时
    def __set__(self, instance, value):
        print("set %s %s %s"%(self, instance, value))
        self.fset(instance, value)
    # 对象被删除时
    def __delete__(self, instance):
        print("delete %s %s"%(self, instance))
        self.fdel(instance)

class demo10:
    def __init__(self):
        self.num = None
    def setvalue(self, value):
        self.num = value
    def getvalue(self):
        return self.num
    def delete(self):
        del self.num
    x = property_my(getvalue, setvalue, delete)

# ===================================================================

# 自定义容器
class lis:
    def __init__(self, *args):
        self.lists = args
        self.size = len(args)
        self.startindex = 0
        self.endindex = self.size
    # len() 容器元素数量
    def __len__(self):
        return self.size;
    # lis[1] 获取元素
    def __getitem__(self, key = 0):
        return self.lists[key]
    # lis[1] = value 设置元素
    def __setitem__(self, key, value):
        pass
    # del lis[1] 删除元素
    def __delitem__(self, key):
        pass
    # 返回迭代器
    def __iter__(self):
        return self
    # rversed() 反向迭代器
    def __reversed__(self):
        while self.endindex > 0:
            self.endindex -= 1
            yield self[self.endindex]
    # next() 迭代器下个元素
    def __next__(self):
        if self.startindex >= self.size:
            raise StopIteration # 控制迭代器结束

        elem = self.lists[self.startindex]
        self.startindex += 1
        return elem

    # in / not in
    def __contains__(self, item):
        for i in self.lists:
            if i == item:
                return True
        return False


# yield 生成器(执行一次返回,下次继续执行后续代码返回)
def yielddemo():
    num = 0
    while 1: # 1 == True; 0 == False
        if num >= 10:
            raise StopIteration
        num += 1
        yield num

# 能接收数据的生成器
def yielddemo_1():
    while 1:
        num = yield
        print(num)


# with 自动上下文管理
class withdemo:
    def __init__(self, value):
        self.value = value
    # 返回值为 as 之后的值
    def __enter__(self):
        return self.value
    # 执行完成,退出时的数据清理动作
    def __exit__(self, exc_type, exc_value, traceback):
        del self.value


if __name__ == "__main__":
    # 构造与析构
    d1 = demo1()
    del d1


    # new
    d2 = demo2()


    # 算术运算符
    d3 = demo3(3)
    d3_1 = demo3(5)
    print(d3 + d3_1)
    print(d3 - d3_1)
    print(d3 * d3_1)
    print(d3 / d3_1)
    print(d3 // d3_1)
    print(d3 % d3_1)
    print(divmod(d3, d3_1))
    print(d3 ** d3_1)
    print(d3 << d3_1)
    print(d3 >> d3_1)
    print(d3 & d3_1)
    print(d3 ^ d3_1)
    print(d3 | d3_1)


    # 反运算符
    d4 = none(3)
    d4_1 = demo4(5)
    print(d4 + d4_1)
    print(d4 - d4_1)
    print(d4 * d4_1)
    print(d4 / d4_1)
    print(d4 // d4_1)
    print(d4 % d4_1)
    print(divmod(d4, d4_1))
    print(d4 ** d4_1)
    print(d4 << d4_1)
    print(d4 >> d4_1)
    print(d4 & d4_1)
    print(d4 ^ d4_1)
    print(d4 | d4_1)


    # 增量赋值运算(测试时注释其他代码)
    d5 = demo5(3)
    d5 <<= 5
    d5 >>= 5
    d5 &= 5
    d5 ^= 5
    d5 |= 5
    d5 += 5
    d5 -= 5
    d5 *= 5
    d5 /= 5
    d5 //= 5
    d5 %= 5
    d5 **= 5
    print(d5)


    # 比较运算符
    d6 = demo6(3)
    d6_1 = demo6(5)
    print(d6 < d6_1)
    print(d6 <= d6_1)
    print(d6 == d6_1)
    print(d6 != d6_1)
    print(d6 > d6_1)
    print(d6 >= d6_1)


    # 一元操作符(测试时注释其他代码)
    d7 = demo7(-5)
    num = +d7
    num = -d7
    num = abs(d7)
    num = ~d7
    print(num)
    print(complex(d7))
    print(int(d7))
    print(float(d7))
    print(round(d7))


    # 格式化
    d8 = demo8()
    print(d8)
    print(repr(d8))
    print(bytes(d8))
    print(format(d8, ""))


    # 属性访问
    d9 = demo9()
    setattr(d9, "a", 1) # => 设置 a 属性值为 1
    print(getattr(d9, "a")) # => a / 访问的属性是a
    print(hasattr(d9, "a")) # => True / 访问的属性是a
    delattr(d9, "a") # 删除 a 属性
    # ---
    d9.x = 100 # => 设置 x 属性值为 100
    print(d9.x) # => x / 访问的属性是x
    del d9.x # => 删除 x 属性


    # 描述器
    r = runtest()
    r.t1 = 100 # =>  <__main__.test1> <__main__.runtest> 100
    print(r.t1) # => 200 /  <__main__.test1> <__main__.runtest> <class '__main__.runtest'>
    del r.t1 # =>  <__main__.test1> <__main__.runtest>
    r.t2 = 200 # => <__main__.test2> <__main__.runtest> 200 / <__main__.test1> <__main__.runtest> 200.3
    print(r.t2) # => 400.6 / <__main__.test2> <__main__.runtest> <class '__main__.runtest'> /  <__main__.test1> <__main__.runtest> <class '__main__.runtest'>
    del r.t2 # <__main__.test2> <__main__.runtest>
    # ---
    # 自定义property
    d10 = demo10()
    d10.x = 100; # => <__main__.property_my> <__main__.demo10> 100
    print(d10.x) # => 100 / <__main__.property_my> <__main__.demo10> <class '__main__.demo10'>
    del d10.x # => <__main__.property_my> <__main__.demo10>
    d10.num = 200;
    print(d10.num) # => 200
    del d10.num


    # 自定义容器(迭代器Iterator)
    lis = lis(1,2,3,4,5,6)
    print(len(lis))
    print(lis[1])
    print(next(lis))
    print(next(lis))
    print(next(lis))
    for i in lis:
        print (i)
    for i in reversed(lis):
        print (i)
    print(3 in lis)
    print(7 in lis)
    print(3 not in lis)
    print(7 not in lis)


    # yield 生成器(可迭代对象Iterable)
    for i in yielddemo():
        print (i)
    # ---
    iters = iter(yielddemo())
    print(next(iters))
    print(next(iters))

    # --- 发送数据给生成器 ---
    iters = yielddemo_1()
    next(iters)
    iters.send(6) # 发送数据并执行
    iters.send(10)


    # with 自动上下文管理
    with withdemo("Less is more!") as s:
        print(s)