python：元类与抽象基类

Posted 2020-11-08 韩非囚秦

一、实例创建

　　在创建实例时，调用__new__方法和__init__方法，这两个方法在没有定义时，是自动调用了object来实现的。python3默认创建的类是继承了object。

class A(object):
    def __init__(self, *args, **kwargs):
        self.name, self.age, self.gender = args[:3]
    def __new__(cls, *args, **kwargs):
        print("__new__ has called.")
        return super(A, cls).__new__(cls)
        # 可写为 super().__new__(cls) 或 object.__new__(cls)

a = A("Li", 27, "male")
print(a.name, a.age, a.gender)

"""
__new__ has called.
Li 27 male

"""

二、类的创建

　　以class关键字开头的上下文在定义时就已经被解释执行。而函数(包括匿名函数)在没被调用时是不执行的。这个过程本质上做了一件事情：从元类type那里创建了一个名为A的类，开辟类内存空间，并读取class语句的上下文，将类属性和方法写进去。

print("--解释器开始执行--")
def func():
    print("what the hell?")

print("--开始读取class关键字的上下文--")
class A:
    name = "A"
    func()
    print("--上下文结束--")
    
def fn1():
    print("--开始读取匿名函数--")
    def fn2():
        pass
    pass
    print("--读取结束--")
print("--解释器执行结束--")

"""
--解释器开始执行--
--开始读取class关键字的上下文--
what the hell?
--上下文结束--
--解释器执行结束--
"""

　　" 使用class语句定义新类时，将会发生很多事情。首先，类主体将为作其自己的私有字典内的一系列语句来执行。其内容里语句的执行与正常代码中的执行过程相同，只是增加了会在私有成员(名称以__开头)上发生的名称变形。然后，类的名称、基类列表和字典将传递给元类的解构函数，以创建相应的类对象。最后，调用元类type()，这里可以自定义。在python3中，使用class Foo(metaclass=type)来显式地指定元类。如果没有找到任何__metaclass__值，Python将使用默认的元类type。"  -- <<python 参考手册(第四版)>>

class_name = "Foo"    # 类名
class_parents = (object, )   # 基类
# 类主体
class_body = """
name = "Foo"
def __init__(self, x):
    self.x = x
def hello(self):
    print("Hello")
"""
class_dict = {}
# 在局部字典class_dict中执行类主体
exec(class_body, globals(), class_dict)
# 创建类对象Foo
Foo = type(class_name, class_parents, class_dict)  # type可以指定
Foo("X").hello()
# Hello

　　type类创建类时，指定了类的三个部分: class_name, class_parent, class_dict。这一步是在底层实现的。

string = """name = ‘Li‘
age = 2712
"""
# 字符串必须是换行符或分号分割
dic = {}
exec(string, globals())  # globals表示执行字符串后的结果保存到全局命名空间中
print(name, age)
print(dic)
exec(string, globals(), dic)  # locals表示执行字符串后的结果保存到局部一个映射对象中
print(dic)

"""
Li 2712
{}
{‘name‘: ‘Li‘, ‘age‘: 2712}
"""

exec函数用法

　　我们可以用type动态地创建类。你可以用上面的方式去实现类的上下文，也可以直接定义函数并给到字典里，尽管它看起来有些"污染"全局空间:

class_name = "A"
class_parent = ()

label = "hello world"

def init(self, name, age):
    self.name = name
    self.age = age
def hello(self):
    print("Hello, i‘m %s, %s." % (self.name, self.age))
    
A = type(class_name, class_parent, {"__init__": init, "hello": hello, "label": label})

a = A("Li", 18)
a.hello()
print(a.label)

"""
Hello, i‘m Li, 18.
hello world
"""

三、元类的实现过程

　　

复制代码

print("First...")
class MyType(type):
    print("MyType begin ...")
    def __init__(self, *args, **kwargs):
        print("Mytype __init__", self, *args, **kwargs , sep="\r\n", end="\r\n\r\n")
        type.__init__(self, *args, **kwargs)  # 调用type.__init__
        
    def __call__(self, *args, **kwargs):
        print("Mytype __call__", *args, **kwargs)
        obj = self.__new__(self)   # 第一个self是Foo，第二个self是F("Alex")
        print("obj ",obj, *args, **kwargs)
        print(self)
        self.__init__(obj,*args, **kwargs)
        return obj
    
    def __new__(cls, *args, **kwargs):
        print("Mytype __new__", cls, *args, **kwargs, sep="\r\n", end="\r\n\r\n")
        return type.__new__(cls, *args, **kwargs)
    print("MyType end ...")
    
print(‘Second...‘)
class Foo(metaclass=MyType):
    print("begin...")
    def __init__(self, name):
        self.name = name
        print("Foo __init__")
        
    def __new__(cls, *args, **kwargs):
        print("Foo __new__", end="\r\n\r\n")
        return object.__new__(cls)
    print("over...")
    
    def __call__(self, *args, **kwargs):
        print("Foo __call__", self, *args, **kwargs, end="\r\n\r\n")
    
print("third...")
f = Foo("Alex")
print("f",f, end="\r\n\r\n")
f()
print("fname",f.name)

"""
First...
MyType begin ...
MyType end ...
Second...
begin...
over...
Mytype __new__
<class ‘__main__.MyType‘>
Foo
()
{‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘Foo‘, ‘__init__‘: <function Foo.__init__ at 0x10ad89268>, ‘__new__‘: <function Foo.__new__ at 0x10ad89488>, ‘__call__‘: <function Foo.__call__ at 0x10ad86ae8>}

Mytype __init__
<class ‘__main__.Foo‘>
Foo
()
{‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘Foo‘, ‘__init__‘: <function Foo.__init__ at 0x10ad89268>, ‘__new__‘: <function Foo.__new__ at 0x10ad89488>, ‘__call__‘: <function Foo.__call__ at 0x10ad86ae8>}

third...
Mytype __call__ Alex
Foo __new__

obj  <__main__.Foo object at 0x10ae2ac88> Alex
<class ‘__main__.Foo‘>
Foo __init__
f <__main__.Foo object at 0x10ae2ac88>

Foo __call__ <__main__.Foo object at 0x10ae2ac88>

fname Alex

"""

　　假设MyType是type类，type有三个特殊方法__init__、__call__、__new__。

　　首先, First请忽略掉吧。假设底层就这样搞了一个type类，它的名字叫MyType。

　　其次，Second这一步。解释器发现class和Foo()，会知道要从元类MyType中"实例化"一个类对象。

　　　　它会首先扫描class Foo()的整个上下文，并分成三部分，类名、基类元组，和私有字典。

　　　　然后它会告诉解释器，马上调用MyType(就是Type)类来创建一个名为Foo的类，来开辟内存空间，把这个Foo的私有字典(包括属性和方法)给放进去。

　　　　于是解释器执行了MyType.__new__，并继续执行MyType.__init__。来创建一个名为Foo的类对象。

　　再次，Third这一步。

　　　　首先通过Foo()来调用MyType.__call__，来实例化一个Foo类。它相当于Foo = Type()

　　　　然后依次执行Foo.__new__和Foo.__init__，来实例化一个实例对象。

　　　　Foo()相当于: MyType()()，而MyType()就是F。于是，在a = Foo()，实际上执行了MyType()()。前面说过，实例+()会调用所属类的__call__方法，同样地，类 + ()会调用类所属元类(MyType)的__call__方法。

　　　　至此，一个实例就算创建完成了。

四、抽象基类

　　抽象基类有两个特点：

　　　　1.规定继承类必须具有抽象基类指定的方法

　　　　2.抽象基类无法实例化

　　基于上述两个特点，抽象基类主要用于接口设计

　　实现抽象基类可以使用内置的abc模块

import abc
class Human(metaclass=abc.ABCMeta):
    @abc.abstractmethod   # 规定子类必须有名为introduce的实例方法
    def introduce(self):
        pass
    
    @abc.abstractproperty  # 规定子类必须有名为country的装饰器方法
    def country(self):
        pass
    
    @abc.abstractclassmethod  # 规定子类必须有名为gender的类方法
    def gender(cls):
        pass
    @abc.abstractstaticmethod  # 规定子类必须有名为hello的静态方法
    def hello():
        pass
class Person(Human):
    __country = "China"
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def introduce(self):
        return "I‘m {}, {}.".format(self.name, self.age)
    
    @property
    def country(self):
        return Person.__country
    
    @classmethod
    def gender(cls):
        return "female"
    
    @staticmethod
    def hello():
        print("What the hell?")

person = Person("Li", 24)
print(person.introduce())
print(person.country)
print(Person.gender())
person.hello()

# I‘m Li, 24.
# China
# female
# What the hell?

 　　collections.abc模块收集了常用的抽象基类。感兴趣的话可以打开collections.abc查看源码。

__all__ = ["Awaitable", "Coroutine",
           "AsyncIterable", "AsyncIterator", "AsyncGenerator",
           "Hashable", "Iterable", "Iterator", "Generator", "Reversible",
           "Sized", "Container", "Callable", "Collection",
           "Set", "MutableSet",
           "Mapping", "MutableMapping",
           "MappingView", "KeysView", "ItemsView", "ValuesView",
           "Sequence", "MutableSequence",
           "ByteString",
           ]