Python -- 元编程

• 元编程概念来自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使用了元类，让我们使用起来很方便