Home > Article > Backend Development > The black magic Metaclass that changes the rules of Python objects
The topic that Xiao Ming wants to share today is: the artifact of changing class definition-metaclass
When you see the title, you may wonder what is the use of changing the definition of a class? ? When do you need to use metaclass?
Today I will lead you to design a simple ORM framework and briefly analyze the principles of YAML, a serialization tool.
Speaking of metaclass, we must first understand the most basic concept that objects are instances of classes, and classes are instances of type. Repeat:
In the object-oriented programming model, a class is equivalent to the design drawing of a house. The object is a house built based on this design drawing.
In the picture below, the toy model can represent a class, and the specific produced toy can represent an object:
In short, a class is created The object's template.
And type is a template for creating classes, so we can create the classes we want through type.
For example, define a Hello class:
class Hello(object):
def hello(self, name='world'):
print('Hello, %s.' % name)
When the Python interpreter loads the hello module, it will execute all the statements of the module in sequence, and the execution result is to dynamically create a Hello class object.
The type() function can not only check the type of a type or variable, but also create a new type based on the parameters. For example, the definition of the above class is essentially:
def hello(self, name='world'):
print('Hello, %s.' % name)
Hello = type('Hello', (object,), dict(hello=hello))
type( ) function creates a class object, passing in 3 parameters in sequence:
The class created through the type() function is exactly the same as writing the class directly, because when the Python interpreter encounters the class definition, it just scans the syntax of the class definition and then calls type() The function creates the class.
Under normal circumstances, we definitely use class Xxx... to define classes, but the type() function allows us to dynamically create classes, which means that Python, a dynamic language, supports dynamic creation during runtime kind. You may not feel how powerful this is. You must know that if you want to create a class during the static language runtime, you must construct a source code string and then call the compiler, or use some tools to generate bytecode implementation. In essence, it is dynamic compilation. very complicated.
What is the relationship between type and metaclass? What exactly is metaclass?
I think metaclass is actually type or a subclass of type. By inheriting type and overloading the __call__ operator, you can make some modifications when the class object is created.
For the class MyClass:
class MyClass(): pass
is actually equivalent to:
class MyClass(metaclass = type): pass
Once we set its metaclass to MyMeta:
class MyClass(metaclass = MyMeta): pass
MyClass is no longer represented by Native type creation will instead call MyMeta's __call__ operator overload.
class = type(classname, superclasses, attributedict) ## 变为了 class = MyMeta(classname, superclasses, attributedict)
For classes with inheritance relationships:
class Foo(Bar): pass
Python does the following operations:
Imagine a silly example where you decide that all class attributes in your module should be in uppercase. There are several ways to do it, but one of them is to set __metaclass__ at the module level:
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'
ORM's full name is "Object Relational Mapping", that is Object-relational mapping is to map a row of a relational database to an object, that is, a class corresponds to a table. In this way, it is easier to write code without directly operating SQL statements.
Now design the calling interface of the ORM framework. For example, if a user wants to operate the corresponding database table User through the User class, we expect him to write code like this:
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()
The above interface passes through the regular The method is difficult or almost difficult to implement, but it is relatively simple through metaclass. The core idea is to modify the definition of the class through metaclass, save all Field type attributes of the class in an additional dictionary, and then delete them from the original definition. The parameters passed in by User when creating an object (id=12345, name='xiaoxiaoming', etc.) can be saved by imitating the dictionary implementation or directly inheriting the dict class.
其中，父类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中，一共做了几件事情：
在Model类中，就可以定义各种操作数据库的方法，比如save()，delete()，find()，update等等。
我们实现了save()方法，把一个实例保存到数据库中。因为有表名，属性到字段的映射和属性值的集合，就可以构造出INSERT语句。
测试：
u = User(id=12345, name='xiaoxiaoming', email='test@orm.org', password='my-pwd') u.save()
输出如下：