关于python:改变-Python-对象规则的黑魔法-Metaclass

明天分享的主题是：扭转类定义的神器-metaclass

看到题目，你可能会想扭转类的定义有什么用呢？什么时候才须要应用metaclass呢？

明天我将带大家设计一个简略的orm框架，并简略分析一下YAML这个序列化工具的原理。

Python类的上帝-type

说到metaclass，咱们首先必须分明一个最根底的概念就是对象是类的实例，而类是type的实例，反复一遍：

对象是类的实例
类是type的实例

在面向对象的编程模型中，类就相当于一个房子的设计图纸，而对象则是依据这个设计图纸建进去的房子。

下图中，玩具模型就能够代表一个类，而具体生产进去的玩具就能够代表一个对象：

总之，类就是创建对象的模板。

而type又是创立类的模板，那么咱们就能够通过type创立本人想要的类。

比方定义一个 Hello 的 class：

class Hello(object):    def hello(self, name='world'):     print('Hello, %s.' % name)

当 Python 解释器载入 hello 模块时，就会顺次执行该模块的所有语句，执行后果就是动态创建出一个 Hello 的 class对象。

type()函数既能够查看一个类型或变量的类型，也能够依据参数创立出新的类型，比方下面那段类的定义实质上就是：

def hello(self, name='world'):    print('Hello, %s.' % name)Hello = type('Hello', (object,), dict(hello=hello))

type()函数创立class 对象，顺次传入 3 个参数：

class 类的名称；
继承的父类汇合，留神 Python 反对多重继承，如果只有一个父类，别忘了 tuple 的单元素写法；
class 的办法名称与函数绑定以及字段名称与对应的值，这里咱们把函数 fn 绑定到办法名 hello 上。

通过 type() 函数创立的类和间接写 class 是齐全一样的，因为 Python 解释器遇到 class 定义时，仅仅是扫描一下class 定义的语法，而后调用 type() 函数创立出 class。

失常状况下，咱们必定都是用 class Xxx... 来定义类，然而type() 函数容许咱们动态创建出类来，这意味着Python这门动静语言反对运行期动态创建类。你可能感触不到这有多弱小，要晓得想在动态语言运行期创立类，必须结构源代码字符串再调用编译器，或者借助一些工具生成字节码实现，实质上都是动静编译，会非常复杂。

metaclass到底是什么

那type和metaclass有什么关系呢？metaclass到底是什么呢？

我认为metaclass 其实就是type或type的子类，通过继承type，重载__call__运算符，便能够在class类对象创立时作出一些批改。

对于类 MyClass：

class MyClass(): pass

其实相当于：

class MyClass(metaclass = type): pass

一旦咱们把它的 metaclass 设置成 MyMeta：

class MyClass(metaclass = MyMeta): pass

MyClass 就不再由原生的 type 创立，而是会调用 MyMeta 的__call__运算符重载。

class = type(classname, superclasses, attributedict) ## 变为了class = MyMeta(classname, superclasses, attributedict)

对于具备继承关系的类：

class Foo(Bar): pass

Python做了如下的操作：

Foo中有__metaclass__这个属性吗？如果是，Python会通过__metaclass__创立一个名字为Foo的类(对象)
如果Python没有找到__metaclass__，它会持续在Bar（父类）中寻找__metaclass__属性，并尝试做和后面同样的操作。
如果Python在任何父类中都找不到__metaclass__，它就会在模块档次中去寻找__metaclass__，并尝试做同样的操作。
如果还是找不到__metaclass__，Python就会用内置的type来创立这个类对象。

假想一个很傻的例子，你决定在你的模块里所有的类的属性都应该是大写模式。有好几种办法能够办到，但其中一种就是通过在模块级别设定__metaclass__：

class UpperAttrMetaClass(type):    ## __new__ 是在__init__之前被调用的非凡办法    ## __new__是用来创建对象并返回之的办法    ## 而__init__只是用来将传入的参数初始化给对象    ## 你很少用到__new__，除非你心愿可能管制对象的创立    ## 这里，创立的对象是类，咱们心愿可能自定义它，所以咱们这里改写__new__    ## 如果你心愿的话，你也能够在__init__中做些事件    ## 还有一些高级的用法会波及到改写__call__非凡办法，然而咱们这里不必    def __new__(cls, future_class_name, future_class_parents, future_class_attr):        ##遍历属性字典，把不是__结尾的属性名字变为大写        newAttr = {}        for name,value in future_class_attr.items():            if not name.startswith("__"):                newAttr[name.upper()] = value        ## 办法1：通过'type'来做类对象的创立        ## return type(future_class_name, future_class_parents, newAttr)        ## 办法2：复用type.__new__办法，这就是根本的OOP编程        ## return type.__new__(cls, future_class_name, future_class_parents, newAttr)        ## 办法3：应用super办法        return super(UpperAttrMetaClass, cls).__new__(cls, future_class_name, future_class_parents, newAttr)class Foo(object, metaclass = UpperAttrMetaClass):    bar = 'bip'print(hasattr(Foo, 'bar'))## 输入: Falseprint(hasattr(Foo, 'BAR'))## 输入:Truef = Foo()print(f.BAR)## 输入:'bip'

繁难ORM框架的设计

ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简略，不必间接操作SQL语句。

当初设计一下ORM框架的调用接口，比方用户想通过User类来操作对应的数据库表User，咱们期待他写出这样的代码：

class User(Model):    ## 定义类的属性到列的映射：    id = IntegerField('id')    name = StringField('username')    email = StringField('email')    password = StringField('password')## 创立一个实例：u = User(id=12345, name='xiaoxiaoming', email='test@orm.org', password='my-pwd')## 保留到数据库：u.save()

下面的接口通过惯例办法很难或简直很难实现，但通过metaclass就会绝对比较简单。核心思想就是通过metaclass批改类的定义，将类的所有Field类型的属性，用一个额定的字典去保留，而后从原定义中删除。对于User创建对象时传入的参数（id=12345, name='xiaoxiaoming'等）能够模拟字典的实现或间接继承dict类保存起来。

其中，父类Model和属性类型StringField、IntegerField是由ORM框架提供的，剩下的魔术办法比方save()全副由metaclass主动实现。尽管metaclass的编写会比较复杂，但ORM的使用者用起来却异样简略。

首先定义Field类，它负责保留数据库表的字段名和字段类型：

class Field(object):    def __init__(self, name, column_type):        self.name = name        self.column_type = column_type    def __str__(self):        return '<%s:%s>' % (self.__class__.__name__, self.name)

在Field的根底上，进一步定义各种类型的Field，比方StringField，IntegerField等等：

class StringField(Field):    def __init__(self, name):        super(StringField, self).__init__(name, 'varchar(100)')class IntegerField(Field):    def __init__(self, name):        super(IntegerField, self).__init__(name, 'bigint')

下一步，编写ModelMetaclass：

class ModelMetaclass(type):    def __new__(cls, name, bases, attrs):        if name == 'Model':            return type.__new__(cls, name, bases, attrs)        print('Found model: %s' % name)        mappings = dict()        for k, v in attrs.items():            if isinstance(v, Field):                print('Found mapping: %s ==> %s' % (k, v))                mappings[k] = v        for k in mappings.keys():            attrs.pop(k)        attrs['__mappings__'] = mappings  ## 保留属性和列的映射关系        attrs.setdefault('__table__', name) ## 当未定义__table__属性时，表名间接应用类名        return type.__new__(cls, name, bases, attrs)

以及基类Model：

class Model(dict, metaclass=ModelMetaclass):    def __init__(self, **kw):        super(Model, self).__init__(**kw)    def __getattr__(self, key):        try:            return self[key]        except KeyError:            raise AttributeError(r"'Model' object has no attribute '%s'" % key)    def __setattr__(self, key, value):        self[key] = value    def save(self):        fields = []        params = []        args = []        for k, v in self.__mappings__.items():            fields.append(v.name)            params.append('?')            args.append(getattr(self, k, None))        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))        print('SQL: %s' % sql)        print('ARGS: %s' % str(args))

在ModelMetaclass中，一共做了几件事件：

在以后类（比方User）中查找定义的类的所有属性，如果找到一个Field属性，就把它保留到一个__mappings__的dict中，同时从类属性中删除该Field属性（防止实例的属性遮蔽类的同名属性）；
当类中未定义__table__字段时，间接将类名保留到__table__字段中作为表名。

在Model类中，就能够定义各种操作数据库的办法，比方save()，delete()，find()，update等等。

咱们实现了save()办法，把一个实例保留到数据库中。因为有表名，属性到字段的映射和属性值的汇合，就能够结构出INSERT语句。

测试：

u = User(id=12345, name='xiaoxiaoming', email='test@orm.org', password='my-pwd')u.save()

输入如下：

Found model: UserFound mapping: id ==> <IntegerField:id>Found mapping: name ==> <StringField:username>Found mapping: email ==> <StringField:email>Found mapping: password ==> <StringField:password>SQL: insert into User (id,username,email,password) values (?,?,?,?)ARGS: [12345, 'xiaoxiaoming', 'test@orm.org', 'my-pwd']

测试2：

class Blog(Model):    __table__ = 'blogs'    id = IntegerField('id')    user_id = StringField('user_id')    user_name = StringField('user_name')    name = StringField('user_name')    summary = StringField('summary')    content = StringField('content')b = Blog(id=12345, user_id='user_id1', user_name='xxm', name='orm框架的根本运行机制', summary="简略讲述一下orm框架的根本运行机制",         content="此处省略一万字...")b.save()

输入：

Found model: BlogFound mapping: id ==> <IntegerField:id>Found mapping: user_id ==> <StringField:user_id>Found mapping: user_name ==> <StringField:user_name>Found mapping: name ==> <StringField:user_name>Found mapping: summary ==> <StringField:summary>Found mapping: content ==> <StringField:content>SQL: insert into blogs (id,user_id,user_name,user_name,summary,content) values (?,?,?,?,?,?)ARGS: [12345, 'user_id1', 'xxm', 'orm框架的根本运行机制', '简略讲述一下orm框架的根本运行机制', '此处省略一万字...']

能够看到，save()办法曾经打印出了可执行的SQL语句，以及参数列表，只须要真正连贯到数据库，执行该SQL语句，就能够实现真正的性能。

YAML序列化工具的实现原理浅析

YAML是一个妇孺皆知的 Python 工具，能够不便地序列化 / 逆序列化构造数据。

装置：

pip install pyyaml

YAMLObject 的任意子类反对序列化和反序列化（serialization & deserialization）。比如说上面这段代码：

import yamlclass Monster(yaml.YAMLObject):    yaml_tag = '!Monster'    def __init__(self, name, hp, ac, attacks):        self.name = name        self.hp = hp        self.ac = ac        self.attacks = attacks    def __repr__(self):        return f"{self.__class__.__name__}(name={self.name}, hp={self.hp}, ac={self.ac}, attacks={self.attacks})"monster1 = yaml.load("""--- !Monstername: Cave spiderhp: [2,6]ac: 16attacks: [BITE, HURT]""")print(monster1, type(monster1))monster2 = Monster(name='Cave lizard', hp=[3, 6], ac=16, attacks=['BITE', 'HURT'])print(yaml.dump(monster2))

运行后果：

Monster(name=Cave spider, hp=[2, 6], ac=16, attacks=['BITE', 'HURT']) <class '__main__.Monster'>!Monsterac: 16attacks: [BITE, HURT]hp: [3, 6]name: Cave lizard

这外面调用对立的 yaml.load()，就能把任意一个 yaml 序列载入成一个 Python Object；而调用对立的 yaml.dump()，就能把一个 YAMLObject 子类序列化。

对于 load() 和 dump() 的使用者来说，他们齐全不须要提前晓得任何类型信息，这让超动静配置编程成了可能。比方说，在一个智能语音助手的大型项目中，咱们有 1 万个语音对话场景，每一个场景都是不同团队开发的。作为智能语音助手的外围团队成员，我不可能去理解每个子场景的实现细节。

在动静配置试验不同场景时，常常是明天我要试验场景 A 和 B 的配置，今天试验 B 和 C 的配置，光配置文件就有几万行量级，工作量不堪称不小。而利用这样的动静配置理念，就能够让引擎依据配置文件，动静加载所须要的 Python 类。

对于 YAML 的使用者也很不便，只有简略地继承 yaml.YAMLObject，就能让你的 Python Object 具备序列化和逆序列化能力。

据说即便是在大厂 Google 的 Python 开发者，发现能深刻解释 YAML 这种设计模式长处的人，大略只有 10%。而能晓得相似 YAML 的这种动静序列化 / 逆序列化性能正是用 metaclass 实现的人，可能只有 1% 了。而可能将YAML 怎么用 metaclass 实现动静序列化 / 逆序列化性能讲出一二的可能只有 0.1%了。

对于YAMLObject 的 load和dump() 性能，简略来说，咱们须要一个全局的注册器，让 YAML 晓得，序列化文本中的!Monster须要载入成 Monster 这个 Python 类型，Monster 这个 Python 类型须要被序列化为!Monster标签结尾的字符串。

一个很天然的想法就是，那咱们建设一个全局变量叫 registry，把所有须要逆序列化的 YAMLObject，都注册进去。比方上面这样：

registry = {} def add_constructor(target_class):    registry[target_class.yaml_tag] = target_class

而后，在 Monster 类定义前面加上上面这行代码：

add_constructor(Monster)

这样的毛病很显著，对于 YAML 的使用者来说，每一个 YAML 的可逆序列化的类 Foo 定义后，都须要加上一句话add_constructor(Foo)。这无疑给开发者减少了麻烦，也更容易出错，毕竟开发者很容易忘了这一点。

更优雅的实现形式天然是通过metaclass 解决了这个问题，YAML 的源码正是这样实现的：

class YAMLObjectMetaclass(type):    def __init__(cls, name, bases, kwds):        super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)        if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:            cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)            cls.yaml_dumper.add_representer(cls, cls.to_yaml)    ## 省略其余定义 class YAMLObject(metaclass=YAMLObjectMetaclass):    yaml_loader = Loader    yaml_dumper = Dumper    ## 省略其余定义

能够看到，YAMLObject 把 metaclass 申明成了 YAMLObjectMetaclass，YAMLObjectMetaclass则会扭转YAMLObject类和其子类的定义，就是上面这行代码将YAMLObject 的子类退出到了yaml的两个全局注册表中：

cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)cls.yaml_dumper.add_representer(cls, cls.to_yaml)

YAML 利用 metaclass，拦挡了所有 YAMLObject 子类的定义。也就是说，在你定义任何 YAMLObject 子类时，Python 会强行插入运行下面这段代码，把咱们之前想要的add_constructor(Foo)和add_representer(Foo)给主动加上。所以 YAML 的使用者，无需本人去手写add_constructor(Foo)和add_representer(Foo)。

总结

这次分享次要是简略的浅析了 metaclass 的实现机制。通过实现一个orm框架并解读 YAML 的源码，置信你曾经对metaclass 有了不错的了解。

metaclass 是 Python 黑魔法级别的语言个性，它能够扭转类创立时的行为，这种弱小的性能应用起来务必小心。

看完本文，你感觉装璜器和 metaclass 有什么区别呢？欢送下方留言和我探讨。记得一键三连呦，笔芯！

咱们的文章到此就完结啦，如果你喜爱明天的Python 实战教程，能够关注公众号Python编程学习圈，理解更多编程技术干货！