python 类的定义 实例化 实例完后初始化

先来看看 类的__init__, 类的__new__ , 元类的__new__的执行顺序

class TMetaclass(type):
    def __new__(cls,name,bases,attrs):
        print('Metaclass new')
        return type.__new__(cls,name,bases,attrs)

class T(metaclass=TMetaclass):
    def __init__(self, *args, **kwargs):
        print('class init')
        return super().__init__(*args, **kwargs)
    def __new__(cls):
        print('class new')
        return super().__new__(cls)

Metaclass new

只定义,没有实例化,也会调用 metaclass new, 感觉就是静态语言中的编译类的定义, 不过python可是非常动态的控制类的定义

类的理解: 在大多数编程语言中，类就是一组用来描述如何生成一个对象的代码段。

但是在python这种动态语言中,不仅如此,类也是一种对象. 由type等元类创建的一种对象.

而且这种对象具有根据它创建其它对象(类实例)的能力.

alias_T =T  #把类当对象,赋值 拷贝等操作
t = alias_T() 

class new
class init

观察上面的输出, 因为类这个对象已经通过元类来创建出来了,

接下类就是 调用类这个对象的__new__,创建类实例,然后再通过__init__初始化类实例

def echo_something(self):
    print('print from new Attribute')
T.echo = echo_something  #动态的给类这个变量增加成员方法(属性)
t.echo()

print from new Attribute

总之

__new__是静态方法 init是实例方法

元类 : 类的定义阶段

类的__new__ : 对象的创建阶段

类的__init__: 对象创建之后

下面是元类实现单例

class Singleton(type): #这也是个类 他实例化出来的对象就是一个类
    def __init__(self, *args, **kw): #
        print("metaclass __init__")
        self.__instance = None  # 这里的self就是元类创建出来的实例,也就是类Test
        super().__init__(*args, **kw)

    def __new__(cls,name,bases,attrs):
        print ("metaclass __new__")
        return type.__new__(cls,name,bases,attrs)
    
    def __call__(self,*args,**kw): #对元类的实例即类进行调用的时候
        if not self.__instance:
            self.__instance = super().__call__(*args, **kw) 
        return self.__instance
        
        

class Test(object,metaclass =Singleton):
    def __init__(self,name): #其实只调用了一次 返回同一个对象
        self.name = name
        
   
t1 = Test('Tom')
t2 = Test('Jim')
print(t1 is t2)
print(t1.name,t2.name) 

metaclass __new__
metaclass __init__
True
Tom Tom