Python类与对象关系详解
时间:2025-07-29 15:27:48 476浏览 收藏
本文深入解析了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会:- 调用
MyClass
这个PyTypeObject
的tp_new
(通常是PyType_GenericNew
)来分配内存。这会创建一个新的PyObject
实例。 - 新创建的
PyObject
实例的ob_type
指针会被设置为指向MyClass
的PyTypeObject
。 - 最后,如果定义了
__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
这个类对象。这个创建过程会:
- 分配一块内存,用于存储代表
MyClass
的PyTypeObject
。 - 将这个新的
PyTypeObject
实例的ob_type
字段设置为指向PyType_Type
(因为MyClass
是type
的实例)。 - 根据
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会:
- 首先查找
instance
自身的__dict__
(如果存在)。 - 如果未找到,它会通过
instance->ob_type
获取到类的PyTypeObject
。 - 然后,CPython会沿着这个类的
PyTypeObject
的tp_mro
列表,依次遍历每个基类的tp_dict
,直到找到匹配的属性或方法。第一个找到的就会被使用。
这种基于MRO的查找机制,确保了多重继承时的行为是可预测和一致的。
多态的实现:
多态在CPython中得以实现,主要得益于“一切皆对象”的统一PyObject
基石和运行时动态查找的特性:
- 统一的接口:由于所有Python对象在C层面都是
PyObject*
,任何C函数或Python函数,只要它期望一个PyObject*
作为参数,就可以接受任何类型的Python对象。例如,Python的内置函数len()
,它在C层面对应的函数会接收一个PyObject*
。 - 运行时动态分派:当调用
len(obj)
时,CPython会检查obj
的ob_type
指针,找到对应的PyTypeObject
。然后,它会根据这个PyTypeObject
中定义的协议(比如tp_as_sequence
或tp_as_mapping
),查找并调用正确的C函数(例如sq_length
或mp_length
)。不同的对象类型,即使调用同一个Python函数名,底层执行的C函数也可能完全不同,这就是多态的体现。 - 鸭子类型(Duck Typing):Python的多态是典型的鸭子类型。它不关心对象的实际类型是什么,只关心它是否“像鸭子一样走路,像鸭子一样嘎嘎叫”——即是否提供了所需的方法或属性。在源码层面,这意味着只要对象的
PyTypeObject
中定义了相应的方法指针(例如,如果它有tp_call
,它就是可调用的;如果它有tp_iter
,它就是可迭代的),那么它就可以参与到相应的操作中。
这种设计使得Python代码高度灵活,你可以轻松地替换不同类型的对象,只要它们提供了相同的接口,代码就能正常运行,而无需进行显式的类型转换或接口声明,这正是Python面向对象设计的魅力所在。
文中关于继承,多态,元类,PyObject,PyTypeObject的知识介绍,希望对你的学习有所帮助!若是受益匪浅,那就动动鼠标收藏这篇《Python类与对象关系详解》文章吧,也可关注golang学习网公众号了解相关技术文章。
-
501 收藏
-
501 收藏
-
501 收藏
-
501 收藏
-
501 收藏
-
323 收藏
-
397 收藏
-
483 收藏
-
463 收藏
-
331 收藏
-
475 收藏
-
240 收藏
-
169 收藏
-
222 收藏
-
340 收藏
-
144 收藏
-
377 收藏
-
- 前端进阶之JavaScript设计模式
- 设计模式是开发人员在软件开发过程中面临一般问题时的解决方案,代表了最佳的实践。本课程的主打内容包括JS常见设计模式以及具体应用场景,打造一站式知识长龙服务,适合有JS基础的同学学习。
- 立即学习 542次学习
-
- GO语言核心编程课程
- 本课程采用真实案例,全面具体可落地,从理论到实践,一步一步将GO核心编程技术、编程思想、底层实现融会贯通,使学习者贴近时代脉搏,做IT互联网时代的弄潮儿。
- 立即学习 511次学习
-
- 简单聊聊mysql8与网络通信
- 如有问题加微信:Le-studyg;在课程中,我们将首先介绍MySQL8的新特性,包括性能优化、安全增强、新数据类型等,帮助学生快速熟悉MySQL8的最新功能。接着,我们将深入解析MySQL的网络通信机制,包括协议、连接管理、数据传输等,让
- 立即学习 498次学习
-
- JavaScript正则表达式基础与实战
- 在任何一门编程语言中,正则表达式,都是一项重要的知识,它提供了高效的字符串匹配与捕获机制,可以极大的简化程序设计。
- 立即学习 487次学习
-
- 从零制作响应式网站—Grid布局
- 本系列教程将展示从零制作一个假想的网络科技公司官网,分为导航,轮播,关于我们,成功案例,服务流程,团队介绍,数据部分,公司动态,底部信息等内容区块。网站整体采用CSSGrid布局,支持响应式,有流畅过渡和展现动画。
- 立即学习 484次学习