一切皆对象

约 1544 字大约 5 分钟

2025-10-20

表象展示

Python 是一门面向对象的程序设计语言，它的设计理念之一便是“一切皆对象”。

一个最简单的字符串就是一个str类的对象：

运行代码

a = 'abc'
print(type(a))  # <class 'str'>

我们可以对a进行upper()等操作，因为str类实现了这些方法：

运行代码

a = 'abc'
print(a.upper())  # ABC

事实上，Python 的基础数据类型全部是类：

运行代码

print(str, int, float, bool, list, dict)
# <class 'str'> <class 'int'> <class 'float'> <class 'bool'> <class 'list'> <class 'dict'>

甚至包括作为关键字的True也是bool类的对象：

运行代码

print(type(True))  # <class 'bool'>

就连函数也难逃一劫：

运行代码

def f():
    ...

print(type(f))  # <class 'function'>

看，到处都是class。

原理刨析

注意

此部分是非常抽象的 Python 内部机制分析，对新手极度不友好。如果你有兴趣，可以作为拓展内容阅读；你也完全可以跳过此部分。

先看看下面朴而不素的代码：

运行代码

class F:
    ...

class A(F):
    ...

class B(F, object):
    ...

a = A()

print(F.__bases__)  # (<class 'object'>,)
print(A.__bases__)  # (<class '__main__.F'>,)
print(B.__bases__)  # (<class '__main__.F'>, <class 'object'>)
print(object.__bases__)  # ()
print(type(a))  # <class '__main__.A'>
print(type(A))  # <class 'type'>
print(type(object))  # <class 'type'>
print(type.__bases__)  # (<class 'object'>,)

通过上面的很简单的代码，运用一眼洞穿法，我们可以根据每个打印语句的结果得到一些简单的观察结论：

如果定义一个类时没有指定继承哪个类，则默认继承 object 类
object 类的父类为空，说明 object 类位于继承关系链的顶端， object 类是 Python 中所有类的父类，可以说 object 是 Python 中的顶端类
对象 a 由类 A 实例化而来，a 的类型为 A，这个比较容易理解
根据 3 的观察结果，同样的观察手法运用在类 A 上，观察到类 A 是由 type 这个类实例化而来，类 A 的类型为 type，说明类 A 是一个类的同时也是一个对象（类 A 是类 type 的实例化对象）。这里可能有点晕但是请先接着看下去吧
根据 3 的观察结果，同样的观察手法运用在顶端类 object 上，观察到 object 这个顶端类也是由 type 这个类实例化而来，类 object 的类型也为 type，也说明 object 作为一个类的同时也是一个对象
类 type 作为实例化类 A 和类 object 的类，其父类为 object

看完上面的这些观察结论，相信有一部分童鞋已经两眼发懵了，什么类 A 是一个类也是一个对象，object 类的类型是 type，而 type 类的父类又是 object……

这里先来一张图简单表示一下这几者的关系，舒缓一下情绪：

蓝色箭头由实例对象指向实例化它的类，红色箭头由子类指向父类。

值得注意的是，这个图有几个关键的地方：

类（如 class A, class object）都是由 type 这个类实例化而来的，即所有类（class）对象的类型都是 type
type 这个类也是由 type 自己实例化而来的（图中 type 处指向自身的部分），即 type 类的类型也为 type
type 类的父类是 object 类

有了以上的铺垫，我们可以知道一个最普通的实例对象链是这样子的：

type --实例化--> object --衍生(继承)--> class A (类) --实例化--> a(具体对象)

这部分都是比较好理解的，但关键的问题是——object 类作为 type 类的父类，怎么会是由 type 类实例化出来的？还有 type 类居然是由 type 自己实例化出来的？这都是什么操作？

我们可以看看在源码中，type 类和 object 类分别是什么（Python 的底层是 C 的实现，下面的源码如果看不懂的话请别在意，因为不妨碍理解）：

在源码中，type 类的定义如下：

#define PyVarObject_HEAD_INIT(type, size)
    1, type, size,

PyTypeObject PyType_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "type",                                     /* tp_name */
    sizeof(PyHeapTypeObject),                   /* tp_basicsize */
    sizeof(PyMemberDef),                        /* tp_itemsize */
    0,                                          /* tp_base */
    ...
}

object 类的定义如下：

PyTypeObject PyBaseObject_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "object",                                   /* tp_name */
    sizeof(PyObject),                           /* tp_basicsize */
    0,                                          /* tp_itemsize */
    0,                                          /* tp_base */
    ...
}

这两个类结构体中的各项的具体含义这里不做深究，因为不在本文研究范围内。我们只需要关注这两个结构中的第一行： PyVarObject_HEAD_INIT(&PyType_Type, 0)。它表示这个类结构的对象类型。能看出来 object 类和 type 类的对象类型都是 &PyType_Type，而 PyType_Type 正是底层表示 type 类的结构体！

这两个结构体就说明了：object 类将类型(即谁实例化了这个类)设置成了 type 类，type 类将类型设置成了自己！这其实是 Python 底层实现的一个小小的 trick ~

然后在 type 类的初始化过程中，执行了如下代码：