面向对象类的特殊成员方法

Posted 2020-10-03 有的事，必须自己去领悟~

类的特殊成员方法：
1.__doc__ : 打印类下面的注释

2.__module__和__class__:
from lib.aa import C
输出类被导出的模块名lib.aa，输出类的模块名和类名<class lib.aa.C>

3.__init__和__del__
注：析构方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，
所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的

4.__call__ 对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo(object):
    def __init__(self):
        print("__init__")
    def __call__(self, *args, **kwargs):
        print("__call__")


f = Foo()  #输出__init__
f()        #输出__call__

5.__dict__方法，查看类或对象中所有成员字典形式

class Province:
 
    country = \'China\'
 
    def __init__(self, name, count):
        self.name = name
        self.count = count
 
    def func(self, *args, **kwargs):
        print \'func\'
 
# 获取类的成员，即：静态字段、方法、
print Province.__dict__
# 输出：{\'country\': \'China\', \'__module__\': \'__main__\', \'func\': <function func at 0x10be30f50>, \'__init__\': <function __init__ at 0x10be30ed8>, \'__doc__\': None}
 
obj1 = Province(\'HeBei\',10000)
print obj1.__dict__
# 获取 对象obj1 的成员
# 输出：{\'count\': 10000, \'name\': \'HeBei\'}
 
obj2 = Province(\'HeNan\', 3888)
print obj2.__dict__
# 获取 对象obj1 的成员
# 输出：{\'count\': 3888, \'name\': \'HeNan\'}

6.__str__:打印对象的时候，打印返回__str__的返回值

class Dog(object):
    def __init__(self, name):
        self.name = name
        self.__food = None
    def __str__(self):
        return self.name

d = Dog("labuladuo")
print(d)  # labaladuo

7.__getitem__、__setitem__、__delitem__:字典封装成一个实例，对用户来说以为访问的是字典，实际上是实例，可以进行权限控制等

class Foo(object):
    def __getitem__(self, key):
        print(\'__getitem__\', key)

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

    def __delitem__(self, key):
        print(\'__delitem__\', key)


obj = Foo()

result = obj[\'k1\']  # 自动触发执行 __getitem__
obj[\'k2\'] = \'alex\'  # 自动触发执行 __setitem__
del obj[\'k1\']       # 自动触发执行 __delitem__

8。__new__和__metaclass__

#type创建Foo
#普通方式：

class Foo(object):    
    def __init__(self,name)
        self.name=name    
    def fun(self):
        print("func.....",self.name)
 
#特殊方式：
def __init__(self,name)
    self.name=name

def func(self):
    print("func.....")

Foo = type("Foo",(object,),{"fun":func,
                            "__init__":__init__})
f = Foo("alex")
f.fun()

Foo类本身也是一个对象，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。可以看出是type类

So ，记住，类 是由 type 类实例化产生

那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？

答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。

f=Foo()的过程可以看做，先创建Foo对象，再调用它的metaclass中的__call__方法。Python2中的特性