Python 描述符与元类:从 Django ORM 到自定义属性系统的进阶之路

Python元类与高级编程技巧全解析 Python作为一门动态语言,其元编程能力是其强大灵活性的核心所在。从基础的描述符协议到高级的元类系统,Python提供了一整套元编程工具链。描述符作为属性访问的底层机制,实现了@property等高级特性;而元类作为'类的类',则能深度控制类的创建过程。这些技术在ORM框架开发、插件系统实现等场景中发挥着关键作用。通过理解Python对象模型、描述符协议和元类机制,开发者能够编写出更灵活、更强大的代码,如实现自动注册子类、动态属性控制等功能。本文以Django模型系统为例,展示了如何利用元类构建ORM框架 阅读详情

Python 描述符与元类:从 Django ORM 到自定义属性系统的进阶之路

cover

一、当你写下 model.field 时,底层到底发生了什么

用过 Django ORM 的人对这种写法再熟悉不过:User.objects.filter(name="test"),user.name = "Alice"。看起来就是在操作普通属性,但实际上每次属性访问都经过了描述符协议的拦截和转换。这种"魔法"背后的机制就是描述符(Descriptor)。

更深层的问题是:当项目规模变大,普通的 Python 类和属性管理开始力不从心。字段验证逻辑散落在各处,类型检查靠手动 if-else,属性变更无法追踪。这些痛点的根源在于 Python 默认的属性访问机制过于简单——直接从 __dict__ 读写,没有任何拦截点。

描述符和元类提供的就是这些拦截点。描述符控制属性的访问行为,元类控制类的创建行为。二者组合起来,就能构建出像 Django ORM 那样优雅且强大的属性系统。

二、描述符协议与元类机制的底层剖析

graph TD
    A[属性访问 obj.attr] --> B{attr 是否是描述符?}
    B -->|否| C[直接从 obj.__dict__ 读取]
    B -->|是| D{是数据描述符还是非数据描述符?}

    D -->|数据描述符<br>定义了 __set__ 或 __delete__| E[优先调用描述符的 __get__]
    D -->|非数据描述符<br>仅定义了 __get__| F{obj.__dict__ 中有无同名属性?}

    F -->|有| G[返回 obj.__dict__ 中的值]
    F -->|无| H[调用描述符的 __get__]

    I[类创建 class Foo: ...] --> J{指定了 metaclass?}
    J -->|否| K[使用默认 type 创建类]
    J -->|是| L[调用 metaclass.__new__ 和 __call__]
    L --> M[在 __new__ 中可以修改类属性、添加方法、注册类]
    M --> N[返回修改后的类对象]

描述符协议的核心规则:

  1. 数据描述符(定义了 __get__ + __set__/__delete__)优先级最高,即使实例 __dict__ 中有同名属性也会被拦截。
  2. 非数据描述符(仅定义 __get__)优先级低于实例 __dict__,实例属性会覆盖它。
  3. 描述符必须定义在类上(而非实例上),因为 Python 的属性查找机制是从类开始的。

元类的核心机制: 元类是"类的类",控制类的创建过程。当 Python 解释器遇到 class 语句时,会先查找元类(通过 metaclass 参数或继承链),然后调用元类的 __new__ 和 __init__ 来构建类对象。这给了我们在类创建时进行元编程的机会。

三、生产级实现:带验证和变更追踪的属性系统

"""
类型安全的属性系统,支持:
1. 类型验证(运行时类型检查)
2. 变更追踪(记录属性修改历史)
3. 默认值与必填约束
4. 自定义验证器
"""
from __future__ import annotations
import typing
from typing import Any, Callable, Optional, Type, Generic, TypeVar, get_type_hints
from dataclasses import dataclass, field
from datetime import datetime


T = TypeVar("T")


@dataclass
class FieldChange:
    """记录单次属性变更"""
    field_name: str
    old_value: Any
    new_value: Any
    timestamp: datetime = field(default_factory=datetime.now)


class ValidatedField(Generic[T]):
    """
    数据描述符:带类型验证和变更追踪的属性

    用法:
        class User(TrackedModel):
            name: str = ValidatedField(str, min_length=1, max_length=100)
            age: int = ValidatedField(int, ge=0, le=150)
    """

    def __init__(
        self,
        field_type: Type[T],
        *,
        default: Optional[T] = None,
        required: bool = False,
        min_length: Optional[int] = None,
        max_length: Optional[int] = None,
        ge: Optional[float] = None,       # greater than or equal
        le: Optional[float] = None,       # less than or equal
        validator: Optional[Callable[[T], bool]] = None,
        validator_msg: str = "自定义验证失败",
    ):
        self.field_type = field_type
        self.default = default
        self.required = required
        self.min_length = min_length
        self.max_length = max_length
        self.ge = ge
        self.le = le
        self.validator = validator
        self.validator_msg = validator_msg
        self.attr_name: Optional[str] = None  # 由元类设置

    def __set_name__(self, owner: type, name: str) -> None:
        """Python 3.6+ 自动调用,获取属性名"""
        self.attr_name = f"_validated_{name}"

    def __get__(self, obj: Any, objtype: Optional[type] = None) -> T:
        if obj is None:
            # 类级别访问,返回描述符自身
            return self  # type: ignore
        return getattr(obj, self.attr_name, self.default)

    def __set__(self, obj: Any, value: Any) -> None:
        # 类型检查
        if value is not None and not isinstance(value, self.field_type):
            raise TypeError(
                f"字段 '{self.attr_name}' 期望类型 {self.field_type.__name__}, "
                f"实际收到 {type(value).__name__}"
            )

        # 必填检查
        if self.required and value is None:
            raise ValueError(f"字段 '{self.attr_name}' 为必填项")

        # 字符串长度验证
        if isinstance(value, str):
            if self.min_length is not None and len(value) < self.min_length:
                raise ValueError(
                    f"字段 '{self.attr_name}' 长度不能小于 {self.min_length}"
                )
            if self.max_length is not None and len(value) > self.max_length:
                raise ValueError(
                    f"字段 '{self.attr_name}' 长度不能超过 {self.max_length}"
                )

        # 数值范围验证
        if isinstance(value, (int, float)):
            if self.ge is not None and value < self.ge:
                raise ValueError(
                    f"字段 '{self.attr_name}' 值不能小于 {self.ge}"
                )
            if self.le is not None and value > self.le:
                raise ValueError(
                    f"字段 '{self.attr_name}' 值不能超过 {self.le}"
                )

        # 自定义验证器
        if self.validator is not None and value is not None:
            if not self.validator(value):
                raise ValueError(self.validator_msg)

        # 记录变更
        old_value = getattr(obj, self.attr_name, None)
        if old_value != value and hasattr(obj, "_change_log"):
            field_display = self.attr_name.replace("_validated_", "")
            obj._change_log.append(FieldChange(
                field_name=field_display,
                old_value=old_value,
                new_value=value,
            ))

        setattr(obj, self.attr_name, value)


class TrackedModelMeta(type):
    """
    元类:自动收集 ValidatedField,设置必填默认值检查
    """
    def __new__(
        mcs,
        name: str,
        bases: tuple,
        namespace: dict,
    ):
        # 收集所有 ValidatedField 描述符
        validated_fields: dict[str, ValidatedField] = {}
        for base in bases:
            if hasattr(base, "_validated_fields"):
                validated_fields.update(base._validated_fields)

        for attr_name, attr_value in namespace.items():
            if isinstance(attr_value, ValidatedField):
                validated_fields[attr_name] = attr_value

        namespace["_validated_fields"] = validated_fields
        cls = super().__new__(mcs, name, bases, namespace)
        return cls


class TrackedModel(metaclass=TrackedModelMeta):
    """
    带变更追踪的模型基类
    所有 ValidatedField 的修改都会被记录
    """
    _validated_fields: dict[str, ValidatedField] = {}

    def __init__(self, **kwargs: Any):
        self._change_log: list[FieldChange] = []

        # 设置默认值
        for name, field_desc in self.__class__._validated_fields.items():
            if name in kwargs:
                setattr(self, name, kwargs[name])
            elif field_desc.default is not None:
                setattr(self, name, field_desc.default)
            elif field_desc.required:
                raise ValueError(f"必填字段 '{name}' 未提供")

    def get_changes(self) -> list[FieldChange]:
        """获取所有变更记录"""
        return list(self._change_log)

    def clear_changes(self) -> None:
        """清空变更记录"""
        self._change_log.clear()

    def to_dict(self) -> dict[str, Any]:
        """导出为字典"""
        result = {}
        for name in self.__class__._validated_fields:
            result[name] = getattr(self, name)
        return result


# ===== 使用示例 =====

def is_valid_email(value: str) -> bool:
    """简单的邮箱格式验证"""
    return "@" in value and "." in value.split("@")[-1]


class User(TrackedModel):
    """用户模型,演示描述符 + 元类的完整能力"""
    name: str = ValidatedField(str, required=True, min_length=1, max_length=50)
    email: str = ValidatedField(
        str, required=True,
        validator=is_valid_email,
        validator_msg="邮箱格式不正确",
    )
    age: int = ValidatedField(int, ge=0, le=150, default=0)
    role: str = ValidatedField(str, default="viewer")


if __name__ == "__main__":
    # 正常创建
    user = User(name="Alice", email="alice@example.com", age=28)
    print(f"用户: {user.to_dict()}")

    # 修改属性,变更会被追踪
    user.name = "Bob"
    user.age = 30
    user.role = "admin"

    print("\n变更记录:")
    for change in user.get_changes():
        print(f"  {change.field_name}: {change.old_value} -> {change.new_value}")

    # 类型验证
    try:
        user.age = "not_a_number"
    except TypeError as e:
        print(f"\n类型错误: {e}")

    # 范围验证
    try:
        user.age = 200
    except ValueError as e:
        print(f"范围错误: {e}")

    # 自定义验证器
    try:
        user.email = "invalid-email"
    except ValueError as e:
        print(f"验证错误: {e}")

    # 必填验证
    try:
        User(email="test@example.com")  # 缺少 name
    except ValueError as e:
        print(f"必填错误: {e}")

关键设计点说明:

  1. __set_name__ 是 Python 3.6 引入的协议方法,描述符在类创建时自动获知自己的属性名,不再需要手动传 name 参数。

  2. 元类 TrackedModelMeta 的职责是收集描述符。它遍历类命名空间和基类,把所有 ValidatedField 实例汇总到 _validated_fields 字典中,供 __init__ 和 to_dict 使用。

  3. 变更追踪通过 _change_log 列表实现,每次 __set__ 时比较新旧值,不同则记录。这在审计和调试场景中非常实用。

四、描述符与元类的代价和适用边界

调试困难是最大的痛点。 描述符拦截了属性访问,调试器中看到的属性值可能不是直接存储在 __dict__ 中的那个。元类修改了类的创建过程,IDE 的代码补全和静态分析工具经常无法正确推断。

隐式行为增加认知负担。 新人看到 user.name = "Bob" 不会想到这背后触发了类型检查和变更记录。这种隐式行为在团队协作中需要良好的文档和代码规范来约束。

适用场景:

  • ORM 字段定义(Django、SQLAlchemy 的核心机制)
  • 配置管理系统(类型安全的配置项)
  • API 数据模型(自动验证和序列化)
  • 审计系统(变更追踪和日志记录)

不适用场景:

  • 简单的数据容器——用 dataclass 就够了
  • 性能敏感的热路径——描述符的额外调用开销不可忽视
  • 小团队快速迭代的项目——元类的隐式行为会拖慢理解速度

一个踩坑记录: 在 __set__ 中调用 getattr(obj, self.attr_name) 时,如果 self.attr_name 和描述符的公开属性名相同,会触发无限递归(__set__ → getattr → __get__ → __set__ → ...)。解决方案是使用不同的内部存储名,如 _validated_{name}。

五、总结

Python 描述符协议通过 __get__、__set__、__delete__ 三个方法拦截属性访问,数据描述符优先级高于实例属性,非数据描述符优先级低于实例属性。元类通过控制类的创建过程实现元编程,__set_name__ 协议简化了描述符与属性名的绑定。描述符和元类组合适用于 ORM、配置管理和审计系统等需要属性拦截和类级别元编程的场景,但隐式行为会增加调试和团队协作成本,简单场景应优先使用 dataclass。

Python面向对象编程进阶:魔法方法、描述符与元类深度解析 面向对象编程是软件工程的核心范式,它通过封装、继承和多态三大特性构建模块化、可复用的代码结构。在Python中,这一范式通过一系列特殊协议实现,其中魔法方法允许开发者定制对象在生命周期中的各种行为,例如通过__new__控制实例创建,__init__负责初始化。描述符协议则提供了更精细的属性访问控制机制,它是实现数据验证、惰性求值等高级特性的基础,广泛应用于Django ORM等框架中。理解这些底层原理,不仅能提升代码的内聚性和可维护性,更是深入掌握Flask、SQLAlchemy等流行框架设计思想的必经之 阅读详情

相关推荐

Python 描述符:处理复杂属性逻辑的好帮手

Python 描述符是支撑动态属性行为的核心机制,通过定义__get____set____delete__协议方法,能够将复杂的属性逻辑(如类型验证、延迟计算、跨属性约束)封装为可复用的组件。本文从第一性原理出发,系统解析描述符的理论基础、实现机制与工程应用,覆盖从基础概念到高级实践的全生命周期,结合真实框架(如 SQLAlchemy、Django ORM)的案例分析,帮助开发者掌握这一“属性逻辑管家”的核心能力。描述符解决的核心问题是属性访问的控制权转移逻辑复用。

AI天才研究院 1014

Python 属性描述符:从原理到 ORM 实践详解

本文深入讲解了Python属性描述符的核心概念与应用。首先从property的局限性出发,说明属性描述符如何解决多字段校验的代码复用问题。详细介绍了描述符的定义与分类(数据/非数据描述符),重点分析了Python属性查找的完整流程及描述符在其中扮演的关键角色。通过ORM框架的底层实现原理,展示了描述符在实际开发中的强大价值。掌握属性描述符不仅能编写更优雅的Python代码,更是理解主流框架底层机制的重要基础。

软件科学-郝学胜 2453

Python实现轻量级ORM框架与源码解析

在并发环境下,单条 SQL 很难保证业务完整性。比如:“给用户扣款的同时,要记录交易日志,两者必须同时成功或失败。这就需要用到事务。回顾全文,你会发现 ORM 并没有多少神秘之处。它所依赖的技术——元类、描述符、上下文管理器、动态代理——全是 Python 自带的能力。真正的难点不在于“怎么做”,而在于“为什么要这么做”。一个好的 ORM,不仅要让你写得爽,更要让你读得懂、改得动、调得准。当你下次看到时,希望你能微微一笑:“哦,原来你背后经历了这么多故事啊。

weixin_42452924的博客 681

[Python] 详解从属性描述符到实现ORM模型

[Python] 详解从属性描述符到实现ORM模型1. 什么是描述符?2. 理解类属性和实例属性访问的不同3. 开始写描述符4. 理解 self、instance 和 owner 参数5. 使用 getattr 和 setattr 替代字典以改写描述符类6. 使用元类注解类的属性7. 用描述符和元类仿照 Django 实现 ORM 模型 1. 什么是描述符? 描述符是对多个属性运用相同存取逻辑的一种方式。例如,Django ORM 和 SQLAlchemy 等 ORM 中的字段类型是描述符,把数据库记录

Spade_的博客 1109

AppStore逆向分析:从网络抓包到自动化模拟的完整实践

在移动应用生态中,理解客户端与服务器之间的通信协议是进行自动化测试、数据分析和系统集成的关键技术基础。通过分析网络请求与响应,可以深入理解认证、会话管理和数据交换的原理,这对于构建稳定的自动化流程至关重要。其技术价值在于能够实现合法场景下的流程模拟,例如应用元数据监控、沙盒环境测试或内部工具开发。在实际应用场景中,开发者常需处理登录态维持、请求签名验证及风控策略应对等挑战。本文聚焦于AppStore这一封闭生态,详细拆解了其登录、查询等核心环节的通信机制,并探讨了使用Python结合抓包工具进行安全逆向分析

weixin_42524171的博客 934

从零到一:YOLOv11高帧率模型在RDK X5上的ONNX转换与部署实战

本文详细介绍了将最新的YOLOv11高帧率模型部署到地平线RDK X5开发板的完整实战流程。内容涵盖从PyTorch模型导出ONNX、地平线工具链环境配置与模型量化编译,到编写高效的板端推理代码,并针对高帧率目标进行了后处理优化。通过实战避坑指南,帮助开发者在RDK X5上实现30FPS以上的实时目标检测。

weixin_29089057的博客 144

Python高阶专题:元类编程以及Django框架ORM的实现

1. 元类编程 在了解元类编程之前首先要明白类这个概念,按照类的定义可以理解类是创建对象的实例的模板,Python明确说明了在Python中一切皆对象,那么可以理解类也是对象,如果类是对象,那么一定就有创建类的模板,元类编程可以说是创建类的模板 1.1 运行时动态创建类 类创建的查找顺序 : 优先查找metaclass指定的类创建,如果没有找到查找其类的继承链,之后调用type()创建类 1.1.1 常规的动态创建类的方式 /*通过用户的选择创建不同的权限的用户*/ def CreateUserClass

Mr_zhangbz的博客 460

ROS2进程内通信:零拷贝Intra-Process原理与实战

Intra-Process通信是ROS2实现低延迟节点间数据交换的核心机制,其本质是通过C++17智能指针与零拷贝共享内存,在同一进程内绕过序列化、系统调用和上下文切换。相比传统DDS跨进程通信,它将`geometry_msgs::Twist`类消息延迟从42μs降至0.8μs,显著提升机器人实时控制性能。该技术并非自动启用,需满足同执行器、QoS严格匹配、内存所有权明确三大约束,适用于机械臂控制、视觉SLAM、图像处理流水线等对端到端延迟敏感的场景。本文聚焦ROS2原生Intra-Process通讯的原理

weixin_30619101的博客 365

Python元类与ORM框架开发实战指南

元类作为Python中控制类创建行为的核心机制,是理解高级编程和框架设计的关键。通过定义'类的类',开发者可以干预类的生成过程,这在ORM(对象关系映射)框架中尤为重要。ORM技术实现了数据库表到Python类的映射,使得开发者可以用面向对象的方式操作数据库,这是现代Web开发的基础设施。在实际工程中,自定义元类能够实现字段自动映射、动态生成CRUD方法等核心功能,特别适合需要轻量级解决方案或特殊数据库支持的场景。本文以Django ORM为参照,深入解析如何利用元类开发自定义ORM框架,涵盖从基础字段系统

weixin_30892763的博客 695

Uniapp返回上一页并刷新:亲测有效的 goBack 实现技巧!

这个技巧在实际开发中非常常用,特别适合表单提交后返回列表刷新这类场景。比起依赖onShow或复杂的vuex状态同步,这种方式更直接、好维护,也不容易出 bug。

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 1845

电机驱动器MP6540H应用设计

/ ... 其他初始化函数(SystemClock_Config, MX_GPIO_Init, MX_TIM1_Init, MX_TIM2_Init)需要你根据STM32CubeMX生成或手动编写。// 假设霍尔传感器引脚是 GPIO_PIN_8, GPIO_PIN_9, GPIO_PIN_10。// 低侧U相GPIO引脚。

zhusl6688的博客 665

Python元类编程:从基础到ORM框架实战

元类(Metaclass)是Python面向对象编程的终极武器,它作为'类的类'控制着类的创建过程。理解元类需要掌握三个关键层级:对象是类的实例、类是type的实例、type本身可编程。这种设计使得Python既能保持语法简洁,又能支持Django ORM等复杂框架开发。通过描述符协议和类型自省,元类可以实现自动API注册、DSL构建等高级功能。在Web开发领域,ORM框架利用元类将模型定义转换为SQL语句,实现声明式编程。掌握元类技术有助于深入理解Python对象模型,但需注意其适用场景应限制在类注册、属

weixin_34008933的博客 292

YOLOv12涨点改进 | 全网独家首发Conv改进篇 | Arxiv 2025 | 引入一种新的WConv加权卷积改进YOLOv12,显著提升其特征提取能力和目标检测精度

本文提出了一种新型加权卷积(WConv)模块,通过引入最优密度函数动态调整邻域像素权重,显著提升了YOLOv12目标检测性能。WConv在保持参数数量不变的情况下,提高了模型精度(VGG准确率提升10%)、增强了小目标检测能力,并改善了多尺度特征提取。文中详细介绍了模块原理、网络结构改进方法,并提供了核心代码实现和yaml配置文件。实验表明,该方法在图像任务中最高可降低53%的损失,虽然会带来11%的时间开销,但具有优异的鲁棒性。该技术可广泛应用于2D/3D图像处理领域。

Ai缝合怪、助力小伙伴高效发论文 219

深度解析ORM字段与元类设计:从零构建优雅的数据映射内核

本文深度剖析ORM框架的核心设计原理,聚焦字段系统与元类机制两大关键技术。通过实现IntField和CharField字段类,演示了如何通过描述符协议实现数据校验和存储,其中IntField管控数值范围,CharField限制字符串长度。文章重点解析元类ModelMetaclass的工作原理,展示其如何自动完成类属性扫描、字段注册和表名映射。设计严格遵循Django规范,实现了高内聚低耦合的架构,既能确保数据安全,又具备良好扩展性。这套方案不仅可用于自研轻量级ORM,更能帮助开发者深入理解主流ORM框架的底

软件科学-郝学胜 459

【006】深入了解C++中的进制转换:二进制、八进制、十进制、十六进制

二进制:0~1,以0b开头,bitset< 8 >输出。八进制:0~7,以0开头,oct输出。十进制:0~9,以数字开头,cout默认输出十进制。十六进制:0 ~ 9和A ~ F,以0x开头,hex输出,不区分正负。n进制:0~n-1。C++ 中常见的数字进制有十进制、二进制、八进制、十六进制。从十进制转换到其他进制:二进制:使用除以 2 取余数的方法,将得到的余数倒序排列即为二进制。八进制:使用除以 8 取余数的方法,将得到的余数倒序排列即为八进制。

Lion_Long的博客 2614

30天入门 SAP BTP 开发系列之七:动手在 SAP BTP 上开发第一个 ABAP 程序

本教程从理论转向实践,指导如何在SAP BTP上创建首个ABAP程序。首先通过Booster向导在Trial账号中配置ABAP环境,需确保已启用Cloud Foundry并创建Space。成功创建ABAP实例后,使用ABAP Development Tool连接环境:下载服务密钥文件,导入工具获取连接URL,即可建立项目开始编码。教程提供了从环境搭建到开发工具配置的完整流程,帮助ABAP开发者快速上手BTP云开发。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1685

python元类的元类_深入理解 Python 中的元类

1. 类是如何产生的类是如何产生?这个问题肯定很傻。实则不然,很多初学者只知道使用继承的表面形式来创建一个类,却不知道其内部真正的创建是由type来创建的。type?这不是判断对象类型的函数吗?是的,type通常用法就是用来判断对象的类型。但除此之外,他最大的用途是用来动态创建类。当Python扫描到class的语法的时候,就会调用type函数进行类的创建。2. 如何使用type创建类首先,typ...

weixin_39786706的博客 108

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Python元类实战:手写ORM框架解析数据库映射原理

元类(Metaclass)是Python中控制类创建过程的高级特性,通过拦截类定义实现动态修改类行为。在数据库编程领域,ORM框架利用元类将类属性映射为数据库字段,实现对象与关系型数据的自动转换。本文以构建简易ORM框架为例,详解如何通过元类实现模型定义、字段类型转换和SQL语句生成等核心功能,帮助开发者深入理解Django和SQLAlchemy等主流ORM框架的底层机制。通过实践Python元编程技术,开发者可以掌握数据库操作抽象、查询构造优化等工程实践方法,提升Web开发效率。

weixin_34389926的博客 355

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

python元类编程_Python进阶开发之元类编程

系列文章本文目录.类是如何产生的类是如何产生?这个问题肯定很傻。实则不然,很多人只知道使用继承的表面形式来创建一个类,却不知道其内部真正的创建是由type来创建的。type?这不是判断对象类型的函数吗?是的,type通常用法就是用来判断对象的类型。但除此之外,他最大的用途是用来动态创建类。当Python扫描到class的语法的时候,就会调用type函数进行类的创建。.如何使用type创建类首先,t...

weixin_39775577的博客 96

python元类编程_Python学习之元类编程

原标题:Python学习之元类编程类是如何产生的类是如何产生?这个问题肯定很傻。实则不然,很多人只知道使用继承的表面形式来创建一个类,却不知道其内部真正的创建是由type来创建的。type?这不是判断对象类型的函数吗?是的,type通常用法就是用来判断对象的类型。但除此之外,他最大的用途是用来动态创建类。当Python扫描到class的语法的时候,就会调用type函数进行类的创建。如何使用type...

weixin_39746552的博客 100

浅析 python 属性描述符(上)

转载自我自己的 github 博客 ——> 半天钟的博客 元编程相关博文的目录及链接 这篇博文是元编程系列博文中的其中一篇、这个系列中其他博文的目录和连接见下: 使用 python 特性管理实例属性 浅析 python 属性描述符(上) 浅析 python 属性描述符(下) python 导入时与运行时 python 元编程之动态属性 python 元编程之类元编程 Review 在上一...

BanTianZhong的博客 1678

Python描述符协议深度剖析:从@property到ORM,属性访问的底层真相

大多数 Python 开发者每天都在用描述符(@property、Django ORM、SQLAlchemy),却从未真正理解它背后的协议。

ITOfDragon的博客 375

python编写代码定义一个形状基类_Python进阶开发之元类编程

系列文章本文目录.类是如何产生的类是如何产生?这个问题肯定很傻。实则不然,很多人只知道使用继承的表面形式来创建一个类,却不知道其内部真正的创建是由type来创建的。type?这不是判断对象类型的函数吗?是的,type通常用法就是用来判断对象的类型。但除此之外,他最大的用途是用来动态创建类。当Python扫描到class的语法的时候,就会调用type函数进行类的创建。.如何使用type创建类首先,t...

weixin_39795292的博客 607

从 Python 描述符看 ORM 的魔法:字段映射、校验、延迟加载与查询构建

Python描述符在ORM中的应用:属性访问背后的魔法 本文揭示了Python ORM框架背后的核心机制——描述符。描述符通过实现__get__、__set__等方法,能够拦截属性访问,为ORM提供了强大的基础能力。 主要内容包括: 描述符基础:介绍描述符的基本概念和工作原理 ORM需求:解释ORM如何通过描述符实现字段映射、类型校验等复杂功能 实现细节: 字段名自动绑定(__set_name__方法) 类型校验与数据清洗 不同字段类型(StringField、IntegerField)的实现 通过一个简化

铭渊老黄 204
上一篇: 用 Rust 构建 AI 命令行工具:从 ONNX Runtime 到智能 Agent 的实战路径
下一篇: WebAssembly AI 插件:浏览器端推理的架构设计与 Rust 实战
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值