python运算符重载2

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

1、重载构造函数和减法运算__init__,__sub__

    #file  number.py

    class
Number:

        def
__init__(self,data):

            self.data =
data

        def
__sub__(self,other):

            return
Number(self,self.data-other)

2、索引和分片:实现__getitem__方法的类可以实现索引和分片

    class
Indexer:

        def
__getitem__(self,index):

            return
index**2

    x =
Indexer()

    print(x[2])  #输出:4

    for
i in
range(5):

        print(x[i],end=‘ ‘#输出:0,1,4,9

        

    或者

    class
Index:

        data =
[1,2,3,4,5]

        def
__getitem__(self,index):

            print("index:",index)

            return
self.data[index]

    __getitem__也是一种重载的迭代方式,可以用于:成员测试关系in,列表解析,内置函数maplisttuple,以及类型构造方法都会自动调用__getitem__

3、迭代器对象:__iter__,__next__

    尽管__getitem__也实现了迭代方法,但是一般通常先尝试__iter__方法,然后在尝试__getitem__方法来对对象进行迭代

    迭代环境是通过内置函数iter调用,__iter__方法来实现的。而这种方法返回一个迭代器,如果提供了,python就会重复调用这个迭代器的__next__方法,直到发生StopIteration.如果没有找到__iter__方法,python就会调用__getitem__,就会通过索引来取值,直到发生IndexError 

     例如:

    class
Myiterator:

    def
__init__(self,wrapped):

        self.wrapped =
wrapped

        self.offset =
0

    def
__iter__(self):

        return
self

    def
__next__(self):

        if
self.offset >=
len(self.wrapped):

            raise
StopIteration

        else
:

            item =
self.wrapped[self.offset]

            self.offset +=
1

            return
item

     要返回多个迭代对象,__iter__只需要替换    新的状态对象,而不是返回self.

     例如:

     class
SkipIterator:

        def
__init__(self,wrapped):

            self.wrapped =
wrapped

            self.offset =
0

        def
__next__(self):

            if
self.offset >=
len(self.wrapped):

                raise
StopIteration

            else:

                item =
self.wrapped[self.offset]

                self.offset +=
1

                return
item

     class
SkipObject:

        def
__init__(self,wrapped):

            self.wrapped =
wrapped

        def
__iter__(self):

            return
SkipIterator(self.wrapped)

            

4、成员关系:__contains__,__iter__,__getitem__

    当用in判断成员关系时,可以如果__contains__存在就用这个,如果不存在就使用__iter__,如果__iter__也不存在,则使用__getitem__

    class
MyContains:

        def
__init__(self,data):

            self.data =
data

        def
__contains__(self,x)

            return
x in
self.data

5、属性引用:__getattr__,__setattr__

    __getattr__拦截属性点运算,当对未定义的属性名称和实例进行点号运算时,就会用这个属性名称作为字符串调用这个方法。

    class
empty:

        def
__getattr__(self,attrname):

            if
attrname =
‘age‘:

                return
40

            else:

                raise
AttributeError,attrname

    x =
empty()

    print(x.age) #输出:40

    #print(x.name)  报错

    在这个理由,x和empty本身都没有属性,所以对x.age会调用__getattr__方法,则self赋值为实例x,而attrname赋值为age。

    

    __setattr__:如果定义了这个方法,则调用self.attr =
value会变成self.__setattr__(‘attr‘,value),要注意,在__setattr__中对任何self赋值时,都会调用__setattr__,导致了无穷循环,如果想用这个方法,则通过对字典属性的索引来赋值任何实例属性。也就是说self.__dict__[‘attr‘]=value,而不是self.attr=value

    例如:

    class
accesscontrol:

        def
__setattr__(self,attr,value):

            if
attr =
value:

                self.__dict__[attr] =
value

            else:

                raise
AttributeError,attr+‘not allowed‘

  

python运算符重载2,码迷,mamicode.com

时间: 2024-10-08 01:48:34

python运算符重载2的相关文章

Python运算符重载

运算符重载是指在方法(双下划线的特殊方法)中拦截内置的操作--当类的实例出现在内置操作中,Python会自动调用自定义的方法,并且返回自定义方法的操作结果. 可以让类拦截常规的Python运算. 可调用对象:__call__() 函数:内置函数.自定义函数.def.lambda 类 类方法 函数的属性: __doc__ __name__ __dict__ __code__ __globals__ 方法的属性: __doc__ __name__ __func__ __class__ __self_

Python——运算符重载(1)

运算符重载 关键概念: 1.运算符重载让类拦截常规的Python运算. 2.类可重载所有的Python表达式运算符. 3.类也可重载打印.函数调用.属性点号运算等内置运算. 4.重载使类实例的行为像内置类型. 5.重载是通过特殊名称的类方法来实现的. 运算符重载只是意味着在类方法中拦截内置的操作--当类的实例出现在内置操作中,Python自动调用你的方法,并且你的方法的返回值变成了相应操作的结果. =================================================

Python 运算符重载 [转载]

构造函数与表达式: __init__, __sub__ 常见运算符重载方法 method overload call __init__ 构造函数 对象创建: X = Class(args) __del__ 析构函数 X对象收回 __add__ 云算法+ 如果没有_iadd_, X+Y, X+=Y __or__ 运算符| 如果没有_ior_,X|Y, X|=Y _repr__, __str__ 打印,转换 print(X),repr(X),str(X) __call__ 函数调用 X(*args,

Python 运算符重载

构造函数与表达式: __init__, __sub__ 常见运算符重载方法 method reload call __init__ 构造函数 对象创建: X = Class(args) __del__ 析构函数 X对象收回 __add__ 云算法+ 如果没有_iadd_, X+Y, X+=Y __or__ 运算符| 如果没有_ior_,X|Y, X|=Y _repr__, __str__ 打印,转换 print(X),repr(X),str(X) __call__ 函数调用 X(*args, *

python 的重载

python 的重载主要包括方法重载和运算符重载.1.python 方法重载: 其他的语言一般对于方法重载的话,主要是根据参数的类型不同或者是数量不同来区分同名的方法.而python则比较特殊,它本身是动态语言,方法的参数是没有类型的,当调用传值的时候才确定参数的类型,故对参数类型不同的方法无需考虑重载.对参数数量不同的方法,则(大多数情况下)可以采用参数默认值来实现.比如你可以定义函数的默认值:def info(x,y,z=1): pass2.python 运算符重载: 在C#中,我们通过使用

Python 正确重载运算符

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 15.0px Helvetica } 有些事情让我不安,比如运算符重载.我决定不支持运算符重载,这完全是个人选择,因为我见过太多 C++ 程序员滥用它. --James Gosling Java 之父 p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 15.0px Helvetica } 运算符重载的作用是让用户定义的对象使用中缀运算符(如 + 和 |)或一元运算

Python 3 之 运算符重载详解

基础知识 实际上,"运算符重载"只是意味着在类方法中拦截内置的操作--当类的实例出现在内置操作中,Python自动调用你的方法,并且你的方法的返回值变成了相应操作的结果.以下是对重载的关键概念的复习: 运算符重载让类拦截常规的Python运算. 类可重载所有Python表达式运算符 类可以重载打印.函数调用.属性点号运算等内置运算 重载使类实例的行为像内置类型. 重载是通过特殊名称的类方法来实现的. 换句话说,当类中提供了某个特殊名称的方法,在该类的实例出现在它们相关的表达式时,Pyt

Python面向对象运算符重载

运算符重载的概念如下: 运算符重载让类拦截常规的Python运算: 类可重载所有Python表达式运算符: 类也可重载打印.函数调用.属性点号运算等内置运算: 重载是类实例的行为想内置类型: 重载是通过提供特殊名称的类方法来实现的: 常见的运算符重载方法 方法 重载 调用 __init__ 构造函数 对象建立:X = Class(args) __del__ 解析函数 X对象收回 __add__ 运算符+ 如果没有__iadd__,X+Y,X+=Y __or__ 运算符或 如果没有__ior__

【Python】面向对象的运算符重载

面向对象的编程中可以对运算符进行重载,使运算符可以对该类的实例进行操作. 重载方法的一般格式如下: 1 def __运算符名__(self, other): 2 运算符语句 比较常用的运算符重载有三类:二元算术运算符重载.反向算术运算符重载.比较运算符重载.一元运算符重载 1 二元算术运算符的重载: 2 方法名                  运算符和表达式      说明 3 __add__(self,rhs)        self + rhs      加法 4 __sub__(self