Python:实例对象

class Contact:    def __init__(self, name, phone):        self.name = name        self.phone = phone    def display(self):        return f"{self.name}: {self.phone}"c = Contact("艾婉婷", "13800138001")

Contact("艾婉婷", "13800138001")

Contact.__call__(...)

obj = Contact.__new__(Contact)

对于未定义 __slots__ 的普通类，实例的 __dict__ 也在此阶段一并创建。此时，实例已经在对象模型意义上成立，具备：

• 独立的身份（identity）

• 明确的类型（type）

但尚未包含任何用户定义的状态数据。

（3）调用 __init__，写入实例初始状态

在实例对象成功创建后，解释器会自动调用类中定义的 __init__ 方法：

Contact.__init__(obj, "艾婉婷", "13800138001")

这里需要强调的是，__init__ 并不创建实例，它操作的是一个已经存在的实例对象：

    def __init__(self, name, phone):        self.name = name        self.phone = phone

此时传入的 self 指向刚刚创建的实例对象。对 self.name、self.phone 的绑定操作，本质上是向实例已有的状态容器（通常是 __dict__）中写入条目。

（4）名称绑定，建立引用关系

当实例构造与初始化完成后，表达式的求值结果会被绑定到目标名称上：

c = Contact("艾婉婷", "13800138001")

这里的 c 只是当前作用域中的一个名称，用于引用该实例对象。名称绑定属于作用域与名字解析机制，与实例对象自身的结构和行为相互独立。

至此，一个实例对象从构造到可用，全部过程均发生在运行期，且每一步都遵循统一的对象模型规则。

二、实例对象的本质

从对象模型的角度看，实例对象与其他对象并无本质差异，同样具备对象的三要素：

• 身份（identity）：实例在运行期间的唯一标识

• 类型（type）：实例所属的类对象

• 值（value）：实例当前所承载的状态数据

c = Contact("艾婉婷", "13800138001")print(isinstance(c, object))   # Trueprint(type(c))                 # <class '__main__.Contact'>

这意味着实例对象：

• 可以被绑定到名称

• 可以作为函数的参数或返回值

• 可以在运行时被检查和修改

实例并不是类对象中的“内部数据”，而是独立存在的运行期实体。

三、实例属性与实例字典

1、实例字典的角色

在未引入 __slots__ 等约束的情况下，大多数实例对象都拥有独立的实例字典：

print(c.__dict__)# {'name': '艾婉婷', 'phone': '13800138001'}

实例字典用于存储：

• 实例特有的状态数据

• 运行时动态添加的实例属性

c.email = "test@example.com"print(c.__dict__)# {'name': '艾婉婷', 'phone': '13800138001', 'email': 'test@example.com'}

2、实例属性的写入语义

当执行：

c.name = "张三"

Python 的行为是：始终向实例自身写入属性，不会修改类对象中的同名属性。

实例属性在语义上始终优先于类属性。

四、实例视角下的属性查找机制

当通过实例访问属性或方法时，例如：

c.display()

解释器的查找顺序为：

（1）在实例对象的 __dict__ 中查找

（2）在实例所属类的 __dict__ 中查找

（3）沿着类的 MRO 向上查找父类

（4）若仍未找到，抛出 AttributeError

这一过程由对象模型的属性访问入口__getattribute__统一驱动，而不是由实例或类“各自决定”。

示例：

class A:    x = 10class B(A):    passb = B()b.x = 20

查找顺序结果为：

• b.__dict__['x'] → 20

• A.x 被遮蔽，但未被修改

五、方法访问与绑定行为

在 Python 中，方法（method）并不是一种独立存储于实例中的对象，而是函数对象在特定访问路径下产生的绑定结果。

1、方法来源于类属性

类体中通过 def 定义的成员，本质上是函数对象，存储于类对象的命名空间中：

class Contact:    ...    def display(self):        return f"{self.name}: {self.phone}"

此时，display 属于 Contact.__dict__，而不属于任何实例的 __dict__。实例并不持有方法本身。

2、实例访问触发绑定行为

当通过实例访问类中定义的函数属性时：

c = Contact("艾婉婷", "13800138001")m = c.display

属性解析首先在类对象中取得函数对象 display。在属性访问返回阶段，解释器会构造一个新的绑定方法对象（bound method）。该对象同时持有：

• 原始函数对象（作为可调用逻辑）

• 当前实例对象（作为隐式绑定的第一个参数）

因此，m 并不是类中存储的原始函数，而是一个临时生成的、与实例关联的方法对象。

当调用该方法时：

m()

等价于：

Contact.display(c)

需要强调的是：

• 绑定方法对象是在属性访问阶段创建的

• 该对象并不写入实例的 __dict__

• 每次通过实例访问，都会生成新的绑定方法对象

3、类访问不会发生绑定

当通过类对象访问方法属性时：

Contact.display

得到的是类对象中存储的原始函数对象，不会发生任何与实例相关的绑定行为。

因此，如果直接调用：

Contact.display()

将导致错误：

TypeError: display() missing 1 required positional argument: 'self'

原因在于 display 在定义时就约定了第一个参数用于接收实例对象，而通过类访问时，解释器不会主动替你提供这个参数。

六、实例与类的协作关系

在 Python 的对象模型中，实例对象与类对象通过清晰的职责分工协作完成面向对象语义。

• 类对象：提供行为定义与结构规范

• 实例对象：承载运行期状态并参与行为执行

1、行为共享，状态独立

类中定义的方法不会被复制到实例中。多个实例共享同一份行为定义，各自维护独立状态。

例如，创建两个实例：

c1 = Contact("艾婉婷", "13800138001")c2 = Contact("张三", "13900000002")

此时，c1.display 与 c2.display 并不存储在各自的实例字典中，display 的函数定义只存在于 Contact.__dict__ 中。

两个实例在调用该方法时，共享同一份行为定义，而它们的状态则完全独立：

print(c1.__dict__)  # {'name': '艾婉婷', 'phone': '13800138001'}print(c2.__dict__)  # {'name': '张三', 'phone': '13900000002'}

这体现了 Python 对象模型中“行为共享、状态分离”的基本原则。

2、实例作为行为执行的参与者

如前所述：

c1.display()

在语义上等价于：

Contact.display(c1)

方法体中对 self 的访问，实质上是对当前实例状态的访问。

3、实例的运行期扩展能力

实例对象本身也是普通对象，其结构在运行期并非不可变。

在未引入额外约束的情况下，可以在运行期为实例单独添加属性：

c1.email = "test@example.com"print(c1.email)     # test@example.com

该属性仅存在于 c1 的实例字典中：

print(c1.__dict__)# {'name': '艾婉婷', 'phone': '13800138001', 'email': 'test@example.com'}

而另一个实例不受影响：

print(hasattr(c2, "email"))  # False

同样，也可以为单个实例注入新的可调用行为：

def greet(self):    return f"Hello, {self.name}"c1.greet = greet.__get__(c1, Contact)print(c1.greet())   # Hello, 艾婉婷

此行为是仅属于该实例的行为，不会影响类对象及其他实例。

📘 小结

实例对象是 Python 对象模型中的基本运行期实体。实例通过类获取行为定义，通过自身结构承载状态数据。实例不是类的拷贝，也不是类的附属结构，而是与类对象协作完成面向对象语义的核心参与者。

理解实例对象，是深入理解 Python 面向对象机制、动态行为以及元编程能力的基础前提。