Python抽象类以及元类

抽象基类: 继承的约束与协议

__doc__ = """
抽象基类: 继承的约束与协议
# 抽象基类 --- 有点java的味道,也有点golang的味道,继承,协议,接口
    1.抽象基类不能实例化
    2.必要时可以要求子类实现基类指定的抽象方法
# 抽象基类的目的：
    1.处理继承问题方面更加规范、系统
    2.明确调用之间的相互关系
    3.使得继承层次更加清晰
    4.限定子类实现的方法
# 参考
https://www.osgeo.cn/cpython/library/abc.html   # 介绍
https://www.python.org/dev/peps/pep-3119/   # 缘由
https://www.cnblogs.com/traditional/p/11731676.html # 使用
"""
import abc
class Base(abc.ABC):
    @abc.abstractmethod  # 要求子类实现指定协议,抽象方法用@abstractmethod装饰器标记,而且定义体中通常只有文档字符串.
    def my_protocol(self):
        """要求子类实现的自定义协议"""
    def not_protocol(self):
        """不要求子类实现的自定义协议"""
    @classmethod
    def __subclasshook__(cls, subclass):  # 同时作用于isinstance和issubclass
        """
        此方法应返回 True ， False 或 NotImplemented .
        如果它回来 True , the 子类 被认为是ABC的一个子类。
        如果它回来 False , the 子类 不被认为是ABC的一个子类，即使它通常是ABC的一个子类。
        如果它回来 NotImplemented ，子类检查继续使用常规机制。
        """
        # print("subclass.__mro__:", subclass.__mro__)  # 继承树
        if cls is Base:
            if any("my_protocol" in B.__dict__ for B in subclass.__mro__):
                return True
            else:
                return False
        return NotImplemented
# 显式继承Base
class MyClass(Base):
    """子类"""
    def my_protocol(self):
        pass
# 显式继承Base
class MyClass2(Base):
    """子类"""
    def my_protocol(self):
        pass
@Base.register
class MyClass3():
    """虚拟子类:issubclass和isinstance等函数都能识别，但是注册的类不会从抽象基类中继承任何方法或属性."""
k = MyClass()
print(isinstance(k, Base))  # True
print(issubclass(MyClass, Base))  # True
k2 = MyClass2()
print(isinstance(k2, Base))  # True
print(issubclass(MyClass2, Base))  # True
k3 = MyClass3()
print(isinstance(k3, Base))  # False
print(issubclass(MyClass3, Base))  # False

元类: 用来拦截和修改 继承此元类 的子类的 创建

__doc__ = """
元类: 用来拦截和修改 继承此元类 的子类的 创建
# 为一个类定义确定适当的元类是根据以下规则:
    1.如果没有基类且没有显式指定元类，则使用 type()；
    2.如果给出一个显式元类而且 不是 type() 的实例，则其会被直接用作元类；
    3.如果给出一个 type() 的实例作为显式元类，或是定义了基类，则使用最近派生的元类。
# 目的
    了解元类的目的前需要先知道普通继承的作用与特点:
    继承的特点：
        <1>减少代码量和灵活指定型类
        <2>子类具有父类的方法和属性
        <3>子类不能继承父类的私有方法或属性
        <4>子类可以添加新的方法
        <5>子类可以修改父类的方法
    可以看到所有涉及到变动的特点都需要子类中实现,这样的话,对于某些固定模式的变动就需要子类中重复实现,增加子类中的代码量,
    或者所有子类固定继承某一个中间类,并在中间类的__new__中根据子类模式去创建,元类就可以理解为python中单独提出来的中间类,
    而一切类的创建最终都会调用type.__new__(cls, classname, bases, attrs)
    元类的使用就是在子类创建时拦截并修改,可以依据子类的特点增加或修改属性.
# 参考:
https://docs.python.org/zh-cn/3/reference/datamodel.html#object.__new__
https://docs.python.org/zh-cn/3/reference/datamodel.html#metaclasses
"""
import abc
from six import add_metaclass, with_metaclass  # py2和py3的桥梁,元类相关的变化很大,可通过six做兼容.
Meta = abc.ABCMeta
# 通用做法。
@add_metaclass(Meta)
class MyClass(object):
    pass
# 在Python 3 等价于
class MyClass(object, metaclass=Meta):
    pass
# 在Python 2.x (x >= 6)中等价于
class MyClass(object):
    __metaclass__ = Meta
    pass
# 或者直接调用装饰器，这里也能看出来装饰器就是个方法包装而已。
class MyClass(object):
    pass
MyClass = add_metaclass(Meta)(MyClass)
# 再或者用 with_metaclass
class MyClass(object, with_metaclass(Meta)):
    pass
def with_metaclass(meta, *bases):  # 代码摘自sqlalchemy中对元类的包装,采用了类似six.with_metaclass的方式
    """Create a base class with a metaclass.
    Drops the middle class upon creation.
    Source: http://lucumr.pocoo.org/2013/5/21/porting-to-python-3-redux/
    """
    class metaclass(meta):
        __call__ = type.__call__
        __init__ = type.__init__
        def __new__(cls, name, this_bases, d):
            if this_bases is None:
                return type.__new__(cls, name, (), d)
            return meta(name, bases, d)
    return metaclass("temporary_class", None, {})
# 举例部分
# 继承type 创建元类
class SayMetaClass(type):
    # 用type动态生成类的的三个重要参数：类名称、父类、属性
    def __new__(cls, name, bases, attrs):
        # 创造"天赋"
        attrs['say_' + name] = lambda self, value, saying=name: print(saying + ',' + value + '!')
        # 类名称、父类、属性 生成元类
        return type.__new__(cls, name, bases, attrs)
# 继承元类 创建类
# class Hello(object, metaclass=SayMetaClass):
class Hello(object, with_metaclass(SayMetaClass)):
    pass
# 创建实列
hello = Hello()
# 调用实例方法
hello.say_Hello('world!')
# 普通类的创建与继承
class Man:
    def __new__(cls, name, age):  # 静态方法
        print('Man.__new__ called.', getattr(cls, 'work_copy'))  # 能传过来
        return super(Man, cls).__new__(cls)  # -->self
# 对比普通类的继承与创建
class Person(Man):
    """普通继承
    对象是由 __new__() 和 __init__() 协作构造完成的 (由 __new__() 创建，并由 __init__() 定制)，
    所以 __init__() 返回的值只能是 None，否则会在运行时引发 TypeError。
    """
    def __new__(cls, name, age, work):  # 可以不写,默认继承了Man.__new__
        print('Person.__new__ called.')
        cls.work_copy = work
        # return super(Person, cls).__new__(cls, name, age)  # -->Man.__new__
        cls = super(Person, cls).__new__(cls, name, age)  # 根据需要修改新创建的实例再将其返回
        cls.work = work  # 可以看到,__new__也是可以做__init__的数值绑定的
        return cls
    def __init__(self, name, age, work):  # 参数与__new__必须一致,__new__的后续构造
        print('Person.__init__ called.')
        self.name = name
        self.age = age
        # self.work = work
    def __str__(self):
        return '<Person: %s %s %s>' % (self.name, self.age, self.work)
zhangsan = Person('zhangsan', 24, '张三')
print(zhangsan)