元类(metaclass)

目录

• 一、什么是元类
  • 1.1 元类的继承关系图
• 二、 class底层原理分析
  • 2.1 通过type直接产生类，不用class关键字
  • 2.2 通过exec内置函数和type创建类，不用class关键字
• 三、 自定义元类来控制类的产生
• 四、通过自定义元类控制类的调用过程
• 五、有了元类之后的属性查找

• 元类属于python面向对象编程的深层魔法，99%的人都不得要领，一些自以为搞明白元类的人其实也只是自圆其说、点到为止，从对元类的控制上来看就破绽百出、逻辑混乱，今天我就来带大家来深度了解python元类的来龙去脉。
• 笔者深入浅出的背后是对技术一日复一日的执念，希望可以大家可以尊重原创，为大家能因此文而解开对元类所有的疑惑而感到开心！！！

一、什么是元类

• 在python中一切皆对象，那么我们用class关键字定义的类本身也是一个对象，负责产生该对象的类称之为元类，即元类可以简称为类的类

• 元类是负责产生类的，所以我们学习元类或者自定义元类的目的：是为了控制类的产生过程，还可以控制对象的产生过程

• type是内置的一个元类，所有的类都是由type实例化得到的，产生类的类，叫元类

• type的实例就是type，并且它还继承了object类，而object类也是type类的实例。

class Person:
    def __init__(self,name):
        self.name = name

p = Person("xc")

# 使用type查看 对象 所属的类
print(type(p))

print(type(Person))
print(type(dict))
print(type(str))
print(type(list))
print(type(object))
print(type(type))

<class 'main.Person'>
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>

由此可知：type类是产生所有类的元类

1.1 元类的继承关系图

二、 class底层原理分析

• class 类名 会把类构造出来(类也是个对象)
• 实际上是：class 底层就是调用type来实例化产生类（对象），需要传一堆参数。只不过class关键字帮我们干了这个事情
• type(object_or_name, bases, dict)

object_or_name：类的名字，是个字符串
bases：是它的所有父类，基类
dict:名称空间,是一个字典

2.1 通过type直接产生类，不用class关键字

# 自己手动去创建
def __init__(self,name):
    self.name=name
Person = type('Person',(object,),{'age':'18','__init__':__init__})
print(Person.__dict__)

{'age': '18', 'init': <function init at 0x0000029BF58D28C8>, 'module': 'main', 'dict': <attribute 'dict' of 'Person' objects>, 'weakref': <attribute 'weakref' of 'Person' objects>, 'doc': None}

2.2 通过exec内置函数和type创建类，不用class关键字

l={}
exec('''
age='18'
def __init__(self,name):
    self.name=name
def score(self):
    print('分数是100')
''',{},l)   # 三个参数：要执行的内容，全局名称空间是个字典，局部名称空间（执行的结果会放到这里）
Person=type('Person',(object,),l)
print(Person.__dict__)  # 类中属性
p=Person('xc')  # 实例化对象
print(p.name)   # 查看对象属性
print(p.__dict__)   # 对象中属性

{'age': '18', 'init': <function init at 0x000002853A9DC1E0>, 'score': <function score at 0x000002853C81DEA0>, 'module': 'main', 'dict': <attribute 'dict' of 'Person' objects>, 'weakref': <attribute 'weakref' of 'Person' objects>, 'doc': None}
xc

三、 自定义元类来控制类的产生

自定义元类控制类的产生：可以控制类名,可以控制类的继承父类,控制类的名称空间

自定义元类必须继承type，如果一个类继承type， 这种类都叫元类

先写元类，在通过元类去控制类的产生，要在类继承的括号中写上metaclass=元类名表示使用的元类

class Mymeta(type):
    # def __init__(self,*args,**kwargs):	# 正常写法，但是我们已经知道type传递的三个参数的意义
    def __init__(self,name,bases,dic):
        # self 就是Person类
        print(name)		# 创建的类名
        print(bases)	# 继承的所有父类
        print(dic)		# 类中属性，是一个字典
        
        #加限制 控制类名：必须以sb开头
        if not name.startswith('sb'):
            raise Exception('类名没有以sb开头')

        #类必须加注释
        print(self.__dict__['__doc__'])
        doc=self.__dict__['__doc__']
        if not doc:
            #没有加注释
            raise Exception('你的类没有加注释')
#metaclass=Mymeta  指定这个类生成的时候,用自己写的Mymeta这个元类
class Person(object,metaclass=Mymeta):
	age='18'
    def __init__(self,name):
        self.name=name
    def score(self):
        print('分数是100')
p=Person("xc")

Person

(<class 'object'>,)

{'module': 'main', 'qualname': 'Person', 'doc': '\n 注释\n ', 'age': '18', 'init': <function Person.init at 0x000001B97FDF19D8>, 'score': <function Person.score at 0x000001B97FDF1A60>}

Exception: 类名没有以sb开头

四、通过自定义元类控制类的调用过程

控制类的调用过程,实际上在控制:对象的产生 __call__

之前的内容说过,__call__当对象加括号就会调用它。那么现在放到类对象也同样适用。

但只是说过类名（）实例化会先去调用init绑定方法，现在又说call是不是很混乱。

实际上，类名（）实例化是先去调用call方法，再去调用init方法

如：

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        print('xxx')
        return 1

class Person(object,metaclass=Mymeta):
    age='18'
    def __init__(self,name):
        self.name=name
    def score(self):
        print('分数是100')
        
#先触发元类的__call__，再触发init的执行
p=Person('nick')    # 当类对象加括号实际上就是去调用了自定义元类中的__call__方法
print(p)   # 所以p等于1
# print(p.name)   # 没有返回对象，p等于1所以一定会报错

那么，如果像上面那样，不就得不到实例化对象了嘛？

实际上，实例化创建对象是通过call方法中的new方法。这些call方法，new方法，init都是一些魔法方法

但是new方法只会得到一个新的对象，什么都没有的对象。

但我们实例化得到对象的本事是为了共享类中属性和方法，需要绑定上属性和方法。这时候就需要再使用init方法

如：

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        # self 就是Person类
        print(2)
        print(self.mro()) # 类对象的属性查找顺序
        # obj=self.__new__(self)  # 方法1，通过self的new方法创建对象
        obj=object.__new__(self)  # 方法2，通过object的new方法创建对象
        obj.__init__(*args, **kwargs)   # 调用对象的init方法
        return obj

    def __init__(self,*args):
        print(3)
        print(args)
        
class Person(metaclass=Mymeta): # 实际上是先调用元类的call方法，再回调自定义元类的init方法
    age = '18'
    def __init__(self, name):   # 当类实例化生成对象后，会通过call调用init方法
        print(1)
        self.name = name
p = Person(name='xc') # 先调用自定义元类的call方法
print(p.__dict__)
print(p.name)
print(p)

3
('Person', (), {'module': 'main', 'qualname': 'Person', 'age': '18', 'init': <function Person.init at 0x000001E8A59D1AE8>})
2
[<class 'main.Person'>, <class 'object'>]
1
{'name': 'xc'}
xc
<main.Person object at 0x000001E896A80CC0>

仔细阅读代码，根据执行结果查看调用顺序

五、有了元类之后的属性查找

• 类的属性查找顺序：先从类本身中找--->mro继承关系去父类中找---->去自己定义的元类中找--->type中--->报错
• 对象的属性查找顺序：先从对象自身找--->类中找--->mro继承关系去父类中找--->报错