La métaclasse de magie noire qui change les règles des objets Python

Le sujet que Xiao Ming souhaite partager aujourd'hui est : l'artefact du changement de définition de classe-métaclasse

Quand vous voyez le titre, vous vous demandez peut-être à quoi sert de changer la définition d'une classe ? Quand devez-vous utiliser une métaclasse ?

Aujourd'hui, je vais vous amener à concevoir un framework ORM simple et à analyser brièvement les principes de YAML, un outil de sérialisation.

Le dieu des classes Python - type

En parlant de métaclasse, nous devons d'abord comprendre le concept le plus élémentaire selon lequel les objets sont des instances de classes et les classes sont des instances de type. Répétez :

1. Les objets sont des instances de classes
2. Classe. est une instance de type

Dans le modèle de programmation orientée objet, une classe équivaut au dessin de conception d'une maison, et l'objet est la maison construite sur la base de ce dessin de conception.

Dans l'image ci-dessous, le modèle de jouet peut représenter une classe, et le jouet spécifique produit peut représenter un objet :

En bref, une classe est un modèle pour créer des objets.

Et type est un modèle pour créer des classes, afin que nous puissions créer les classes que nous voulons via le type.

Par exemple, définissez une classe Hello :

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

Lorsque l'interpréteur Python charge le module hello, il exécutera toutes les instructions du module dans l'ordre, et le résultat de l'exécution est de créer dynamiquement un objet de classe Hello. La fonction

type() peut non seulement vérifier le type d'un type ou d'une variable, mais également créer un nouveau type basé sur des paramètres. Par exemple, la définition de la classe ci-dessus est essentiellement : la fonction

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

type() crée un. objet de classe et le transmet à son tour. Entrez 3 paramètres :

• nom de la classe ;
• collection de classes parent héritées. Notez que Python prend en charge l'héritage multiple. S'il n'y a qu'une seule classe parent, n'oubliez pas la méthode d'écriture à un seul élément. tuple;
• nom de la méthode de classe et fonction Liaison, noms de champs et valeurs correspondantes Ici, nous lions la fonction fn au nom de la méthode hello.

La classe créée via la fonction type() est exactement la même que l'écriture directe de la classe, car lorsque l'interpréteur Python rencontre la définition de classe, il analyse simplement la syntaxe de la définition de classe, puis appelle la fonction type() pour créer la classe.

Dans des circonstances normales, nous utilisons certainement la classe Xxx... pour définir des classes, mais la fonction type() nous permet de créer dynamiquement des classes, ce qui signifie que Python, un langage dynamique, prend en charge la création dynamique de classes pendant l'exécution. Vous ne ressentirez peut-être pas à quel point cela est puissant.Vous devez savoir que si vous souhaitez créer une classe dans un environnement d'exécution de langage statique, vous devez essentiellement construire une chaîne de code source, puis appeler le compilateur, ou utiliser certains outils pour générer une implémentation de bytecode. , c'est une compilation dynamique.

Qu'est-ce que la métaclasse exactement ?

Quelle est la relation entre le type et la métaclasse ? Qu’est-ce que la métaclasse exactement ?

Je pense que la métaclasse est en fait un type ou une sous-classe de type. En héritant du type et en surchargeant l'opérateur __call__, vous pouvez apporter quelques modifications lors de la création d'un objet de classe.

Pour la classe MyClass :

class MyClass():
 pass

est en fait équivalent à :

class MyClass(metaclass = type):
 pass

Une fois que nous avons défini sa métaclasse sur MyMeta :

class MyClass(metaclass = MyMeta):
 pass

MyClass n'est plus créé par le type natif, mais appellera la surcharge d'opérateur __call__ de MyMeta .

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

Pour les classes avec des relations d'héritage :

class Foo(Bar):
 pass

Python effectue les opérations suivantes :

• Y a-t-il un attribut __metaclass__ dans Foo ? Si tel est le cas, Python créera une classe (objet) nommée Foo via __metaclass__
• Si Python ne trouve pas __metaclass__, il continuera à rechercher l'attribut __metaclass__ dans Bar (classe parent) et essaiera de faire la même chose qu'avant l'opération.
• Si Python ne trouve pas __metaclass__ dans aucune classe parent, il recherchera __metaclass__ dans la hiérarchie des modules et essaiera de faire la même opération.
• Si __metaclass__ n'est toujours pas trouvé, Python utilisera le type intégré pour créer cet objet de classe.

Imaginez un exemple idiot où vous décidez que tous les attributs de classe de votre module doivent être en majuscules. Il existe plusieurs façons de le faire, mais l'une d'elles consiste à définir __metaclass__ au niveau du module :

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'))
## 输出: False
print(hasattr(Foo, 'BAR'))
## 输出:True
f = Foo()
print(f.BAR)
## 输出:'bip'

Conception d'un framework ORM simple

Le nom complet d'ORM est "Object Relational Mapping", qui est un mappage objet-relationnel, qui consiste à mapper des relations. Une ligne de la base de données est mappée à un objet, c'est-à-dire qu'une classe correspond à une table. De cette façon, il est plus facile d'écrire du code sans utiliser directement les instructions SQL.

Concevez maintenant l'interface d'appel du framework ORM. Par exemple, si un utilisateur souhaite faire fonctionner la table de base de données correspondante User via la classe User, nous attendons de lui qu'il écrive du code comme celui-ci :

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()

L'interface ci-dessus est difficile ou presque. difficile à implémenter avec les méthodes conventionnelles, mais ce sera relativement simple grâce à la métaclasse. L'idée principale est de modifier la définition de la classe via la métaclasse, de sauvegarder tous les attributs de type Field de la classe dans un dictionnaire supplémentaire, puis de les supprimer de la définition d'origine. Les paramètres transmis par l'utilisateur lors de la création d'un objet (id=12345, name='xiaoxiaoming', etc.) peuvent être enregistrés en imitant l'implémentation du dictionnaire ou en héritant directement de la classe 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中，一共做了几件事情：

1. 在当前类（比如User）中查找定义的类的所有属性，如果找到一个Field属性，就把它保存到一个__mappings__的dict中，同时从类属性中删除该Field属性（避免实例的属性遮盖类的同名属性）；
2. 当类中未定义__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: User
Found 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_, user_name='xxm', name='orm框架的基本运行机制', summary="简单讲述一下orm框架的基本运行机制",
 content="此处省略一万字...")
b.save()

输出：

Found model: Blog
Found 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 工具，可以方便地序列化 / 逆序列化结构数据。

官方文档：https://pyyaml.org/wiki/PyYAMLDocumentation

安装：

pip install pyyaml

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

import yaml
class 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("""
--- !Monster
name: Cave spider
hp: [2,6]
ac: 16
attacks: [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'>
!Monster
ac: 16
attacks: [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)。

Résumé

Ce partage analyse principalement brièvement le mécanisme d'implémentation de la métaclasse. En implémentant un framework ORM et en interprétant le code source YAML, je pense que vous avez déjà une bonne compréhension de la métaclasse.

metaclass est une fonctionnalité du langage de niveau magie noire de Python. Elle peut modifier le comportement d'une classe lors de sa création. Cette fonctionnalité puissante doit être utilisée avec prudence.

Après avoir lu cet article, selon vous, quelle est la différence entre les décorateurs et les métaclasses ? Bienvenue à laisser un message ci-dessous pour discuter avec moi. Pensez à cliquer trois fois de suite pour recharger !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!