增加 metaclass

Author: TheBigFish

metaclass/abc_ABCMeta.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @File  : abc_ABCMeta.py
+# @Author: yubo
+# @Date  : 2019/11/29
+# @Desc  :
+
+import abc
+
+"""
+解释器创建类时，会检测 cls.__abstractmethods__ 是否为空，若不为空，则拒绝创建对象
+
+ABCMeta 利用了一点，在类 TestA 创建时，检测是否含有 @abc.abstractmethod 修饰的成员，即设置了 .__isabstractmethod__ 
+根据各成员生成一个 __abstractmethods__ 集合，若集合不为空，则无法创建示例，即为抽象类
+
+class ABC(metaclass=ABCMeta):
+    pass
+
+ABC 指定元类为 ABCMeta, 故继承 ABC 的类的元类也为 ABCMeta
+
+class TestA(abc.ABC) 等同于
+class TestA(metaclass=ABCMeta)
+"""
+class TestA(abc.ABC):
+
+    a = 1
+    b = "a"
+
+    @abc.abstractmethod
+    def func1(self):
+        pass
+
+
+class TestB(TestA):
+    @abc.abstractmethod
+    def func2(self):
+        pass
+
+
+class TestC(TestB):
+    @abc.abstractmethod
+    def func3(self):
+        pass
+
+'''
+The notion is correct; the ABCMeta code does not distinguish between a abstractproperty and a abstractmethod.
+
+Both of these decorators add an attribute to the decorated item, .__isabstractmethod__, 
+which ABCMeta uses to add an .__abstractmethods__ attribute (a frozenset) to the ABC you defined. 
+The object type then guards against creating an instance of any class where any of the names listed 
+in .__abstractmethods__ does not have a concrete implementation. No checks are made for functions versus properties there.
+
+To illustrate:
+
+>>> from abc import *
+>>> class C:
+...     __metaclass__ = ABCMeta
+...     @abstractmethod
+...     def abstract_method(self): pass
+...     @abstractproperty
+...     def abstract_property(self): return 'foo'
+... 
+>>> C.__abstractmethods__
+frozenset(['abstract_method', 'abstract_property'])
+By creating new overrides for these in a subclass, the ABCMeta class will find fewer methods or properties with 
+the . __isabstractmethod__ attribute, thus making the resulting __abstractmethods__ set smaller; once the set is empty 
+you can create instances of such a subclass.
+
+These checks are made in the ABCMeta.__new__ constructor and no checks are made to match descriptor types:
+
+cls = super(ABCMeta, mcls).__new__(mcls, name, bases, namespace)
+# Compute set of abstract method names
+abstracts = set(name
+             for name, value in namespace.items()
+             if getattr(value, "__isabstractmethod__", False))
+for base in bases:
+    for name in getattr(base, "__abstractmethods__", set()):
+        value = getattr(cls, name, None)
+        if getattr(value, "__isabstractmethod__", False):
+            abstracts.add(name)
+cls.__abstractmethods__ = frozenset(abstracts)
+You'd have to create a subclass of ABCMeta that overrides the __new__ method, and check that any abstract method or 
+property named on a base class is indeed matched with a non-abstract method or property on cls instead.
+'''

metaclass/metaclass_0.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @File  : metaclass_0.py
+# @Author: yubo
+# @Date  : 2019/11/18
+# @Desc  :
+
+
+class Meta(type):
+    """
+    自定义元类
+    """
+    def __new__(cls, name, bases, d):
+        """
+        使用自定义元类，最终都是要调用 type 生成类实例
+        return super(Meta, cls).__new__(cls, name, bases, d)
+        等同于
+        type.__new__(cls, name, bases, d)
+        """
+        print("call Meta __new__")
+        d["a"] = "a"
+        return super(Meta, cls).__new__(cls, name, bases, d)
+
+    def __init__(self, *args, **kwargs):
+        print("call Meta __init__")
+        super(Meta, self).__init__(*args, **kwargs)
+
+
+class MetaNormal0(object):
+    """
+    我们写下如下代码时：
+
+    class Foo(object):
+        pass
+    实际上，解释器将其解释为：
+
+    Foo = type('Foo', (object,), {})
+    """
+    pass
+
+
+class MetaNormal1(metaclass=Meta):
+    """
+    如果定义了元类
+    class MyMetaType(type):
+          pass
+    class Foo(metaclass=MyMetaType):
+        pass
+
+    解释器解释到class Foo(...)的时候，就会转换为：
+    Foo = MyMetaType('Foo', (object,), {})
+
+    此时调用 MyMetaType.__new__, MyMetaType.__init__, 生成类MyMetaType 的实例化对象：Foo
+    """
+    pass
+
+
+"""
+MetaNormal1 的元类是 Meta, 父类是 object
+"""
+print(type(MetaNormal1))
+print(MetaNormal1.__mro__)
+"""
+call Meta __new__
+call Meta __init__
+<class '__main__.Meta'>
+(<class '__main__.MetaNormal1'>, <class 'object'>)
+"""

metaclass/metaclass_1.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @File  : metaclass_1.py
+# @Author: yubo
+# @Date  : 2019/11/18
+# @Desc  :
+
+class_definition = type('class_name', (), {})   # ➊
+
+print(type(class_definition))
+
+
+class Meta(type):   # ➋
+    def __new__(cls, name, bases, d):
+        print("call Meta __new__")
+        d["a"] = "a"
+        return super(Meta, cls).__new__(cls, name, bases, d)
+
+    def __init__(self, *args, **kwargs):
+        print("call Meta __init__")
+        super(Meta, self).__init__(*args, **kwargs)
+
+
+print(type(class_definition))   # ➌
+print(class_definition)     # ➍
+print(Meta)
+print(type(Meta))
+
+meta_definition = Meta('meta', (), {})  # ➎
+print(meta_definition)
+print(type(meta_definition))        # ➏
+
+
+class MetaNormal0(Meta):
+    """
+    我们写下如下代码时：
+
+    class Foo(object):
+        pass
+    实际上，解释器将其解释为：
+
+    Foo = type('Foo', (object,), {})
+    """
+    pass
+
+
+class MetaNormal1(metaclass=Meta):
+    """
+    如果定义了元类
+    class MyMetaType(type):
+          pass
+    class Foo(metaclass=MyMetaType):
+        pass
+
+    解释器解释到class Foo(...)的时候，就会转换为：
+    Foo = MyMetaType('Foo', (object,), {})
+    """
+    pass
+
+
+class MetaNormal2(meta_definition):
+    '''
+    为什么这里可以用 meta_definition 定义元类？而不需要 metaclass 关键字？
+    '''
+    pass
+
+
+print(type(MetaNormal2))
+print(MetaNormal2.a)
+
+# print(MetaNormal0.__mro__)
+# print(MetaNormal1.__mro__)
+"""
+➊ ➋ type 类或者继承自 type 的类称为元类
+➌ class_definition 是type创建，所以 type(class_definition) 为 <class 'type'>
+➍ class_definition 是一个类
+➎ meta_definition 由元类 Meta 创建，创建 meta_definition 时，
+    1. 先调用 Meta 的 __new__, 
+    2. 再调用 Meta 的 __init__，
+  这样，meta_definition（类） 作为 元类 Meta 的一个实例就被创建好
+➏ meta_definition 的元类为 Meta
+"""
+
+""" 输出：
+<class 'type'>
+<class '__main__.class_name'>
+<class 'type'>
+call Meta __new__
+call Meta __init__
+<class '__main__.meta'>
+<class '__main__.Meta'>
+"""

metaclass/metaclass_2.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @File  : metaclass_2.py
+# @Author: yubo
+# @Date  : 2019/11/18
+# @Desc  :
+
+
+class SimpleMetaClass(type):
+    def __new__(cls, *args, **kwargs):
+        print("creating class Earth...")
+        return super(SimpleMetaClass, cls).__new__(cls, *args, **kwargs)
+
+    def __init__(self, *args, **kwargs):
+        print("you have create a class instance by metaclass")
+        super(SimpleMetaClass, self).__init__(*args, **kwargs)
+
+    def __call__(self, *args, **kwargs):
+        print("__call__ in metaclass has been invoked...", "the args:", args, kwargs)
+        return super(SimpleMetaClass, self).__call__(*args, **kwargs)
+
+
+class Earth(metaclass=SimpleMetaClass):
+    def __new__(cls, g, R=65535):
+        print("creating instance using __new__")
+        cls.g = g
+        cls.R = R
+        return super(Earth, cls).__new__(cls)
+
+    def __init__(self, g, R=65535):
+        print("initializing instance in __init__")
+        print("gravity on Earth is:%f" % self.g)
+
+    def __call__(self):
+        print(self.g)
+
+    def sayHello(self):
+        print("hello earth,your gravity is:%f" % self.g)
+
+
+if __name__ == "__main__":
+    """earth = Earth(9.8, R=65535)
+    1、调用 创建 Earth 的类的__call__ 方法，即 SimpleMetaClass.__call__
+        1、调用 type.__call__
+        2、调用 Earth.__new__
+        3、type.__call__ 返回
+        SimpleMetaClass.__call__ 返回 Earth 的一个实例
+    2、调用 Earth.__init__ 
+    """
+    earth = Earth(9.8, R=65535)
+    """
+    earth() 调用创建 earth 的类的__call__方法，即 Earth.__call__
+    """
+    earth()
+    earth.sayHello()
+
+"""
+creating class Earth...
+you have create a class instance by metaclass
+__call__ in metaclass has been invoked... the args: (9.8,) {'R': 65535}
+creating instance using __new__
+initializing instance in __init__
+gravity on Earth is:9.800000
+9.8
+hello earth,your gravity is:9.800000
+"""
+
+"""
+1. 首先python创建SimpleMetaClass类，这个SimpleMetaClass是元类，应该是由type创建的。
+2. 当创建Earth这个类时，找到了它类中有__metaclass__属性，于是，采用SimpleClass来创建这个类
+3. 创建Earth类时，解释器会把类名，父类元祖，类的属性三个参数传给SimpleMetaClass(传给 type 也是这几个参数)
+4. SimpleMetaClass 根据 clazzName,(parent2,parent1,..),{‘attribute’:….,’method’:”}在自己__new__方法中创建出这个Earth实例【打印出①】，
+   然后调用自己的__init__方法初始化类的参数【打印出②】。这时，这个Earth类作为metaclass的一个实例就被创建好了。
+5. 接下来通过 earth = Earth(9.8,R=65535) 创建一个Earth对象实例earth。这一步实际上是调用 Earth这个类对象的__call__（SimpleMetaClass::__call__）
+   方法来创建一个Earth的实例。【打印出③，我们还能看到调用__call__的参数】。
+6. 而创建earth实例的方法__new__(Earth::__new__),和__init__(Earth:__init__),将会在Earth实例中的__call__（SimpleMetaClass::__call__）
+   当中先后得以执行【先后打印出④⑤⑥】执行完成Earth实例earth对象被返回。
+7.8. 容易理解
+
+"""