Python代码的执行顺序(包含类及其魔术方法)

想问一下Python的代码运行顺序。
就下面这段代码：


class Enum(type):
    _init = {}
    print("40:I'm Enum")
    def __init__(self, name, base, class_dict):
        super(Enum, self).__init__(name, base, class_dict)
        print(id(self))

    def __new__(cls, *args, **kwargs):
        c = super().__new__(cls, *args, **kwargs)
        print('47:enum')
        print(args, kwargs)
        print(id(cls), id(c))
        return c


class Server(object, metaclass=Enum):
    print("54:I'm Server")
    def __init__(self, host, port):
        self.host = host
        self.port = port

    def __new__(cls, *args, **kwargs):
        c = super().__new__(cls)
        print('61:Server')
        return c


class SingleMetaClass(type):
    print("66:I'm SingleMetaClass")
    _dct = {}
    _init = {}

    def __init__(self, class_name, base, class_dict):
        self._init[self] = class_dict.get('__init__', None)
        super(SingleMetaClass, self).__init__(class_name, base, class_dict)

    def __call__(self, *args, **kwargs):
        if self._init[self] is None:
            key = self
        else:
            key = (self, args, repr(kwargs))
        if self._dct.get(key) is None:
            self._dct[key] = super().__call__(*args, **kwargs)
        return self._dct[key]


class Coon(metaclass=SingleMetaClass):
    print("85:Coon")
    def __init__(self, a, b):
        print(a, b)


if __name__ == '__main__':
    Server('localhost', '8000')
    print(Coon(1, b=2))
    print(Coon(1, b=2))
    print(Coon(1, 3))

运行结果：

img

通过结果解释运行顺序即可，感谢。

之前看了这篇文章https://blog.csdn.net/weixin_44793743/article/details/126336444
结果还是有些问题。

首先，class中有静态的代码块，所以class一加载print就开始执行了
最先执行的是Enum，因为它写在最前面，最先加载，所以先打印40：
然后是54:
这里使用了MetaClass元类，它的创建过程本身就很复杂，先创建父类，再利用父类对象创建子类
在创建过程中，new方法在创建之前执行，init方法在创建之后执行
注意，一直到此时Server类都没有真正被创建，所以它的new并不执行
前面都走完了才开始加载后面两个类，执行顺序和前面类似
要一直到Server('localhost', '8000')创建一个实例，它自己的new才会执行，输出一个61：
再后面是创建coot时执行它自身的new方法

你用debug打一个断点就能看出来他们的执行顺序了，首先，new只会被执行加载一次，类被别的类调用的时候，就会有实例化操作

我debug的

class Enum(type):
    _init = {}
    print("1、40:I'm Enum 初始化调用")
    def __init__(self, name, base, class_dict):
        super(Enum, self).__init__(name, base, class_dict)
        print(id(self))
 
    def __new__(cls, *args, **kwargs):
        c = super().__new__(cls, *args, **kwargs)
        print('3、47:enum  Server继承调用')
        print(args, kwargs)
        print(id(cls), id(c))
        return c
 
 
class Server(object, metaclass=Enum):
    print("2、54:I'm Server 初始化调用")
    def __init__(self, host, port):
        self.host = host
        self.port = port
 
    def __new__(cls, *args, **kwargs):
        c = super().__new__(cls)
        print('6、61:Server Server调用')
        return c
 
 
class SingleMetaClass(type):
    print("4、66:I'm SingleMetaClass  初始化调用")
    _dct = {}
    _init = {}
 
    def __init__(self, class_name, base, class_dict):
        self._init[self] = class_dict.get('__init__', None)
        super(SingleMetaClass, self).__init__(class_name, base, class_dict)
 
    def __call__(self, *args, **kwargs):
        if self._init[self] is None:
            key = self
        else:
            key = (self, args, repr(kwargs))
        if self._dct.get(key) is None:
            self._dct[key] = super().__call__(*args, **kwargs)
        return self._dct[key]
 
 
class Coon(metaclass=SingleMetaClass):
    print("5、85:Coon 初始化调用")
    def __init__(self, a, b):
        print(a, b)
 
 
if __name__ == '__main__':
    Server('localhost', '8000')
    print("7、print(a, b)")
    print("8、",Coon(1, b=2))
    print("9、相同类地址未实例化调用print(a, b)")
    print("10、",Coon(1, b=2))
    print("11、print(a, b)")
    print("12、",Coon(1, 3))