python的元类
本文示例代码在python3.7下
一.元类(metaclass)
1.python中一切皆对象.class也是一个对象.
class A:
pass
a = A()
print(type(a))
print(type(A))
输出
<class '__main__.A'> <class 'type'>
a是A类的实例,类A(是一个class)是type的实例(注意:类A是type的实例,是object的子类,所有新式类的根类都是object)
2.A类是如何创建的?
(1).解释器检查是否有类A的元类属性,如果有则按指定元类来创建
(2).如果没有则默认使用type元类来创建
(3).对于创建类,解释器调用元类,需要使用三个参数
name:这将是需要创建的类的名称。对于我们的情况，它将是字符串'A'。
bases：该类基类的元组。
attrs：它是一个字典，包含为该类定义的所有属性
因此动态创建上述A类可以写作:
A = type('A', (), {})
3.元类:
(1).type是创建类的默认元类,指示了类如何被创建.
(2).元类只是一个可以创建类的类,就像普通类具有创建该类实例的能力一样，元类也具有创建类的能力。创建的类是元类的一个实例
(3).类是元类的一个实例
(4).由于type是默认元类，因此如果我们要编写元类，我们必须从type继承。
二.实例
1.自定义元类:
class TestMetaClass(type):
def __new__(cls, name, bases, attrs):
return super().__new__(cls, name, bases, attrs)
(1).继承自元类type
(2).在元类中覆写了__new__
(3).解释器将使用三个参数调用我们的元类，因此元类的__new__将接收四个参数。所以我们要注意__new__元类需要四个参数
(4).在__new__中我们使用超类中的__new__,如果TestMetaClass不是从type继承,实际的类创建将发生在type的__new__中
(5).任何类的__new__收到的第一个参数是类本身(上文代码中的cls)
如果我们编写元类,必须从type继承,必须覆写__new__,并且调用超类的__new__来创建类
2.使用TestMetaClass
class B(metaclass=TestMetaClass):
pass
b = B()
print(type(b))
print(type(B))
输出
<class '__main__.B'>
<class '__main__.TestMetaClass'>
b是类B的一个实例,类B是TestMetaClass的实例
(1).解释器知道默认的元类类型不能用于创建B.而是必须使用TestMetaClass来创建B.
(2).当调用MyMeta时，调用MyMeta的__new__
(3).以上代码等同于:
B = TestMetaClass('B', (), {})
b = B()
print(type(b))
print(type(B))
(4).因为TestMetaClass继承自type,所以TestMetaClass的__new__也可以定义成
class TestMetaClass(type):
def __new__(cls, name, bases, attrs):
return type.__new__(cls, name, bases, attrs)
三.type
1.type(),是一个内置函数,可以检查类型
方法为：
type(some_object)
2.type是一个内置函数,也可以动态创建类:
方法为：
type(cls类名, bases(继承的元组), attrs(属性字典))
3.type也是一个类,是创建类的默认元类
四.何时使用
1.元类使用的比较少,99%的情况下用不到
2.一个简单的例子,限制类的属性:
allowed_attributes = ['first', 'second']
class Meta(type):
def __new__(cls, name, bases, attrs):
attrs_list = list(attrs)
for each_attr in attrs_list:
if not each_attr.startswith('_') and each_attr not in allowed_attributes:
del attrs[each_attr]
print("Attributes after deleting non allowed attributes", attrs)
return type.__new__(cls, name, bases, attrs)
class B(metaclass=Meta):
first = 1
second = 2
third = 3
b = B()
注意:
上文代码中,您或许可能认为直接使用__new__就可以实现,因为__new__就是负责实例的创建.但类B中first,second等属性是静态属性,隶属于类,而不是实例,所以此处使用了元类.元类是负责类的创建.
我们使用__new__来写一个限制实例属性的(不是很恰当)
class My:
def __new__(cls, *args, **kwargs):
print(kwargs)
if not isinstance(kwargs, dict):
raise RuntimeError('参数错误')
if 'c' in kwargs:
raise RuntimeError('不能包含key为c的参数')
return super().__new__(cls)
def __init__(self, **kwargs):
self.args = kwargs
test = My(a=2, b=3, c=100)
print(test.args)
3.ORM的例子
class Field(object):
def __init__(self, name, column_type):
self.__name = name
self.__column_type = column_type
def __str__(self):
return '<%s,%s>' % (self.__name, self.__column_type)
def __getattr__(self, item):
return {'name': self.__name, 'column': self.__column_type}[item]
class IntegerField(Field):
def __init__(self, name):
super(IntegerField, self).__init__(name, 'bigint')
class ModelMetaClass(type):
def __new__(cls, name, bases, attrs):
if name == 'Model':
return type.__new__(cls, name, bases, attrs)
mappings = dict()
for k, v in attrs.items():
if isinstance(v, Field):
mappings[k] = v
for k in mappings.keys():
attrs.pop(k)
attrs['__mappings__'] = mappings
attrs['__table__'] = name
return type.__new__(cls, name, bases, attrs)
class Model(dict, metaclass=ModelMetaClass):
def __init__(self, **kwargs):
super(Model, self).__init__(**kwargs)
def __getattr__(self, key):
try:
return self[key]
except BaseException:
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([str(x) for x in args]))
print('SQL: %s' % sql)
class User(Model):
id = IntegerField('id')
# create user instance
user = User(id=100)
user.save()
