Python -- 元编程

关注

原创最新推荐文章于 2026-04-13 10:56:20 发布 397 阅读 AI 写同款· GEO 优化 ›

python元编程详解一、元编程的概念 元编程依赖于python的一个叫做元类的概念。元类就是当你的某段代码在被执行的过程中，另外一段代码同时在被执行。维基百科上说的很好，在面向对象编程中，元类的实例还是类。当我们定义一个类时，该类的对象都是由这个类来创建。但是类本身呢？类又是由什么来创建的呢？这个问题就引申出元类的概念了，元类可以为其他类定义属性。举个例子，下面这段代码为每个类添加了一个hello属性，而这些类都是由定义的元类创建。也就是说，这些类都会有一个hello的属性，并不需要他们自己去定义。运行上面的代码，得到阅读详情

元编程概念来自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__)