Python3 操作符重载方法示例


Posted in Python onNovember 23, 2017

基础知识

实际上,“运算符重载”只是意味着在类方法中拦截内置的操作……当类的实例出现在内置操作中,Python自动调用你的方法,并且你的方法的返回值变成了相应操作的结果。以下是对重载的关键概念的复习:

  1. 运算符重载让类拦截常规的Python运算。
  2. 类可重载所有Python表达式运算符
  3. 类可以重载打印、函数调用、属性点号运算等内置运算
  4. 重载使类实例的行为像内置类型。
  5. 重载是通过特殊名称的类方法来实现的。

换句话说,当类中提供了某个特殊名称的方法,在该类的实例出现在它们相关的表达式时,Python自动调用它们。正如我们已经学习过的,运算符重载方法并非必须的,并且通常也不是默认的;如果你没有编写或继承一个运算符重载方法,只是意味着你的类不会支持相应的操作。然而,当使用的时候,这些方法允许类模拟内置对象的接口,因此表现得更一致。

以下代码以Python3.6.1为例

操作符重载方法: 类(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)

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持三水点靠木。

Python 相关文章推荐
python启动办公软件进程(word、excel、ppt、以及wps的et、wps、wpp)
Apr 09 Python
Python算法之栈(stack)的实现
Aug 18 Python
Python Sqlite3以字典形式返回查询结果的实现方法
Oct 03 Python
python实现协同过滤推荐算法完整代码示例
Dec 15 Python
python版微信跳一跳游戏辅助
Jan 11 Python
Python3.5面向对象编程图文与实例详解
Apr 24 Python
11个Python Pandas小技巧让你的工作更高效(附代码实例)
Apr 30 Python
Python中新式类与经典类的区别详析
Jul 10 Python
Python 实现加密过的PDF文件转WORD格式
Feb 04 Python
pyqt5数据库使用详细教程(打包解决方案)
Mar 25 Python
Jupyter加载文件的实现方法
Apr 14 Python
Django框架之路由用法
Jun 10 Python
Python3安装Scrapy的方法步骤
Nov 23 #Python
Python 和 JS 有哪些相同之处
Nov 23 #Python
深入理解Python分布式爬虫原理
Nov 23 #Python
Python实现希尔排序算法的原理与用法实例分析
Nov 23 #Python
Python 用Redis简单实现分布式爬虫的方法
Nov 23 #Python
Python3 伪装浏览器的方法示例
Nov 23 #Python
python学习笔记之列表(list)与元组(tuple)详解
Nov 23 #Python
You might like
PHP实现文件安全下载
2006/10/09 PHP
探讨:如何使用PHP实现计算两个日期间隔的年、月、周、日数
2013/06/13 PHP
php提高脚本性能的4个技巧
2020/08/18 PHP
node.js中的fs.appendFile方法使用说明
2014/12/17 Javascript
jQuery中prev()方法用法实例
2015/01/08 Javascript
简介JavaScript中setUTCSeconds()方法的使用
2015/06/12 Javascript
关于js里的this关键字的理解
2015/08/17 Javascript
Ext JS框架程序中阻止键盘触发回退或者刷新页面的代码分享
2016/06/07 Javascript
Bootstrap CSS组件之按钮组(btn-group)
2016/12/17 Javascript
详谈$.data()的用法和作用
2017/02/13 Javascript
JS实现图片预加载之无序预加载功能代码
2017/05/12 Javascript
详解如何在项目中使用jest测试react native组件
2018/02/09 Javascript
深入浅析js原型链和vue构造函数
2018/10/25 Javascript
vue实现的请求服务器端API接口示例
2019/05/25 Javascript
基于JQuery实现页面定时弹出广告
2020/05/08 jQuery
[51:15]完美世界DOTA2联赛PWL S2 PXG vs Magma 第一场 11.21
2020/11/24 DOTA
python赋值操作方法分享
2013/03/23 Python
Python迭代器和生成器介绍
2015/03/06 Python
Python复制文件操作实例详解
2015/11/10 Python
Python实现的用户登录系统功能示例
2018/02/05 Python
基于python的ini配置文件操作工具类
2019/04/24 Python
对python中的装包与解包实例详解
2019/08/24 Python
浅析Python 中的 WSGI 接口和 WSGI 服务的运行
2020/12/09 Python
意大利灯具购物网站:Lampade.it
2018/10/18 全球购物
数控加工专业毕业生自荐信
2013/09/27 职场文书
通信工程毕业生自荐信
2013/11/01 职场文书
《月迹》教学反思
2014/02/19 职场文书
班主任经验交流材料
2014/12/16 职场文书
小学运动会前导词
2015/07/20 职场文书
2016年寒假见闻
2015/10/10 职场文书
小公司融资,商业计划书的8切记
2019/07/15 职场文书
2019送给家人们的中秋节祝福语
2019/08/15 职场文书
python文件名批量重命名脚本实例代码
2021/04/22 Python
python开发实时可视化仪表盘的示例
2021/05/07 Python
redis复制有可能碰到的问题汇总
2022/04/03 Redis
vue实现拖拽交换位置
2022/04/07 Vue.js