首页
所有分类
TAGS
文字工具 EMOJI BIBLE
编程 Python

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)

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

Python3 操作符重载方法示例

- Author -

LZ_Luzhuo

声明：登载此文出于传递更多信息之目的，并不意味着赞同其观点或证实其描述。

Python 相关文章推荐
讲解Python中的标识运算符
May 14 Python
在Mac OS上搭建Python的开发环境
Dec 24 Python
Python 通过URL打开图片实例详解
Jun 01 Python
用python实现百度翻译的示例代码
Mar 09 Python
Python Series从0开始索引的方法
Nov 06 Python
python+selenium实现自动抢票功能实例代码
Nov 23 Python
Python中shapefile转换geojson的示例
Jan 03 Python
如何更优雅地写python代码
Jul 02 Python
Pytorch使用MNIST数据集实现CGAN和生成指定的数字方式
Jan 10 Python
使用python 的matplotlib 画轨道实例
Jan 19 Python
pytorch加载自己的图像数据集实例
Jul 07 Python
详解python实现可视化的MD5、sha256哈希加密小工具
Sep 14 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
监听(2) KVM(1) 项目打包(2) vue-cli3.x(1) Yolov5(1) vue-router-link(1) TimePickerView(1) watch(1) Jmerte(1) scss(1)
You might like
mysql中存储过程、函数的一些问题
2007/02/14 PHP
PHP下常用正则表达式整理
2010/10/26 PHP
php数组去重实例及分析
2013/11/26 PHP
thinkPHP自动验证、自动添加及表单错误问题分析
2016/10/17 PHP
PHP数组访问常用方法解析
2020/09/05 PHP
js获取事件源及触发该事件的对象
2013/10/24 Javascript
js获取当前路径的简单示例代码
2014/01/08 Javascript
jQuery中before()方法用法实例
2014/12/25 Javascript
jquery实现公告翻滚效果
2015/02/27 Javascript
JS非Alert实现网页右下角“未读信息”效果弹窗
2015/09/26 Javascript
学习Javascript闭包（Closure）知识
2016/08/07 Javascript
JavaScript ES6中CLASS的使用详解
2016/11/22 Javascript
JS对象的深度克隆方法示例
2017/03/16 Javascript
浅谈js中的this问题
2017/08/31 Javascript
react实现菜单权限控制的方法
2017/12/11 Javascript
js消除图片小游戏代码
2019/12/11 Javascript
详解Vue中的自定义指令
2020/12/07 Vue.js
Python遍历文件夹和读写文件的实现代码
2016/08/28 Python
浅谈Django学习migrate和makemigrations的差别
2018/01/18 Python
Python3 requests文件下载 期间显示文件信息和下载进度代码实例
2019/08/16 Python
关于django 1.10 CSRF验证失败的解决方法
2019/08/31 Python
对django layer弹窗组件的使用详解
2019/08/31 Python
Windows10下 python3.7 安装 facenet的教程
2019/09/10 Python
Django后台管理系统的图文使用教学
2020/01/20 Python
pycharm激活码快速激活及使用步骤
2020/03/12 Python
Python实现Excel自动分组合并单元格
2021/02/22 Python
HTML5引入的新数组TypedArray介绍
2012/12/24 HTML / CSS
HTML5语义化元素你真的用对了吗
2019/08/22 HTML / CSS
英国知名美妆护肤在线商城：Zest Beauty
2018/04/24 全球购物
医学求职自荐信
2014/06/21 职场文书
学校读书活动总结
2014/06/30 职场文书
后勤管理员岗位职责
2014/08/27 职场文书
2014迎接教师节演讲稿
2014/09/10 职场文书
护士年终考核评语
2014/12/31 职场文书
2015年化验员工作总结
2015/04/10 职场文书
Python爬取奶茶店数据分析哪家最好喝以及性价比
2022/09/23 Python