一文读懂Python的对象模型与动态属性机制

Python 对象模型的核心分类与关系验证

在 Python 的面向对象体系中，为避免概念混淆，可将对象划分为明确的三类：

• 内置类对象：解释器原生提供的类型，如 int、str、list、type、object 等；
• 自定义类对象：通过 class 关键字声明的类，默认隐式继承自 object；
• 实例对象：由上述任意一种类对象 instantiated（实例化）生成的运行时实体。

对象之间主要通过两种逻辑维度建立联系：is-kind-of（子类与父类的继承关系）和 is-instance-of（实例与其所属类的归属关系）。

第1步：界定内置类、自定义类与实例对象

class Girl(object):
    pass

girl = Girl()
print(type(girl))          # <class '__main__.Girl'>
print(isinstance(girl, Girl))  # True
print(isinstance(girl, object))  # True

执行 type(girl) 返回的是定义它的类对象 Girl。由于 Girl 默认继承自 object，因此实例 girl 同时也符合 object 的实例规范。

第2步：使用内建函数核对继承与实例归属

Python 提供了两套对称的探测手段，分别用于校验这两种关系：

• 使用 type() 或 __class__ 属性查看对象自身的类型（即判断 is-instance-of）；
• 使用 __bases__ 或 __base__ 查看类直接继承的父类元组（即判断 is-kind-of）；
• 使用 issubclass(A, B) 与 isinstance(obj, C) 进行布尔值验证。

class Girl(object):
    pass

girl = Girl()

# 查看自身类型（is-instance-of 入口）
print(girl.__class__)      # <class '__main__.Girl'>
print(Girl.__class__)      # <class 'type'>

# 查看继承链（is-kind-of 入口）
print(Girl.__base__)       # <class 'object'>
print(Girl.__bases__)      # (<class 'object'>,)

print(issubclass(Girl, object))   # True
print(isinstance(girl, object))   # True

深入 type 与 object 的元类交互循环

在对象模型的最顶层，type 与 object 构成了著名的循环依赖结构：

• type 是 object 的子类（is-kind-of）；
• object 是 type 的实例（is-instance-of）。

这一设计源于底层 C 结构的初始化顺序。创建 object 时，其内部指针指向了 PyType_Type；而在创建 type 时，将其基类指针设定为 PyBaseObject_Type。两者互为基石，使得 Python 能够将元类机制无缝嵌入语言核心。

基于此结构，所有自定义类的类型均收敛于 type，所有类的基类均收敛于 object。这也赋予了 Python 极强的动态能力。

类对象动态属性的操作与安全边界

Python 允许在类定义完成后继续追加属性，这在静态强类型语言中并不常见。其底层依赖的是类内部的属性字典映射。

第3步：向类字典安全注入新属性与方法

通过点号赋值可直接为类添加属性。该操作实质上是向类的 __dict__ 写入数据。但需要注意，__dict__ 的实际类型为 mappingproxy，它对外屏蔽了键值对的直接增删改，仅开放查询接口：

class Girl(object):
    pass

Girl.name = "古明地觉"
print(Girl.__dict__.get("name"))  # 古明地觉

# 直接操作 __dict__ 会触发拦截
try:
    Girl.__dict__["name"] = "测试"
except TypeError as e:
    print(e)  # 'mappingproxy' object does not support item assignment

若需强制修改，可借助 setattr() 或直接调用类型对象的方法（等价于委托给 __setattr__）。对于底层 hack，可通过 gc.get_referents() 穿透 mappingproxy 拿到原始字典，但该做法强烈不建议在生产环境使用。

第4步：修正实例调用时的参数传递冲突

当直接将无参函数或 lambda 赋值为类方法时，实例调用会产生参数错位。因为 Python 会将函数自动包装为绑定方法，首个位置默认为 self。

Girl.info = lambda name: f"我是{name}"
# Girl().info("古明地觉")  # TypeError: 多传了一个参数

# 方案A：包装为静态方法，解除 self 绑定
Girl.info = staticmethod(lambda name: f"我是{name}")
Girl().info("古明地觉")  # 正常输出

# 方案B：显式预留 self 参数
Girl.info = lambda self, name: f"我是{name}"
Girl().info("古明地觉")  # 正常输出

内置类型的静态固化与内存优化策略

尽管 type 能够灵活操控通过 class 定义的动态类，但它无法修改内置类型（如 int、list）的属性：

try:
    int.name = "demo"
except Exception as e:
    print(e)  # can't set attributes of built-in/extension type 'int'

根本原因在于执行效率与内存管理的权衡。Python 虚拟机（CPython）的动态特性发生在字节码翻译阶段，而内置类及其衍生实例的内存布局在解释器启动阶段就已通过 C 结构体静态分配完毕。它们跳过了常规的解释执行流，因此不具备运行时挂载 __dict__ 的空间。

验证这一点非常简单，内置类型的实例对象不包含 __dict__ 属性：

a = 123
print(hasattr(a, "__dict__"))  # False

省略实例属性字典能大幅降低内存开销。若需保存扩展状态，应直接使用类的组合或实现 __slots__ 来精确控制字段占用。

以上就是Python对象模型与动态属性机制的详细内容，更多关于Python高级特性的资料请关注本站其它相关文章！