Python类与对象关系详解

本文深入解析了Python类与对象在源码层面的关系，揭示了“一切皆对象”的底层实现机制。通过剖析CPython的基石PyObject和PyTypeObject，阐述了对象如何在C层面共享结构体，并通过类型指针区分不同类型。文章详细介绍了类与元类的协作方式，元类如何通过tp_new/tp_init定制类的构造与行为，以及继承如何通过tp_base和tp_mro维护父子关系，实现属性查找。此外，还探讨了多态的实现原理，依赖PyObject统一接口和运行时动态调用协议函数，实现“鸭子类型”式的动态分派。本文旨在帮助读者从源码层面理解Python面向对象设计的精髓，掌握Python对象模型的底层运作机制。

Python中“一切皆对象”的底层实现机制是所有对象在C层面都基于PyObject结构体，共享ob_refcnt（引用计数）和ob_type（指向PyTypeObject类型对象）字段，使得整数、字符串、函数、类本身等均统一为PyObject*指针，行为由ob_type指向的PyTypeObject定义；2. 类与元类协作方式为：每个类是PyTypeObject实例，其ob_type指向元类（通常是PyType_Type），元类通过tp_new/tp_init创建并配置类对象的tp_dict、tp_base等字段，实现类的构造与行为定制；3. 继承通过tp_base和tp_bases维护父子关系，并在类初始化时计算tp_mro（方法解析顺序）用于属性查找，多态则依赖PyObject统一接口和运行时根据ob_type动态调用对应PyTypeObject中协议函数（如tp_call、tp_iter），实现“鸭子类型”式动态分派。

Python源码中，类与对象的关系远比我们平时使用Python时感受到的要深邃和自洽。在我看来，它们本质上都共享一个最基础的C语言结构——PyObject，而它们之间的差异和面向对象特性，则通过这个结构中的一个关键指针，指向不同的PyTypeObject来定义和实现。这就像是，所有Python世界里的“东西”，无论是一个整数、一个字符串、一个列表，甚至是一个函数，它们最核心的身份标识都是一个PyObject*指针，而这个指针所指向的PyObject内部，又有一个ob_type字段，它指向了描述这个“东西”具体行为和属性的“蓝图”——那个PyTypeObject。这种设计，巧妙地构建了一个递归的、自举的面向对象体系，让“一切皆对象”不仅仅是口号，而是实实在在的底层实现。

解决方案

要深入理解Python源码中的类与对象关系，我们必须从CPython的基石PyObject和PyTypeObject说起。

1. PyObject：万物之源

在CPython的C语言实现中，所有Python对象在内存中的表示都始于一个名为PyObject的结构体（或其变体）。它通常包含两个基本字段：

struct _object {
    Py_ssize_t ob_refcnt; // 引用计数
    PyTypeObject *ob_type; // 指向其类型对象（PyTypeObject）的指针
};
typedef struct _object PyObject;

• ob_refcnt：这是Python内存管理的核心，用于垃圾回收的引用计数。当这个计数归零时，对象通常会被销毁。
• ob_type：这是关键所在！它是一个指向PyTypeObject的指针，明确地告诉运行时这个PyObject实例到底是什么类型（例如，是一个整数、一个字符串，还是我们自定义的某个类的实例）。

这意味着，无论你在Python代码中创建一个int、一个str、一个list，还是一个MyClass的实例，在C层面，它们都首先被视为一个PyObject*指针。它们的具体行为和内部数据结构，完全由ob_type所指向的PyTypeObject来定义。

2. PyTypeObject：类型的蓝图与行为定义

如果说PyObject是所有对象的基石，那么PyTypeObject就是所有“类型”的基石。一个PyTypeObject实例描述了特定类型（比如int、str、list，或者你定义的MyClass）的所有特性和行为。它本身也是一个PyObject，这意味着类型也是对象，这便是Python面向对象设计的精妙之处——“元类”的概念由此而生。

PyTypeObject结构体非常庞大，包含了大量的函数指针和字段，用于定义：

• 基本信息：tp_name（类型名称）、tp_basicsize（实例的基本大小）、tp_itemsize（变长对象元素大小）。
• 生命周期管理：tp_dealloc（析构函数）、tp_init（初始化函数，对应Python的__init__）。
• 对象操作：tp_repr（repr()）、tp_str（str()）、tp_call（可调用对象）、tp_getattr、tp_setattr（属性访问）。
• 数据结构：tp_dict（类型字典，存储类属性和方法）、tp_methods（C扩展方法）、tp_members（C结构体成员）。
• 继承关系：tp_base（单继承的基类）、tp_bases（多继承的基类元组）、tp_mro（方法解析顺序）。
• 协议实现：tp_as_number（数值操作）、tp_as_sequence（序列操作）、tp_as_mapping（映射操作）等，这些都是指向特定C结构体的指针，结构体内部又包含了针对该协议的各种操作函数指针。

3. 类与实例的创建流程

当我们定义一个Python类，例如class MyClass:，并在运行时执行它时，CPython会：

• 创建类对象：解释器会创建一个PyTypeObject的实例来代表MyClass这个类本身。这个PyTypeObject的ob_type字段会指向PyType_Type（即Python内置的type类型对象），因为MyClass是type的实例。这个MyClass的PyTypeObject会填充其tp_name为"MyClass"，并根据类定义填充tp_dict（存储类方法、类变量等）。
• 创建实例对象：当我们调用my_instance = MyClass()时，CPython会：
  1. 调用MyClass这个PyTypeObject的tp_new（通常是PyType_GenericNew）来分配内存。这会创建一个新的PyObject实例。
  2. 新创建的PyObject实例的ob_type指针会被设置为指向MyClass的PyTypeObject。
  3. 最后，如果定义了__init__方法，MyClass的tp_init函数指针会被调用，执行Python层面的__init__逻辑，完成实例的初始化。

4. 属性访问与方法调用

当访问my_instance.attribute或调用my_instance.method()时，CPython会：

• 属性查找：首先在my_instance自身的__dict__（这是一个PyDictObject）中查找。
• 类属性/方法查找：如果实例中没有，则通过my_instance->ob_type（即MyClass的PyTypeObject）的tp_dict中查找。
• 继承链查找：如果MyClass的tp_dict中也没有，则根据MyClass的PyTypeObject中的tp_mro（方法解析顺序）链，向上查找其基类的tp_dict。
• 调用：如果找到的是一个方法，它通常是一个PyFunctionObject。当它被调用时，会把实例my_instance作为第一个参数（self）传递过去。

这种层层递进、环环相扣的设计，构成了Python强大而灵活的面向对象模型。它让我常常感慨，一个看似简单的语言特性，其背后隐藏的工程智慧是如此的深邃。

Python中“一切皆对象”的底层实现机制是什么？

“一切皆对象”是Python最核心的哲学之一，在CPython源码层面，它的实现机制归根结底在于PyObject这个统一的基石。无论你操作的是一个整数1，一个字符串"hello"，一个列表[1, 2, 3]，甚至是一个函数、一个模块、一个类本身，它们在C语言的内存中，都被表示为一个PyObject*指针。这意味着，所有这些不同类型的数据，都共享了PyObject结构体中的引用计数（ob_refcnt）和类型指针（ob_type）这两个基本字段。

这种统一的结构带来了极大的便利性。例如，Python的垃圾回收机制（主要是引用计数）可以不区分类型地应用于任何对象，因为它们都有一个统一的ob_refcnt。同样，当你需要知道一个变量的类型时，你只需要检查它的ob_type指针即可。

举个例子，一个Python的整数1，在C层面是一个PyLongObject，但它以PyObject_HEAD宏开头，这实际上就是嵌入了PyObject的基本结构。

// 简化后的PyLongObject结构
typedef struct {
    PyObject_HEAD // 包含了 ob_refcnt 和 ob_type
    digit ob_digit[1]; // 存储整数值
} PyLongObject;

字符串、列表、字典等也都有各自的C结构体（如PyUnicodeObject、PyListObject、PyDictObject），但它们无一例外地都以PyObject_HEAD开始。这种设计使得C语言代码可以编写通用的函数来操作任何Python对象，因为它们都可以被强制转换为PyObject*并访问其通用头部信息。这无疑大大简化了CPython内部的实现复杂性，也为Python的动态性和灵活性奠定了坚实的基础。

类与元类在CPython源码中是如何协作构建对象模型的？

类与元类在CPython源码中扮演着“构造者”与“构造者的构造者”的角色，它们通过PyTypeObject的层层嵌套和协作，构建起Python的整个对象模型。

首先，我们知道每个Python类（比如list、dict，或者我们自定义的MyClass）在C层面都是一个PyTypeObject的实例。这个PyTypeObject的ob_type字段指向了定义其行为的“类型”——也就是它的元类。对于大多数我们直接定义的类，它们的元类都是内置的type。在CPython源码中，这个type对应的就是全局唯一的PyType_Type这个PyTypeObject实例。

所以，当你在Python中写下：

class MyClass(object):
    pass

解释器在执行这行代码时，实际上会调用PyType_Type（也就是type元类）的tp_new和tp_init方法来“创建”MyClass这个类对象。这个创建过程会：

1. 分配一块内存，用于存储代表MyClass的PyTypeObject。
2. 将这个新的PyTypeObject实例的ob_type字段设置为指向PyType_Type（因为MyClass是type的实例）。
3. 根据MyClass的定义（基类、方法、属性等），填充这个PyTypeObject的各种字段，例如tp_name、tp_base、tp_bases、tp_dict等。

tp_dict尤其重要，它是一个PyDictObject*，存储了类中定义的所有方法（如my_method）和类属性（如class_var）。当你在Python代码中访问MyClass.my_method时，CPython就会去查找MyClass这个PyTypeObject的tp_dict。

元类（PyType_Type或其他自定义元类）的强大之处在于，它可以在类创建的整个生命周期中介入。例如，如果你自定义一个元类MyMeta，并让MyClass通过metaclass=MyMeta来指定它，那么在创建MyClass时，CPython会调用MyMeta的tp_new和tp_init。这使得元类可以修改类的行为、注入方法、检查属性等等，提供了极其灵活的元编程能力。可以说，PyTypeObject是Python对象模型的骨架，而元类则是这骨架的设计者和建造者。这种协作方式，使得Python的类型系统既统一又高度可扩展。

源码层面的继承与多态是如何实现的？

Python源码层面的继承与多态，是其面向对象设计精髓的体现，它们都围绕着PyTypeObject中的特定字段和运行时查找机制展开。

继承的实现：

在CPython中，继承关系主要通过PyTypeObject中的tp_base和tp_bases字段来维护：

• tp_base：指向当前类型的直接基类（单继承）。
• tp_bases：一个元组，包含了所有直接基类（多继承）。

当一个子类被定义时，其PyTypeObject的tp_base和tp_bases会被相应地设置。但更关键的是，CPython在类准备就绪（PyType_Ready函数被调用）时，会计算并缓存一个非常重要的数据结构：方法解析顺序（MRO），并将其存储在PyTypeObject的tp_mro字段中。tp_mro是一个元组，里面包含了从当前类到object类，按照特定规则（C3线性化算法）排序的所有基类。

当你在Python中访问一个对象的属性或方法时，例如instance.attribute，CPython会：

1. 首先查找instance自身的__dict__（如果存在）。
2. 如果未找到，它会通过instance->ob_type获取到类的PyTypeObject。
3. 然后，CPython会沿着这个类的PyTypeObject的tp_mro列表，依次遍历每个基类的tp_dict，直到找到匹配的属性或方法。第一个找到的就会被使用。

这种基于MRO的查找机制，确保了多重继承时的行为是可预测和一致的。

多态的实现：

多态在CPython中得以实现，主要得益于“一切皆对象”的统一PyObject基石和运行时动态查找的特性：

1. 统一的接口：由于所有Python对象在C层面都是PyObject*，任何C函数或Python函数，只要它期望一个PyObject*作为参数，就可以接受任何类型的Python对象。例如，Python的内置函数len()，它在C层面对应的函数会接收一个PyObject*。
2. 运行时动态分派：当调用len(obj)时，CPython会检查obj的ob_type指针，找到对应的PyTypeObject。然后，它会根据这个PyTypeObject中定义的协议（比如tp_as_sequence或tp_as_mapping），查找并调用正确的C函数（例如sq_length或mp_length）。不同的对象类型，即使调用同一个Python函数名，底层执行的C函数也可能完全不同，这就是多态的体现。
3. 鸭子类型（Duck Typing）：Python的多态是典型的鸭子类型。它不关心对象的实际类型是什么，只关心它是否“像鸭子一样走路，像鸭子一样嘎嘎叫”——即是否提供了所需的方法或属性。在源码层面，这意味着只要对象的PyTypeObject中定义了相应的方法指针（例如，如果它有tp_call，它就是可调用的；如果它有tp_iter，它就是可迭代的），那么它就可以参与到相应的操作中。

这种设计使得Python代码高度灵活，你可以轻松地替换不同类型的对象，只要它们提供了相同的接口，代码就能正常运行，而无需进行显式的类型转换或接口声明，这正是Python面向对象设计的魅力所在。

文中关于继承,多态,元类,PyObject,PyTypeObject的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Python类与对象关系详解》文章吧，也可关注golang学习网公众号了解相关技术文章。