Python面向对象(特殊成员)

day25

    __init__     类()自动执行
    __del__
    __call__     对象()  类()() 自动执行
    __int__      int(对象)  
    __str__      str()

特殊成员

class Foo:
    def __init__(self):
        print('init')

    def __call__(self, *argc, **kwarge):
        print('call')

obj = Foo()#直接执行__init__

obj()#执行__call__中内容

Foo()()#同上

对象加括号，obj()执行__call__()。

执行结果：

init
call
init
call

Process finished with exit code 0

__str__，__int__

class Foo:
    def __init__(self):
        pass

    def __int__(self):
        return 111

    def __str__(self):
        return "nizhipeng"
obj = Foo()

print(obj, type(obj))

r = int(obj)#自动执行__int__方法，并将返回值给int对象
print(r)

print(str(obj))

类型转换的时候，自动执行__int__,和__str__方法。

执行结果：

nizhipeng <class '__main__.Foo'>
111
nizhipeng

Process finished with exit code 0

自动转换

class Foo:
    def __init__(self, n, a):
        self.name = n
        self.age = a
    def __str__(self):
        return '%s-%s' %(self.name, self.age)

obj = Foo('alex', 18)
print(obj) #obj自动转成了str类型

第9行自动执行了str(obj)。

执行结果：

alex-18

Process finished with exit code 0

__add__

class Foo:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __add__(self, other):
        #self为obj1包含信息（alex，18）
        #other为obj2包含信息（eiro，66）

        '''return self.age + other.age'''
        return Foo(obj1.name, other.age)#对象1的名字，对象2的年龄

    def __del__(self):
        print("析构方法")#对象销毁时执行


obj1 = Foo('alex', 19)
obj2 = Foo('eiro', 66)

r = obj1 + obj2#两个对象相加时，自动执行第一个对象的__add__方法，并且将第二个对象当作参数

print(r.age, type(r))

两个对象相加时，自动执行第一个对象的__add__方法，并且将第二个对象当作参数
执行结果：

66 <class '__main__.Foo'>
析构方法
析构方法
析构方法

Process finished with exit code 0

__dict__

class Foo:

    '''
    注释也是类成员
    '''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.n = 123

obj = Foo('alex', 18)

d = obj.__dict__#通过字典形式显示对象成员
print(d)

ret = Foo.__dict__#通过字典形式显示类成员
print(ret)

__dict__（）可以通过字典显示类成员，和对象成员。注释也是类成员的一部分。

执行结果：

{'name': 'alex', 'age': 18, 'n': 123}
{'__init__': <function Foo.__init__ at 0x7fb7f3155620>, '__doc__': '
    注释也是类成员
    ', '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__module__': '__main__'}
44

Process finished with exit code 0

__getitem__,__setitem__,__delitem__

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        return item+10

    def __setitem__(self, key, value):
        print(key, value)

    def __delitem__(self, key):
        print(key)
li = Foo('alex', 18)
#以索引方式访问对象，执行__getitem__方法

r = li[8]#自动执行li对象类中的__getitem__方法， 8作为参数给item
print(r)#有获取数据属于需要返回值

li[100] = 'aasd'#执行__setitem__(), key为100，value为aasd

del li[999]#执行__delitem__()

以索引方式访问需要以上几种特殊方法。

__setitem__,__delitem__并不获取数据，不需要return。

执行结果：

18
100 aasd
999

Process finished with exit code 0

__iter__

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __iter__(self):
        return iter([11,22,33])#生成迭代器对象
#如果类中有__iter__方法，对象为可迭代对象
#对象.__iter__()的返回值：迭代器
li = Foo('alex', 18)


for i in li:
    print(i)

如果类中有__iter__方法，对象为可迭代对象，iter()生成迭代对象。

执行结果：

11
22
33

Process finished with exit code 0

__new__ 和 __metaclass__

Foo类其实为type类的对象。

所有类默认继承object类。

http://www.cnblogs.com/wupeiqi/p/4766801.html

其中第11节

class MyType(type):
    #self 为 Foo
    def __init__(self, *args, **kwargs):
        print('123')
        pass

    def __call__(cls):
        print('456')

#Foo为MyType对象
class Foo(object,metaclass=MyType):#任何类都继承object类，并使Foo类为type类子类MyType的对象
    def __init__(self):
        print('567')

    def func(self):
        print('hello')

#使Foo类为type类子类MyType的对象，创建Foo对象时会执行类中的__init__()方法
#输出  123

#有__call__方法时输出456，对象加(),执行__call__方法，Foo是MyType的一个对象。
#没有时输出567，Foo类创建obj对象，执行__init__方法。
obj = Foo()

任何类都继承object类，并使Foo类为type类子类MyType的对象
执行结果：

123
456

Process finished with exit code 0