- 元编程概念来自LISP和smalltalk。 我们写程序是直接写代码,是否能够用代码来生成未来我们需要的代码吗?这就是元编程
例如,我们写一个类class A,能否用代码生成一个类出来?
- 用来生成代码的程序称为元程序metaprogram,编写这种程序就称为元编程metaprogramming
- Python语言能够通过反射实现元编程
Python中- 所有非object类都继承自object类
- 所有类的类型包括type类都是type
- type类继承自object类
- object类的类型也是type类
type类
type构建类
class type(object):
def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
"""
type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type
# (copied from class doc)
"""
pass
type(object) -> the object's type
,返回对象的类型,例如type(10)
type(name, bases, dict) -> a new type
, 返回一个新的类型
XClass = type('myclass', (object,), {'a':100, "b":'string'}) # (objcect,) 可直接为空元组()
print(XClass)
print('-' * 30)
print(XClass.__dict__)
print('-' * 30)
print(XClass.__name__)
print('-' * 30)
print(XClass.__bases__)
print('-' * 30)
print(XClass.mro())
# 执行结果
<class '__main__.myclass'>
------------------------------
{'a': 100, 'b': 'string', '__module__': '__main__',\
'__dict__': <attribute '__dict__' of 'myclass' objects>, \
'__weakref__': <attribute '__weakref__' of 'myclass' objects>, '__doc__': None}
------------------------------
myclass
------------------------------
(<class 'object'>,)
------------------------------
[<class '__main__.myclass'>, <class 'object'>]
- 创建更加复杂的类
def __init__(self):
self.x = 1000
def show(self):
print(self.__dict__)
XClass = type('myclass', (object,), {'a':100, 'show':show, '__init__':__init__})
print(XClass)
print('-' * 30)
print(XClass.__dict__)
print('-' * 30)
print(XClass.__name__)
print('-' * 30)
print(XClass.mro())
print('-' * 30)
XClass().show()
# 执行结果
<class '__main__.myclass'>
------------------------------
{'a': 100, 'show': <function show at 0x0000024D0C7B5158>,\
'__init__': <function __init__ at 0x0000024D0C7B51E0>, \
'__module__': '__main__', '__dict__': <attribute '__dict__' of 'myclass' objects>,\
'__weakref__': <attribute '__weakref__' of 'myclass' objects>, '__doc__': None}
------------------------------
myclass
------------------------------
[<class '__main__.myclass'>, <class 'object'>]
------------------------------
{'x': 1000}
总结
- 可以借助type构造任何类,用代码来生成代码,这就是元编程
构建元类
一个类可以继承自type类
- 注意不是继承自object类
class ModelMeta(type):
def __new__(cls, *args, **kwargs):
print(cls)
print(args)
print(kwargs)
return super().__new__(cls, *args, **kwargs)
继承自type,ModelMeta就是元类,它可以创建出其它类
class ModelMeta(type): # 继承自type
def __new__(cls, *args, **kwargs):
print(cls)
print(args)
print(kwargs)
print()
return super().__new__(cls, *args, **kwargs)
class A(metaclass=ModelMeta):
id = 1000
def __init__(self):
print('A.init~~~')
# 第二种 B继承自A后,依然是从ModelMeta的类型
class B(A):
def __init__(self):
print('B.init~~~')
# 第三种 元类就可以使用下面的方式创建新的类
C = ModelMeta('C', (), {})
# D、E是type的实例
class D: pass # D = type('D', (), {})
E = type('E', (), {})
class F(ModelMeta): pass
print('-' * 30)
print('A', type(A), A.__bases__)
print('B', type(B), B.__bases__)
print('C', type(C), C.__bases__)
print('~' * 30)
print('D', type(D), D.__bases__)
print('E', type(E), E.__bases__)
print('F', type(F), C.__bases__)
# 执行结果
<class '__main__.ModelMeta'>
('A', (), {'__module__': '__main__', '__qualname__': 'A',\
'id': 1000, '__init__': <function A.__init__ at 0x0000021CDD5B5268>})
{}
<class '__main__.ModelMeta'>
('B', (<class '__main__.A'>,), {'__module__': '__main__', \
'__qualname__': 'B', '__init__': <function B.__init__ at 0x0000021CDD5B5598>})
{}
<class '__main__.ModelMeta'>
('C', (), {})
{}
------------------------------
A <class '__main__.ModelMeta'> (<class 'object'>,)
B <class '__main__.ModelMeta'> (<class '__main__.A'>,)
C <class '__main__.ModelMeta'> (<class 'object'>,)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
D <class 'type'> (<class 'object'>,)
E <class 'type'> (<class 'object'>,)
F <class 'type'> (<class 'object'>,)
从运行结果还可以分析出·__new__(cls, *args, **kwargs)
的参数结构:
- 中间是一个元组
('A', (), {'__init__': <function A.__init__ at 0x0000000000B6E598>, '__module__': '__main__', '__qualname__': 'A', 'id': 100})
- 对应
(name, bases, dict)
修改代码如下
class ModelMeta(type): # 继承自type
def __new__(cls, name, bases, dict):
print('CLS : ', cls)
print('NAME : ', name)
print('BASES : ', bases)
print('DICT : ', dict)
return super().__new__(cls, name, bases, dict)
- 执行结果
CLS : <class '__main__.ModelMeta'>
NAME : A
BASES : ()
DICT : {'__module__': '__main__', '__qualname__': 'A', 'id': 1000,\
'__init__': <function A.__init__ at 0x000001DB6E6F5268>}
CLS : <class '__main__.ModelMeta'>
NAME : B
BASES : (<class '__main__.A'>,)
DICT : {'__module__': '__main__', '__qualname__': 'B', \
'__init__': <function B.__init__ at 0x000001DB6E6F5598>}
CLS : <class '__main__.ModelMeta'>
NAME : C
BASES : ()
DICT : {}
------------------------------
A <class '__main__.ModelMeta'> (<class 'object'>,)
B <class '__main__.ModelMeta'> (<class '__main__.A'>,)
C <class '__main__.ModelMeta'> (<class 'object'>,)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
D <class 'type'> (<class 'object'>,)
E <class 'type'> (<class 'object'>,)
F <class 'type'> (<class 'object'>,)
- 从运行结果可以看出,只要元类是
ModelMeta
,创建类对象时,就会调用ModelMeta
的__new__
方法 - 上例中,
F
也是元类,F --继承自--> ModelMeta --继承自--> type
- type(元类) 返回type。但是type被metaclass修改了的元类的类返回其元类
元类的应用
class Column:
def __init__(self, fieldname=None, pk = False, nullable=False):
self.fieldname = fieldname
self.pk = pk
self.nullable = nullable
def __repr__(self):
return "<{} {}>".format(__class__.__name, self.fieldname)
class ModelMeta(type):
def __new__(cls, name, bases, attrs:dict):
print(cls)
print(name, bases, attrs)
if '__tablename__' not in attrs:
attrs['__tablename__'] = name.lower() # 添加表名
primarykeys = []
for k, v in attrs.items():
if isinstance(v, Column):
if v.fieldname is None or v.fieldname.strip() == '':
v.fieldname = k # 字段没有名字使用属性名
if v.pk:
primarykeys.append(v)
attrs['__primarykeys__'] = primarykeys
return super().__new__(cls, name, bases, attrs)
class Base(metaclass=ModelMeta):
"""从ModelBase继承的类的类型都是ModelMeta"""
class Student(Base):
id = Column(pk=True, nullable=False)
name = Column('username', nullable=False)
age = Column()
print('-' * 30)
print(Student.__dict__)
元编程总结
元类是制造类的工厂,是用来构造类的类
- 构造好元类,就可以在类定义时,使用关键字参数·metaclass·指定元类,可以使用最原始的·metatype(name, bases, dict)·的方式构造一个类
- 元类的
__new__()
方法中,可以获取元类信息、当前类、基类、类属性字典
元编程一般用于框架开发中
- 开发中除非你明确的知道自己在干什么,否则不要随便使用元编程
- 99%的情况下用不到元类,可能有些程序员一辈子都不会使用元类
Django、SQLAlchemy使用了元类,让我们使用起来很方便