Python万物皆对象源码分析

引言

Python 是一种面向对象的编程语言，其核心思想是“万物皆对象”。这意味着在 Python 中，所有的数据类型、函数、模块、类等都是对象。本文将通过分析 Python 的源码，深入探讨“万物皆对象”这一概念的具体实现。

Python 对象模型

对象的定义

在 Python 中，所有的对象都是 PyObject 类型的实例。PyObject 是 Python 对象模型的基础，定义在 Include/object.h 文件中：

typedef struct _object {
    PyObject_HEAD
} PyObject;

PyObject_HEAD 是一个宏，定义了每个对象都必须包含的头部信息：

#define PyObject_HEAD \
    _PyObject_HEAD_EXTRA \
    Py_ssize_t ob_refcnt; \
    struct _typeobject *ob_type;

• ob_refcnt：引用计数，用于管理对象的内存。
• ob_type：指向对象的类型对象，类型对象本身也是一个 PyObject。

类型对象

类型对象是描述对象类型的对象，定义在 Include/object.h 中：

typedef struct _typeobject {
    PyObject_VAR_HEAD
    const char *tp_name; /* For printing, in format "<module>.<name>" */
    Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
    /* Methods to implement standard operations */
    destructor tp_dealloc;
    printfunc tp_print;
    getattrfunc tp_getattr;
    setattrfunc tp_setattr;
    PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2) or tp_reserved (Python 3) */
    reprfunc tp_repr;
    /* Method suites for standard classes */
    PyNumberMethods *tp_as_number;
    PySequenceMethods *tp_as_sequence;
    PyMappingMethods *tp_as_mapping;
    /* More standard operations (here for binary compatibility) */
    hashfunc tp_hash;
    ternaryfunc tp_call;
    reprfunc tp_str;
    getattrofunc tp_getattro;
    setattrofunc tp_setattro;
    /* Functions to access object as input/output buffer */
    PyBufferProcs *tp_as_buffer;
    /* Flags to define presence of optional/expanded features */
    unsigned long tp_flags;
    const char *tp_doc; /* Documentation string */
    /* Assigned meaning in release 2.0 */
    /* call function for all accessible objects */
    traverseproc tp_traverse;
    /* delete references to contained objects */
    inquiry tp_clear;
    /* Assigned meaning in release 2.1 */
    /* rich comparisons */
    richcmpfunc tp_richcompare;
    /* weak reference enabler */
    Py_ssize_t tp_weaklistoffset;
    /* Iterators */
    getiterfunc tp_iter;
    iternextfunc tp_iternext;
    /* Attribute descriptor and subclassing stuff */
    struct PyMethodDef *tp_methods;
    struct PyMemberDef *tp_members;
    struct PyGetSetDef *tp_getset;
    struct _typeobject *tp_base;
    PyObject *tp_dict;
    descrgetfunc tp_descr_get;
    descrsetfunc tp_descr_set;
    Py_ssize_t tp_dictoffset;
    initproc tp_init;
    allocfunc tp_alloc;
    newfunc tp_new;
    freefunc tp_free; /* Low-level free-memory routine */
    inquiry tp_is_gc; /* For PyObject_IS_GC */
    PyObject *tp_bases;
    PyObject *tp_mro; /* method resolution order */
    PyObject *tp_cache;
    PyObject *tp_subclasses;
    PyObject *tp_weaklist;
    destructor tp_del;
    /* Type attribute cache version tag. Added in version 2.6 */
    unsigned int tp_version_tag;
    destructor tp_finalize;
} PyTypeObject;

类型对象包含了对象的各种操作方法和属性，例如对象的创建、销毁、比较、哈希等。

对象的创建与销毁

对象的创建

在 Python 中，对象的创建通常通过调用类型对象的 tp_new 和 tp_init 方法来完成。例如，创建一个整数对象：

a = 42

在底层，Python 会调用 PyLong_FromLong 函数来创建一个整数对象：

PyObject *PyLong_FromLong(long ival) {
    PyLongObject *v;
    /* ... */
    v = _PyLong_New(1);
    if (v != NULL) {
        v->ob_digit[0] = (digit)abs(ival);
        /* ... */
    }
    return (PyObject *)v;
}

对象的销毁

对象的销毁通过引用计数机制来管理。当对象的引用计数降为 0 时，Python 会自动调用对象的 tp_dealloc 方法来释放对象的内存。例如，整数对象的 tp_dealloc 方法定义如下：

static void int_dealloc(PyObject *v) {
    Py_TYPE(v)->tp_free(v);
}

对象的引用计数

Python 使用引用计数来管理对象的内存。每个对象都有一个 ob_refcnt 字段，用于记录当前有多少个引用指向该对象。当引用计数降为 0 时，对象会被销毁。

引用计数的操作通过 Py_INCREF 和 Py_DECREF 宏来实现：

#define Py_INCREF(op) (                         \
    _Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA       \
    ((PyObject *)(op))->ob_refcnt++)

#define Py_DECREF(op)                                   \
    do {                                                \
        if (_Py_DEC_REFTOTAL  _Py_REF_DEBUG_COMMA       \
        --((PyObject *)(op))->ob_refcnt != 0)           \
            _Py_CHECK_REFCNT(op)                        \
        else                                            \
            _Py_Dealloc((PyObject *)(op));              \
    } while (0)

对象的类型与继承

在 Python 中，类型对象本身也是对象，因此类型对象也有自己的类型。所有类型对象的类型都是 PyType_Type，定义在 Objects/typeobject.c 中：

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

类型对象之间可以通过继承关系形成类型层次结构。例如，整数类型 PyLong_Type 继承自 PyType_Type：

PyTypeObject PyLong_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "int",                                      /* tp_name */
    sizeof(PyLongObject),                       /* tp_basicsize */
    0,                                          /* tp_itemsize */
    (destructor)int_dealloc,                    /* tp_dealloc */
    /* ... */
};

结论

通过分析 Python 的源码，我们可以看到“万物皆对象”这一概念在 Python 中的具体实现。所有的对象都是 PyObject 类型的实例，类型对象本身也是对象，并且通过引用计数机制来管理对象的内存。理解这些底层机制有助于我们更好地掌握 Python 的面向对象编程思想。

参考资料

• Python 源码：https://github.com/python/cpython
• Python 官方文档：https://docs.python.org/3/c-api/index.html