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中使用PIL库实现图片高斯模糊实例
Feb 08 Python
Python中的defaultdict模块和namedtuple模块的简单入门指南
Apr 01 Python
利用Python绘制数据的瀑布图的教程
Apr 07 Python
python中闭包Closure函数作为返回值的方法示例
Dec 17 Python
浅谈Python中的bs4基础
Oct 21 Python
Python3.5基础之NumPy模块的使用图文与实例详解
Apr 24 Python
Python3.7 新特性之dataclass装饰器
May 27 Python
Python实现决策树并且使用Graphviz可视化的例子
Aug 09 Python
python logging添加filter教程
Dec 24 Python
Python读取yaml文件的详细教程
Jul 21 Python
python实现简单贪吃蛇游戏
Sep 29 Python
Python 快速验证代理IP是否有效的方法实现
Jul 15 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
Can't create/write to file 'C:\WINDOWS\TEMP\...MYSQL报错解决方法
2011/06/30 PHP
php输出全球各个时区列表的方法
2015/03/31 PHP
php-fpm.conf配置文件中文说明详解及重要参数说明
2018/10/10 PHP
jquery 屏蔽一个区域内的所有元素,禁止输入
2009/10/22 Javascript
用js实现控件的隐藏及style.visibility的使用
2013/06/14 Javascript
JavaScript代码简单实现求杨辉三角给定行的最大值
2013/10/29 Javascript
Javascript中的delete操作符详细介绍
2014/06/06 Javascript
javascript动态控制服务器控件实例
2014/09/05 Javascript
asp知识整理笔记3(问答模式)
2015/09/27 Javascript
原生js编写autoComplete插件
2016/04/13 Javascript
解析JavaScript面向对象概念中的Object类型与作用域
2016/05/10 Javascript
jquery实现侧边栏左右伸缩效果的示例
2017/12/19 jQuery
解决layui中的form表单与button的点击事件冲突问题
2018/08/15 Javascript
Vuex 使用 v-model 配合 state的方法
2018/11/13 Javascript
js getBoundingClientRect使用方法详解
2019/07/17 Javascript
vue穿梭框实现上下移动
2021/01/29 Vue.js
[03:01]2014DOTA2国际邀请赛 DC:我是核弹粉,为Burning和国土祝福
2014/07/13 DOTA
[36:52]DOTA2真视界:基辅特锦赛总决赛
2017/05/21 DOTA
Python文件操作类操作实例详解
2014/07/11 Python
将Python中的数据存储到系统本地的简单方法
2015/04/11 Python
使用C#配合ArcGIS Engine进行地理信息系统开发
2016/02/19 Python
Python 中字符串拼接的多种方法
2018/07/30 Python
python绘制无向图度分布曲线示例
2019/11/22 Python
Python Scrapy框架:通用爬虫之CrawlSpider用法简单示例
2020/04/11 Python
用pandas划分数据集实现训练集和测试集
2020/07/20 Python
浅谈CSS3 box-sizing 属性 有趣的盒模型
2019/04/02 HTML / CSS
HTML5 Canvas API中drawImage()方法的使用实例
2016/03/25 HTML / CSS
基于html5实现的图片墙效果
2014/10/16 HTML / CSS
Expedia爱尔兰:酒店、机票、租车及廉价假期
2017/01/02 全球购物
薇诺娜官方网上商城:专注敏感肌肤
2017/05/25 全球购物
出纳工作岗位责任制
2014/02/02 职场文书
会计岗位职责范本
2014/03/07 职场文书
文明班集体申报材料
2014/05/23 职场文书
第二批党的群众路线教育实践活动总结报告
2014/10/30 职场文书
2015公务员年度考核评语
2015/03/25 职场文书
Go获取两个时区的时间差
2022/04/20 Golang