Python3 操作符重载方法

最新推荐文章于 2022-05-03 12:00:01 发布

Python热爱者

最新推荐文章于 2022-05-03 12:00:01 发布

阅读量306

点赞数 1

文章标签：编程语言 python

原文链接：https://www.jianshu.com/u/8f2987e2f9fb

版权

操作符重载方法: 类(class)通过使用特殊名称的方法(len(self))来实现被特殊语法(len())的调用

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)

算术运算

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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)

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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

格式化

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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)中,这些方法才会调用)(注:函数调用,这些方法不会被调用)

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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)

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

自定义容器

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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 生成器(执行一次返回,下次继续执行后续代码返回)

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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()

算术运算符

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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)

比较运算符

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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))

格式化

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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)

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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)