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__': '\n    注释也是类成员\n    ', '__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()生成迭代对象。

执行结果：

Process finished with exit code 

__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('')
         pass

     def __call__(cls):
         print('')

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

     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