python3 metaclass orm

本文介绍如何使用Python的元类(Metaclass)实现简单的对象关系映射(ORM),通过自定义字段类和元类,自动将类属性转换为数据库表字段,实现Python对象与数据库表之间的映射。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在python3 利用metaclass 实现简单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.__class__.__name__, self.name)

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')
#metaclass 封装mapping 元素
class ModelMetaclass(type):

    # __new__方法接受的参数依次是:
    # 1.当前准备创建的类的对象(cls)
    # 2.类的名字(name)
    # 3.类继承的父类集合(bases)
    # 4.类的方法集合(attrs)
    def __new__(cls, name, bases, attrs):
        # 如果说新创建的类的名字是Model,那直接返回不做修改
        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 mappings:%s ==> %s" % (k, v))  # 找到映射, 这里用到上面的__str__
                mappings[k] = v
            # 结合之前,即把之前在方法集合中的零散的映射删除,
            # 把它们从方法集合中挑出,组成一个大方法__mappings__
            # 把__mappings__添加到方法集合attrs中
        for k in mappings.keys():
                attrs.pop(k)
        attrs["__mappings__"] = mappings
        attrs["__table__"] = name # 添加表名,假设表名与类名一致
        return type.__new__(cls, name, bases, attrs)
# 编写Model基类,所有继承子类自动对filed 增加
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))


class User(Model):
    # 定义类的属性到列的映射:
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

u = User(id=12345, name='hunterfox', email='test@orm.org', password='12345678')
u.save()
print(id(u))
<think>我们正在讨论Python中的元类(Metaclass)。元类是类的类,用于创建类。在Python中,类本身也是对象,它们是元类的实例。默认情况下,大多数类的元类是`type`。 元类允许我们自定义类的创建过程。我们可以通过定义一个继承自`type`的元类,并重写`__new__`或`__init__`方法来干预类的创建,从而添加一些额外的功能或修改类的属性。 一个简单的元类示例: ```python class Meta(type): def __new__(cls, name, bases, dct): # 在创建类之前可以做一些操作 dct[&#39;added_by_meta&#39;] = "Hello from Meta!" return super().__new__(cls, name, bases, dct) class MyClass(metaclass=Meta): pass obj = MyClass() print(obj.added_by_meta) # 输出: Hello from Meta! ``` 在这个例子中,`Meta`是一个元类,它继承自`type`。当创建`MyClass`时,元类的`__new__`方法被调用,我们向类的字典中添加了一个新的属性,因此所有由这个类创建的对象都会有这个属性。 元类的一个常见用途是创建API时强制某些约束,比如确保所有的方法都有文档字符串,或者自动注册子类等。 注意:元类是高级特性,通常只在复杂场景下使用,比如框架开发。在普通应用开发中,应尽量避免使用元类,而使用更简单的替代方案(如装饰器或类装饰器)。 §§相关问题§§ 1. 元类与类装饰器有什么区别和各自的适用场景? 2. 如何理解`type`是Python中的内置元类? 3. 在元类的`__new__`方法中,参数`name`、`bases`、`dct`分别代表什么? 4. 元类在哪些实际项目或框架中被广泛使用? 5. 使用元类可能带来哪些潜在问题?</think>### Python Metaclass 解说 元类(Metaclass)是 Python 中创建类的类,可理解为"类的模板"。所有类(包括内置类型)都是元类的实例,默认元类是 `type`。元类允许在类创建时动态修改类定义,常用于实现高级设计模式。 #### 核心特性: 1. **继承关系** - 所有类继承自 `object` - 所有元类继承自 `type` ```python class Meta(type): ... # 自定义元类 class MyClass(metaclass=Meta): ... # 使用元类 ``` 2. **创建过程** 类创建时调用元类的 `__new__` 和 `__init__`: ```python class Meta(type): def __new__(cls, name, bases, dct): # 控制类创建逻辑 dct["version"] = 1.0 # 动态添加属性 return super().__new__(cls, name, bases, dct) ``` 3. **典型应用场景**: - **自动注册子类**(如 ORM 框架): ```python class PluginMeta(type): registry = {} def __init__(cls, name, bases, dct): if name != "BasePlugin": PluginMeta.registry[name] = cls ``` - **强制接口约束**: ```python class InterfaceMeta(type): def __init__(cls, name, bases, dct): if "execute" not in dct: raise TypeError("必须实现 execute() 方法") ``` - **单例模式**: ```python class SingletonMeta(type): _instances = {} def __call__(cls, *args, **kwargs): if cls not in cls._instances: cls._instances[cls] = super().__call__(*args, **kwargs) return cls._instances[cls] ``` #### 注意事项: - 优先使用类装饰器替代简单需求 - 深度继承链可能增加调试难度 - 主要应用于框架开发(如 Django ORM、SQLAlchemy)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值