Metaclass sihir hitam yang mengubah peraturan objek Python

Topik yang Brother Xiao Ming ingin kongsikan hari ini ialah: artifak menukar definisi kelas-metaclass

Melihat tajuk itu, anda mungkin tertanya-tanya apa kegunaan menukar definisi kelas? Bilakah anda perlu menggunakan metaclass?

Hari ini saya akan membawa anda untuk mereka bentuk rangka kerja ORM yang ringkas dan menganalisis secara ringkas prinsip YAML, alat penyirian.

Dewa kelas Python - jenis

Bercakap tentang metaclass, kita mesti terlebih dahulu memahami konsep paling asas bahawa objek adalah contoh kelas, dan kelas adalah contoh jenis Ulang:

1. Objek ialah contoh kelas
2. Kelas ialah contoh jenis

Dalam model pengaturcaraan berorientasikan objek, kelas adalah bersamaan dengan lukisan reka bentuk rumah Objek adalah rumah yang dibina berdasarkan lukisan reka bentuk ini.

Dalam gambar di bawah, model mainan boleh mewakili kelas, dan mainan khusus yang dihasilkan boleh mewakili objek:

Ringkasnya, kelas ialah mencipta Templat objek.

Dan taip ialah templat untuk mencipta kelas, jadi kita boleh mencipta kelas yang kita inginkan melalui taip.

Sebagai contoh, tentukan kelas Hello:

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

Apabila penterjemah Python memuatkan modul hello, ia akan melaksanakan semua pernyataan modul dalam urutan, dan hasil pelaksanaan adalah untuk mencipta objek kelas Hello secara dinamik.

Fungsi type() bukan sahaja boleh menyemak jenis jenis atau pembolehubah, tetapi juga mencipta jenis baharu berdasarkan parameter Sebagai contoh, takrifan kelas di atas pada asasnya ialah:

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

Fungsi type() mencipta objek kelas dan menghantar dalam 3 parameter dalam urutan:

• nama kelas
• koleksi kelas induk yang diwarisi warisan. Jika hanya ada satu Untuk kelas induk, jangan lupa kaedah penulisan unsur tunggal bagi nama kaedah kelas
• terikat pada fungsi serta nama medan dan nilai yang sepadan fungsi fn kepada nama kaedah hello.

Kelas yang dicipta melalui fungsi type() adalah sama seperti menulis kelas secara langsung, kerana apabila penterjemah Python menemui definisi kelas, ia hanya mengimbas sintaks definisi kelas dan kemudian memanggil type() Fungsi mencipta kelas.

Dalam keadaan biasa, kami pasti menggunakan kelas Xxx... untuk mentakrifkan kelas, tetapi fungsi type() membolehkan kami mencipta kelas secara dinamik, yang bermaksud Python, bahasa dinamik, menyokong penciptaan dinamik semasa jenis runtime . Anda mungkin tidak merasakan betapa hebatnya ini. Anda mesti tahu bahawa jika anda ingin mencipta kelas dalam masa jalan bahasa statik, anda mesti membina rentetan kod sumber dan kemudian memanggil pengkompil, atau menggunakan beberapa alat untuk menjana pelaksanaan kod bait , ia adalah kompilasi dinamik.

Apakah sebenarnya metaclass

Apakah hubungan antara jenis dan metaclass? Apakah sebenarnya metaclass?

Saya rasa metaclass sebenarnya adalah jenis atau subkelas jenis Dengan mewarisi jenis dan melebihkan operator __call__, anda boleh membuat beberapa pengubahsuaian semasa mencipta objek kelas.

Untuk kelas MyClass:

class MyClass():
 pass

sebenarnya bersamaan dengan:

class MyClass(metaclass = type):
 pass

Sebaik sahaja kami menetapkan metaclassnya kepada MyMeta:

class MyClass(metaclass = MyMeta):
 pass

MyClass tidak lagi akan dicipta oleh jenis asli, tetapi akan memanggil operator __call__ beban berlebihan MyMeta.

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

Untuk kelas dengan perhubungan warisan:

class Foo(Bar):
 pass

Python melakukan operasi berikut:

• Adakah terdapat atribut __metaclass__ dalam Foo ? Jika ya, Python akan mencipta kelas (objek) bernama Foo melalui __metaclass__
• Jika Python tidak menjumpai __metaclass__, ia akan terus mencari atribut __metaclass__ dalam Bar (kelas induk) dan cuba Lakukan operasi yang sama seperti sebelum ini.
• Jika Python tidak dapat mencari __metaclass__ dalam mana-mana kelas induk, ia akan mencari __metaclass__ dalam hierarki modul dan cuba melakukan operasi yang sama.
• Jika __metaclass__ masih tidak ditemui, Python akan menggunakan jenis terbina dalam untuk mencipta objek kelas ini.

Bayangkan contoh bodoh di mana anda memutuskan bahawa semua atribut kelas dalam modul anda hendaklah dalam huruf besar. Terdapat beberapa cara untuk melakukannya, tetapi salah satunya ialah menetapkan __metaclass__ pada tahap modul:

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'

Reka bentuk rangka kerja ORM yang ringkas

Nama penuh ORM ialah "Pemetaan Hubungan Objek " , iaitu, pemetaan hubungan objek, yang memetakan baris pangkalan data hubungan ke objek, iaitu, kelas sepadan dengan jadual. Dengan cara ini, lebih mudah untuk menulis kod tanpa mengendalikan pernyataan SQL secara langsung.

Sekarang reka bentuk antara muka panggilan rangka kerja ORM Contohnya, jika pengguna ingin mengendalikan pengguna jadual pangkalan data yang sepadan melalui kelas Pengguna, kami mengharapkan dia menulis kod seperti ini:

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

Antara muka di atas Sukar atau hampir sukar untuk dilaksanakan melalui kaedah konvensional, tetapi ia agak mudah melalui metaclass. Idea teras adalah untuk mengubah suai takrif kelas melalui metaclass, simpan semua atribut jenis Medan kelas dalam kamus tambahan, dan kemudian padamkannya daripada takrifan asal. Parameter yang diluluskan oleh Pengguna semasa membuat objek (id=12345, name='xiaoxiaoming', dsb.) boleh disimpan dengan meniru pelaksanaan kamus atau mewarisi secara langsung kelas 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)。

Ringkasan

Perkongsian ini menganalisis secara ringkas mekanisme pelaksanaan metaclass. Dengan melaksanakan rangka kerja ORM dan mentafsir kod sumber YAML, saya percaya anda sudah mempunyai pemahaman yang baik tentang metaclass.

Metaclass ialah ciri bahasa Python peringkat sihir hitam Ia boleh mengubah gelagat kelas apabila ia dicipta. Ciri berkuasa ini mesti digunakan dengan berhati-hati.

Selepas membaca artikel ini, pada pendapat anda, apakah perbezaan antara penghias dan metaclass? Dialu-alukan untuk meninggalkan mesej di bawah untuk berbincang dengan saya. Jangan lupa klik tiga kali berturut-turut untuk mengisi semula!

Atas ialah kandungan terperinci Metaclass sihir hitam yang mengubah peraturan objek Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!