当前位置:Gxlcms > Python > Python运算符重载的代码教程

Python运算符重载的代码教程

时间:2021-07-01 10:21:17 帮助过:68人阅读

这篇文章主要介绍了Python运算符重载详解及实例代码的相关资料,需要的朋友可以参考下

Python运算符重载

Python语言提供了运算符重载功能,增强了语言的灵活性,这一点与C++有点类似又有些不同。鉴于它的特殊性,今天就来讨论一下Python运算符重载。

Python语言本身提供了很多魔法方法,它的运算符重载就是通过重写这些Python内置魔法方法实现的。这些魔法方法都是以双下划线开头和结尾的,类似于X的形式,python通过这种特殊的命名方式来拦截操作符,以实现重载。当Python的内置操作运用于类对象时,Python会去搜索并调用对象中指定的方法完成操作。

类可以重载加减运算、打印、函数调用、索引等内置运算,运算符重载使我们的对象的行为与内置对象的一样。Python在调用操作符时会自动调用这样的方法,例如,如果类实现了add方法,当类的对象出现在+运算符中时会调用这个方法。

常见运算符重载方法

方法名

重载说明

运算符调用方式

init

构造函数

对象创建: X = Class(args)

del

析构函数

X对象收回

add/sub

加减运算

X+Y, X+=Y/X-Y, X-=Y

or

运算符|

X|Y, X|=Y

_repr/str

打印/转换

print(X)、repr(X)/str(X)

call

函数调用

X(*args, **kwargs)

getattr

属性引用

X.undefined

setattr

属性赋值

X.any=value

delattr

属性删除

del X.any

getattribute

属性获取

X.any

getitem

索引运算

X[key],X[i:j]

setitem

索引赋值

X[key],X[i:j]=sequence

delitem

索引和分片删除

del X[key],del X[i:j]

len

长度

len(X)

bool

布尔测试

bool(X)

lt, gt,

le, ge,

eq, ne

特定的比较

依次为X<Y,X>Y,X<=Y,X>=Y,

X==Y,X!=Y

注释:(lt: less than, gt: greater than,

le: less equal, ge: greater equal,

eq: equal, ne: not equal

radd

右侧加法

other+X

iadd

实地(增强的)加法

X+=Y(or else add)

iter, next

迭代

I=iter(X), next()

contains

成员关系测试

item in X(X为任何可迭代对象)

index

整数值

hex(X), bin(X), oct(X)

enter, exit

环境管理器

with obj as var:

get, set,

delete

描述符属性

X.attr, X.attr=value, del X.attr

new

创建

在init之前创建对象

下面对常用的运算符方法的使用进行一下介绍。

构造函数和析构函数:init和del

它们的主要作用是进行对象的创建和回收,当实例创建时,就会调用init构造方法。当实例对象被收回时,析构函数del会自动执行。

  1. >>> class Human():
  2. ... def init(self, n):
  3. ... self.name = n
  4. ... print("init ",self.name)
  5. ... def del(self):
  6. ... print("del")
  7. ...
  8. >>> h = Human('Tim')
  9. init Tim
  10. >>> h = 'a'
  11. del

加减运算:add和sub

重载这两个方法就可以在普通的对象上添加+-运算符操作。下面的代码演示了如何使用+-运算符,如果将代码中的sub方法去掉,再调用减号运算符就会出错。

  1. >>> class Computation():
  2. ... def init(self,value):
  3. ... self.value = value
  4. ... def add(self,other):
  5. ... return self.value + other
  6. ... def sub(self,other):
  7. ... return self.value - other
  8. ...
  9. >>> c = Computation(5)
  10. >>> c + 5
  11. 10
  12. >>> c - 3
  13. 2

对象的字符串表达形式:repr和str

这两个方法都是用来表示对象的字符串表达形式:print()、str()方法会调用到str方法,print()、str()和repr()方法会调用repr方法。从下面的例子可以看出,当两个方法同时定义时,Python会优先搜索并调用str方法。

  1. >>> class Str(object):
  2. ... def str(self):
  3. ... return "str called"
  4. ... def repr(self):
  5. ... return "repr called"
  6. ...
  7. >>> s = Str()
  8. >>> print(s)
  9. str called
  10. >>> repr(s)
  11. 'repr called'
  12. >>> str(s)
  13. 'str called'

索引取值和赋值:getitem, setitem

通过实现这两个方法,可以通过诸如 X[i] 的形式对对象进行取值和赋值,还可以对对象使用切片操作。

  1. >>> class Indexer:
  2. data = [1,2,3,4,5,6]
  3. def getitem(self,index):
  4. return self.data[index]
  5. def setitem(self,k,v):
  6. self.data[k] = v
  7. print(self.data)
  8. >>> i = Indexer()
  9. >>> i[0]
  10. 1
  11. >>> i[1:4]
  12. [2, 3, 4]
  13. >>> i[0]=10
  14. [10, 2, 3, 4, 5, 6]

设置和访问属性:getattr、setattr

我们可以通过重载getattr和setattr来拦截对对象成员的访问。getattr在访问对象中不存在的成员时会自动调用。setattr方法用于在初始化对象成员的时候调用,即在设置dict的item时就会调用setattr方法。具体例子如下:

  1. class A():
  2. def init(self,ax,bx):
  3. self.a = ax
  4. self.b = bx
  5. def f(self):
  6. print (self.dict)
  7. def getattr(self,name):
  8. print ("getattr")
  9. def setattr(self,name,value):
  10. print ("setattr")
  11. self.dict[name] = value
  12. a = A(1,2)
  13. a.f()
  14. a.x
  15. a.x = 3
  16. a.f()

上面代码的运行结果如下,从结果可以看出,访问不存在的变量x时会调用getattr方法;当init被调用的时候,赋值运算也会调用setattr方法。

  1. setattr
  2. setattr
  3. {'a': 1, 'b': 2}
  4. getattr
  5. setattr
  6. {'a': 1, 'x': 3, 'b': 2}

迭代器对象: iter, next

Python中的迭代,可以直接通过重载getitem方法来实现,看下面的例子。


  1. >>> class Indexer:
  2. ... data = [1,2,3,4,5,6]
  3. ... def getitem(self,index):
  4. ... return self.data[index]
  5. ...
  6. >>> x = Indexer()
  7. >>> for item in x:
  8. ... print(item)
  9. ...
  10. 1
  11. 2
  12. 3
  13. 4
  14. 5
  15. 6

通过上面的方法是可以实现迭代,但并不是最好的方式。Python的迭代操作会优先尝试调用iter方法,再尝试getitem。迭代环境是通过iter去尝试寻找iter方法来实现,而这种方法返回一个迭代器对象。如果这个方法已经提供,Python会重复调用迭代器对象的next()方法,直到发生StopIteration异常。如果没有找到iter,Python才会尝试使用getitem机制。下面看一下迭代器的例子。


  1. class Next(object):
  2. def init(self, data=1):
  3. self.data = data
  4. def iter(self):
  5. return self
  6. def next(self):
  7. print("next called")
  8. if self.data > 5:
  9. raise StopIteration
  10. else:
  11. self.data += 1
  12. return self.data
  13. for i in Next(3):
  14. print(i)
  15. print("-----------")
  16. n = Next(3)
  17. i = iter(n)
  18. while True:
  19. try:
  20. print(next(i))
  21. except Exception as e:
  22. break

程序的运行结果如下:

  1. next called
  2. 4
  3. next called
  4. 5
  5. next called
  6. 6
  7. next called
  8. -----------
  9. next called
  10. 4
  11. next called
  12. 5
  13. next called
  14. 6
  15. next called

可见实现了iter和next方法后,可以通过for in的方式迭代遍历对象,也可以通过iter()和next()方法迭代遍历对象。

【相关推荐】

1. 特别推荐:“php程序员工具箱”V0.1版本下载

2. Python免费视频教程

3. Python基础入门教程

以上就是Python运算符重载的代码教程的详细内容,更多请关注Gxl网其它相关文章!

人气教程排行