一、什么是元类

  在 Python 中，一切皆为对象，即类也是一个对象。type 是内置的元类。我们用 class 关键字定义的所有的类以及内置的类都是由元类 type（内置的元类） 实例化产生的。

class Person:def __init__(self, name, age):self.name = nameself.age = agedef show_info(self):print(f"name: {self.name}, age: {self.age}")print(type(Person))
print(type(int))

当 Python 解释器遇到 class 的时候，实际上会进行调用，其目的是：至少要知道有哪些属性，有哪些方法，然后将这些类属性、方法传递到元类 type 中，进行创建一个对象，这个对象就是我们所谓的类对象。

二、class机制分析

# 1、类名
class_name = "Person"
# 2、类的基类
class_base = (object,)
# 3、执行类体代码拿到类的名称空间
class_dict = {"name": "unknown"}
class_body = """
def __init__(self, name, age):self.name = nameself.age = agedef show_info(self):print(f"name: {self.name}, age: {self.age}")
"""exec(class_body, {}, class_dict)
print(class_dict)# 4、调用元类
Person = type(class_name, class_base, class_dict)
print(Person)# 5、创建对象
p = Person("Sakura", 10)
p.show_info()

# 1、类名
class_name = "Person"
# 2、类的基类
class_base = (object,)
# 3、执行类体代码拿到类的名称空间
def show_info(self):print(f"name: {self.name}")@classmethod
def description(cls):print(f"{cls.name}是一个人")@staticmethod
def static():print("我是一个静态方法")class_dict = {"name": "unknown", "show_info": show_info, "description": description, "static": static}# 4、调用元类
Person = type(class_name, class_base, class_dict)
print(Person)# 5、创建对象
p = Person()
p.show_info()
p.description()
p.static()

三、自定义元类

# 只有继承了type类的类才是元类
class MyMeta(type):# cls当前所在的类，*args、**kwargs调用类时所传入的参数def __new__(cls,*args,**kwargs):print("__new__()方法运行了")print(cls)print(args)print(kwargs)return type.__new__(cls, *args, **kwargs)# __init__()接收的参数是__new__()方法返回的def __init__(self, class_name, class_bases, class_dict):print("__init__()方法运行了")print(self)print(class_name)print(class_bases)print(class_dict)def __call__(self,*args,**kwargs):print(self)print(args)print(kwargs)# MyMeta.__call__()方法会先调用Person类内的__new__()方法obj = self.__new__(self)# MyMeta.__call__()方法内会调用Person类内的__init__()方法self.__init__(obj,*args,**kwargs)# MyMeta.__call__()方法会返回一个初始化好的对象return obj"""
调用MyMeta发生的三件事：1、先造一个空对象，调用类内的__new__()方法，就是调用type.__call__()方法2、调用MyMeta这个类内的__init__()方法，完成初始化对象的操作3、返回初始化好的对象
Person = MyMeta(class_name,class_bases,class_dict)
""""""
类的产生：Person = MyMeta() --> type.__call__()干的三件事：1、type.__call__()方法内会先调用MyMeta类内的__new__()方法2、type.__call__()方法内会调用MyMeta类内的__init__()方法3、type.__call__()方法会返回一个初始化好的对象
"""
class Person(metaclass=MyMeta):def __new__(cls,*args,**kwargs):# 产生真正的对象return object.__new__(cls)def __init__(self,name,age):self.name = nameself.age = agedef show_info(self):print(f"name: {self.name}, age: {self.age}")"""
类的调用：p = Person("Sakura",10) --> MyMeta.__call__()干的三件是1、MyMeta.__call__()方法内会先调用Person类内的__new__()方法2、MyMeta.__call__()方法内会调用Person类内的__init__()方法3、MyMeta.__call__()方法会返回一个初始化好的对象
"""
p = Person("Sakura",10)
print(p)
print(p.__dict__)

# 只有继承了type类的类才是元类
class MyMeta(type):def __new__(cls, class_name, class_base, class_dict):print("__new__()方法运行了")# 方法1：通过type来做类对象的创建return type(class_name, class_base, class_dict)# 方法2：复用type.__init__()方法#return type.__new__(cls, class_name, class_base, class_dict)class Person(metaclass=MyMeta):def __init__(self,name,age):self.name = nameself.age = agedef show_info(self):print(f"name: {self.name}, age: {self.age}")p = Person("Sakura",10)
print(p)
print(p.__dict__)

只要调类，那么会依次调用类内的 __new__() 方法，在调用 __init__() 方法；

如果想要一个对象可以加括号调用，需要在该对象的类中添加一个 __call__() 方法；

四、利用元类实现单例模式

class MyType(type):def __init__(self, name, base, attrs):super().__init__(name, base, attrs)self.instance = Nonedef __call__(self, *args, **kwargs):# 判断是否有对象，有，则不创建，没有，则创建if not self.instance:# 调用自己的那个类的__new__()创建对象self.instance = self.__new__(self)# 调用自己的那个类的__init__()初始化对象self.__init__(self.instance, *args, **kwargs)return self.instanceclass P(metaclass=MyType):passp1 = P()
print(p1)p2 = P()
print(p1)