Python-元类

一、类

类由type创建

1.1、创建一个类  传统方式

class Cht(object):
    v1 = 123

    def func1(self):
        return 666

1.2、非传统式

"""
-类名-继承类-成员
"""
c = type("Cht", (object,), {"v1": 123, "func1": lambda self: 666})
 

二、元类

概念：指定类由谁创建

2.1、type创建类

class Foo(object):
    pass

2.2、元类指定  通常继承type

class MyType(type):
    pass

# Foo类由MyType创建
class Foo(object, metaclass=MyType):
    pass

三、元类 -MyTupe创建类

class MyType(type):
    # 创建类走的流程，先new执行完走init

     def __new__(cls, *args, **kwargs):
        print("new")
        # 为F00创建类
        new_cls = super().__new__(cls, *args, **kwargs)
        print(new_cls)
        return new_cls   

    def __init__(self, *args, **kwargs):
        print("init")
        super().__init__(*args, **kwargs)

   

    def __call__(self, *args, **kwargs):
        # 1、调用自己类的__new__方法去创建对象
        empty_object = self.__new__(self)
        # 2、调用自己类的__init__方法去初始化
        self.__init__(empty_object, *args, **kwargs)
        print("Foo()->call")
        return empty_object

# Foo类由MyType创建
# Foo类相当于MyType的一个对象
# Foo()->MyType对象()
class Foo(object, metaclass=MyType):
    def __init__(self, name):
        self.name = name

    def __call__(self, *args, **kwargs):
        print("v1()->call")

    pass

v1 = Foo("cht")
print(v1)
v1()
print(v1.name)

"""
new
<class '__main__.Foo'>
init
Foo()->call
<__main__.Foo object at 0x000002DA5D0BD790>
v1()->call
cht
"""

四、元类-实现单例模式

class MyType(type):
    # -name 类名 -bases 继承谁 -attrs成员
    def __init__(self, name, bases, attrs):
        super().__init__(name, bases, attrs)
        # 初始类变量
        self.instance = None

    def __call__(self, *args, **kwargs):
        # 判断是否有对象，有不创建，没有则创建
        if not self.instance:
            self.instance = self.__new__(self)
        # 2、调用自己类的__init__方法去初始化
        self.__init__(self.instance, *args, **kwargs)
        return self.instance

class Singleton(object, metaclass=MyType):
    pass

# 继承Singleton 实现单例
class Foo(Singleton):
    # # 类变量 创建的对象
    # instance = None
    pass

v1 = Foo()  # 创建对象并设置instance并返回
v2 = Foo()
print(v1)  # 内存地址一样
print(v2)
print(Foo.instance)

"""
<__main__.Foo object at 0x000001FA28F7D610>
<__main__.Foo object at 0x000001FA28F7D610>
<__main__.Foo object at 0x000001FA28F7D610>
"""