ToB企服应用市场:ToB评测及商务社交产业平台

标题: Python 元类详解 [打印本页]
作者: 张春    时间: 2022-9-2 12:15
标题: Python 元类详解
一、Type介绍

在Python中一切皆对象，类它也是对象，而元类其实就是用来创建类的对象（由于一切皆对象，所以元类其实也是一个对象）。
先来看这几个例子：
例1：
  1. In [1]: type(12)
  2. Out[1]: int
复制代码
通过 type 可以查看对象的类型，也就是查看对象是那一类的，这里可以看出来 12 是 int 类型的也就是整数类。由于一切皆对象，那么我们也可以查看 int 是属于哪一个类型的。
  1. In [2]: type(int)
  2. Out[2]: type
复制代码
通过这样的操作可以看出来 int 是 type 类型的，也就是说 int 类是 type 类实例化得到的对象。按照这样的思路在来看看 type 类是什么类型。
  1. In [3]: type(type)
  2. Out[3]: type
复制代码
从上面可以看出来 type 是 type 类型的对象
例2：在来看这样一个规律
  1. In [4]: class Foo:
  2.    ...:     pass
  3.    ...:
  5. In [5]: f = Foo()
  7. In [6]: type(f)
  8. Out[6]: __main__.Foo
  10. In [7]: type(Foo)
  11. Out[7]: type
  13. In [8]: type(type)
  14. Out[8]: type
复制代码
由上可以看出，实例 f 是 Foo 类的对象，Foo 这个自定义的类它是 type 类型的，并且 type 也是 type 类型的。
总结：
从上面的规律可以看出，所有的类终归都是由 type 实例化得来的，它就是最元始的，同时它也是一个类，所以也可以称之为元类（Metaclass）
实例、类、元类之间的关系如图所示：

二、Type 使用方法

在 help(type) 显示的帮助文档中，可以看到这样两种使用方法；
  1. class type(object)
  2. |  type(object) -> the object's type
  3. |  type(name, bases, dict, **kwds) -> a new type
复制代码
第一种：直接带入对象，返回对象的类型，也是我们最常用的。
第二种：type(name, bases, dict, **kwds) 返回一个新的类型，也就是一个新的类。
实例1：用 type 创建一个名为 Foo1 的类
  1. In [10]: Foo1 = type("Foo1", (), {})
  3. In [11]: Foo1.__bases__
  4. Out[11]: (object,)
复制代码
虽然没有给 bases 赋值，但是 Python 中所有的类都是以 object 为基类，所以查看类 Foo1 的父类，会得到这样一个结果。PS：__bases__查看父类。
也可以将 Foo1 实例化，就能看见 f 是 Foo1 类型，并且仿照之前的样子查找它的类型，可以一直查找到元类 type。
  1. In [12]: f = Foo1()
  3. In [13]: f.__class__
  4. Out[13]: __main__.Foo1
  6. In [14]: f.__class__.__class__
  7. Out[14]: type
复制代码
__class__ 是类的一个内置属性，表示类的类型，也是类的实例的属性，表示实例对象的类
实例2：利用元类 type 所创建的类 Bar 继承了 Foo1 和 Book 两个类
  1. In [15]: class Book:
  2.     ...:     def __new__(cls, *args, **kwargs):
  3.     ...:         cls.website = 'www.cnblogs.com'
  4.     ...:         return super().__new__(cls)
  5.     ...:
  7. In [16]: Bar = type('Bar', (Foo1, Book), {'name': 'python'})
  9. In [17]: b = Bar()
  11. In [18]: b.name
  12. Out[18]: 'python'
  14. In [19]: b.website
  15. Out[19]: 'www.cnblogs.com'
  17. In [20]: b.__class__
  18. Out[20]: __main__.Bar
  20. In [21]: b.__class__.__class__
  21. Out[21]: type
  22.    
  23. In [22]: Bar.__bases__
  24. Out[22]: (__main__.Foo1, __main__.Book)
  26. In [23]: Bar.__dict__
  27. Out[23]: mappingproxy({'name': 'python',
  28.               '__module__': '__main__',
  29.               '__doc__': None,
  30.               'website': 'www.cnblogs.com'})
复制代码
上述中 Bar 类除了在创建时设置的 name 外，还有从 Book 类继承来的 website，实例化后也可以读取到 name 和 website 两个属性的值，并且实例的类型是 Bar。
三、Metaclass

虽然使用第二种方法能定义出所需要的各种类型的类，但是，在实践中，这种形式并不常用，而是用这种形式；
  1. In [24]: class Meta(type):
  2.     ...:     pass
  3.     ...:
  5. In [25]: class Spam(metaclass=Meta):
  6.     ...:     pass
  7.     ...:
  9. In [26]: s = Spam()
复制代码
类 Meta 继承了 type ，也可以称为元类，而 Spam 类与之前定义的类的不同之处就在于，类名后括号内添加了参数 metaclass 来说明或指定元类，这样就利用了元类 Meta 创建了类 Spam。
总结描述：
  1. In [27]: s.__class__
  2. Out[27]: __main__.Spam
  4. In [28]: s.__class__.__class__
  5. Out[28]: __main__.Meta
  7. In [29]: s.__class__.__class__.__class__
  8. Out[29]: type
复制代码
下面做一个更详细的实例，来了解 Spam 与 Meta 之间的关系。
  1. class Meta(type):
  3.     def __new__(cls, name, bases, attrs):
  4.         print("执行了元类 Meta!")
  5.         attrs['author'] = "xiaoyang-sir"
  6.         spam_class = super().__new__(cls, name, bases, attrs)
  7.         print(spam_class)
  8.         return spam_class
  12. class Spam(metaclass=Meta):
  14.     def __init__(self, website):
  15.         self.website = website
  17.         
  18. print(Spam.author)
  21. """
  22. Out：
  23.     执行了元类 Meta!
  24.     <class '__main__.Spam'>
  25.     xiaoyang-sir
  27. """
复制代码
从上面程序运行的的结果可以直接看出当该段程序运行的时候，虽然并没有直接实例化 Spam 类，但是由于指定了 Meta 为 Spam 类的元类 ，所以 Meta 会直接实例化 Spam 类，并且元类 Meta 的构造方法 __new__() 中定义的属性 author 已经成为了实例 Spam 类的类属性。
那么接下来将 Spam 实例化后，也就能得到想要的结果。
  1. s = Spam('www.cnblogs.com')
  2. print(s.website)
  3. print(s.author)
  5. """
  6. Out:
  7.     执行了元类 Meta!
  8.     <class '__main__.Spam'>
  9.     www.cnblogs.com
  10.     xiaoyang-sir
  11. """
复制代码
四、元类实现单例模式

元类实现单例模式可以在元类中定义 __call__() 方法，__call__() 方法主要是在对象加括号被调用的时候执行 __call__() 方法中的内容。由于类是一个对象，所以在类加括号的时候就会执行元类中的__call__()方法。
  1. class Meta(type):
  2.     __instance = None
  4.     def __call__(cls, *args, **kwargs):
  5.         if not cls.__instance:
  6.             cls.__instance = type.__call__(cls, *args, **kwargs)
  7.         return cls.__instance
  10. class Spam(metaclass=Meta):
  11.     pass
  14. x = Spam()
  15. y = Spam()
  16. print(x)
  17. print(y)
  18. print(x==y)
  21. """
  22. Out:
  23.     <__main__.Spam object at 0x00000251A51E7E50>
  24.     <__main__.Spam object at 0x00000251A51E7E50>
  25.     True
  26. """
复制代码
作者：Mr-Yang
出处：https://www.cnblogs.com/XiaoYang-sir/p/16524775.html
版权：本作品采用「署名-非商业性使用-相同方式共享 4.0 国际」许可协议进行许可。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4