内存管理

概述

Python 中的内存管理涉及一个私有堆，其中包含所有 Python 对象和数据结构。这个私有堆的管理由Python 内存管理器在内部确保。Python 内存管理器有不同的组件，处理各种动态存储管理方面，如共享、分段、预分配或缓存。

在最低级别，原始内存分配器通过与操作系统的内存管理器交互，确保私有堆中有足够的空间来存储所有与 Python 相关的数据。在原始内存分配器的基础上，几个特定于对象的分配器在同一个堆上操作，并实现不同的内存管理策略，以适应每种对象类型的特性。例如，整数对象在堆中的管理方式与字符串、元组或字典不同，因为整数意味着不同的存储需求和速度/空间权衡。因此，Python 内存管理器将一些工作委托给特定于对象的分配器，但确保后者在私有堆的范围内操作。

重要的是要理解，Python 堆的管理是由解释器本身执行的，用户无法控制它，即使他们经常操作指向堆内内存块的对象指针。Python 对象的堆空间以及其他内部缓冲区的分配由 Python 内存管理器通过本文档中列出的 Python/C API 函数按需执行。

为了避免内存损坏，扩展编写者绝不应尝试使用 C 库导出的函数操作 Python 对象：malloc()、calloc()、realloc() 和 free()。这将导致 C 分配器和 Python 内存管理器之间的混合调用，并产生致命的后果，因为它们实现了不同的算法并在不同的堆上操作。但是，可以安全地使用 C 库分配器为个别目的分配和释放内存块，如下例所示

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

在此示例中，I/O 缓冲区的内存请求由 C 库分配器处理。Python 内存管理器仅参与分配作为结果返回的字节对象。

然而，在大多数情况下，建议专门从 Python 堆分配内存，因为后者受 Python 内存管理器的控制。例如，当用 C 编写的新对象类型扩展解释器时，这是必需的。使用 Python 堆的另一个原因是希望告知Python 内存管理器扩展模块的内存需求。即使请求的内存仅用于内部、高度特定的目的，将所有内存请求委托给 Python 内存管理器也会使解释器更准确地了解其整体内存占用情况。因此，在某些情况下，Python 内存管理器可能会或可能不会触发适当的操作，如垃圾回收、内存压缩或其他预防性程序。请注意，通过使用上例中所示的 C 库分配器，I/O 缓冲区分配的内存完全逃脱了 Python 内存管理器。

另请参阅

PYTHONMALLOC 环境变量可用于配置 Python 使用的内存分配器。

PYTHONMALLOCSTATS 环境变量可用于在每次创建新的 pymalloc 对象竞技场以及关闭时打印 pymalloc 内存分配器的统计信息。

分配器域

所有分配函数都属于三个不同的“域”之一（另请参见 PyMemAllocatorDomain）。这些域代表不同的分配策略，并针对不同的目的进行优化。关于每个域如何分配内存或每个域调用哪些内部函数的具体细节被认为是实现细节，但出于调试目的，可以在此处找到一个简化的表格。用于分配和释放内存块的 API 必须来自同一域。例如，PyMem_Free() 必须用于释放使用 PyMem_Malloc() 分配的内存。

三个分配域是

• 原始域：用于为通用内存缓冲区分配内存，其中分配必须转到系统分配器，或者分配器可以在没有 GIL 的情况下操作。内存直接从系统请求。请参阅 原始内存接口。

• “Mem”域：用于为 Python 缓冲区和通用内存缓冲区分配内存，其中必须在持有 GIL 的情况下执行分配。内存取自 Python 私有堆。请参阅 内存接口。

• 对象域：用于为 Python 对象分配内存。内存取自 Python 私有堆。请参阅 对象分配器。

注意

自由线程 构建要求仅使用“对象”域分配 Python 对象，并且所有 Python 对象都使用该域分配。这与以前的 Python 版本不同，在以前的 Python 版本中，这只是一种最佳实践，而不是硬性要求。

例如，应使用 PyMem_Malloc()、PyMem_RawMalloc() 或 malloc() 分配缓冲区（非 Python 对象），但不应使用 PyObject_Malloc() 分配。

请参阅 内存分配 API。

原始内存接口

以下函数集是系统分配器的包装器。这些函数是线程安全的，不需要持有 GIL。

默认原始内存分配器使用以下函数：malloc()、calloc()、realloc() 和 free()；请求零字节时调用 malloc(1) (或 calloc(1, 1))。

在 3.4 版本中添加。

void *PyMem_RawMalloc(size_t n)

自 3.13 版本以来，是 稳定 ABI 的一部分。

分配 n 个字节，并返回指向已分配内存的 void* 类型的指针，如果请求失败，则返回 NULL。

如果可能，请求零字节将返回一个不同的非 NULL 指针，就像改为调用了 PyMem_RawMalloc(1) 一样。内存将不会以任何方式初始化。

void *PyMem_RawCalloc(size_t nelem, size_t elsize)

自 3.13 版本以来，是 稳定 ABI 的一部分。

分配 nelem 个元素，每个元素的大小为 elsize 字节，并返回一个类型为 void* 的指针，指向已分配的内存。如果请求失败，则返回 NULL。该内存会被初始化为零。

如果请求零个元素或大小为零字节的元素，如果可能，将返回一个不同的非 NULL 指针，就像调用了 PyMem_RawCalloc(1, 1) 一样。

在 3.5 版本中新增。

void *PyMem_RawRealloc(void *p, size_t n)

自 3.13 版本以来，是 稳定 ABI 的一部分。

将 p 指向的内存块调整大小为 n 字节。内容将保持不变，直至旧大小和新大小的最小值。

如果 p 为 NULL，则该调用等同于 PyMem_RawMalloc(n)；否则，如果 n 等于零，则内存块将调整大小，但不会被释放，并且返回的指针为非 NULL。

除非 p 为 NULL，否则它必须是由先前调用 PyMem_RawMalloc()、PyMem_RawRealloc() 或 PyMem_RawCalloc() 返回的。

如果请求失败，PyMem_RawRealloc() 将返回 NULL，并且 p 仍然是指向前一个内存区域的有效指针。

void PyMem_RawFree(void *p)

自 3.13 版本以来，是 稳定 ABI 的一部分。

释放 p 指向的内存块，该内存块必须是由先前调用 PyMem_RawMalloc()、PyMem_RawRealloc() 或 PyMem_RawCalloc() 返回的。否则，或者如果之前已调用过 PyMem_RawFree(p)，则会发生未定义的行为。

如果 p 为 NULL，则不执行任何操作。

内存接口

以下函数集仿照 ANSI C 标准，但指定了请求零字节时的行为，可用于从 Python 堆分配和释放内存。

默认内存分配器 使用 pymalloc 内存分配器。

警告

使用这些函数时，必须持有 GIL。

在 3.6 版本中更改: 默认分配器现在是 pymalloc 而不是系统 malloc()。

void *PyMem_Malloc(size_t n)

属于 稳定 ABI 的一部分。

分配 n 个字节，并返回指向已分配内存的 void* 类型的指针，如果请求失败，则返回 NULL。

如果可能，请求零字节将返回一个不同的非 NULL 指针，就像调用了 PyMem_Malloc(1) 一样。该内存将不会以任何方式初始化。

void *PyMem_Calloc(size_t nelem, size_t elsize)

自 3.7 版本以来，属于 稳定 ABI 的一部分。

分配 nelem 个元素，每个元素的大小为 elsize 字节，并返回一个类型为 void* 的指针，指向已分配的内存。如果请求失败，则返回 NULL。该内存会被初始化为零。

如果可能，请求零个元素或大小为零字节的元素将返回一个不同的非 NULL 指针，就像调用了 PyMem_Calloc(1, 1) 一样。

在 3.5 版本中新增。

void *PyMem_Realloc(void *p, size_t n)

属于 稳定 ABI 的一部分。

将 p 指向的内存块调整大小为 n 字节。内容将保持不变，直至旧大小和新大小的最小值。

如果 p 为 NULL，则该调用等同于 PyMem_Malloc(n)；否则，如果 n 等于零，则内存块将调整大小，但不会被释放，并且返回的指针为非 NULL。

除非 p 为 NULL，否则它必须是由先前调用 PyMem_Malloc()、PyMem_Realloc() 或 PyMem_Calloc() 返回的。

如果请求失败，PyMem_Realloc() 将返回 NULL，并且 p 仍然是指向前一个内存区域的有效指针。

void PyMem_Free(void *p)

属于 稳定 ABI 的一部分。

释放 p 指向的内存块，该内存块必须是由先前调用 PyMem_Malloc()、PyMem_Realloc() 或 PyMem_Calloc() 返回的。否则，或者如果之前已调用过 PyMem_Free(p)，则会发生未定义的行为。

如果 p 为 NULL，则不执行任何操作。

为了方便起见，提供了以下面向类型的宏。请注意，TYPE 指的是任何 C 类型。

PyMem_New(TYPE, n)

与 PyMem_Malloc() 相同，但分配 (n * sizeof(TYPE)) 字节的内存。返回一个强制转换为 TYPE* 的指针。该内存将不会以任何方式初始化。

PyMem_Resize(p, TYPE, n)

与 PyMem_Realloc() 相同，但内存块会调整大小为 (n * sizeof(TYPE)) 字节。返回一个强制转换为 TYPE* 的指针。返回时，p 将是指向新内存区域的指针，如果失败，则为 NULL。

这是一个 C 预处理器宏；p 总是会被重新赋值。保存 p 的原始值，以避免在处理错误时丢失内存。

void PyMem_Del(void *p)

与 PyMem_Free() 相同。

此外，还提供以下宏定义，用于直接调用 Python 内存分配器，而无需涉及上面列出的 C API 函数。但是，请注意，它们的使用不能保证跨 Python 版本的二进制兼容性，因此在扩展模块中不推荐使用。

• PyMem_MALLOC(size)

• PyMem_NEW(type, size)

• PyMem_REALLOC(ptr, size)

• PyMem_RESIZE(ptr, type, size)

• PyMem_FREE(ptr)

• PyMem_DEL(ptr)

对象分配器

以下函数集仿照 ANSI C 标准，但指定了请求零字节时的行为，可用于从 Python 堆分配和释放内存。

注意

不能保证当通过 自定义内存分配器 部分中描述的方法拦截此域中的分配函数时，这些分配器返回的内存可以成功转换为 Python 对象。

默认对象分配器使用 pymalloc 内存分配器。

警告

使用这些函数时，必须持有 GIL。

void *PyObject_Malloc(size_t n)

属于 稳定 ABI 的一部分。

分配 n 个字节，并返回指向已分配内存的 void* 类型的指针，如果请求失败，则返回 NULL。

如果可能，请求零字节会返回一个不同的非 NULL 指针，就像调用了 PyObject_Malloc(1) 一样。内存将不会以任何方式初始化。

void *PyObject_Calloc(size_t nelem, size_t elsize)

自 3.7 版本以来，属于 稳定 ABI 的一部分。

分配 nelem 个元素，每个元素的大小为 elsize 字节，并返回一个类型为 void* 的指针，指向已分配的内存。如果请求失败，则返回 NULL。该内存会被初始化为零。

如果可能，请求零个元素或零字节大小的元素会返回一个不同的非 NULL 指针，就像调用了 PyObject_Calloc(1, 1) 一样。

在 3.5 版本中新增。

void *PyObject_Realloc(void *p, size_t n)

属于 稳定 ABI 的一部分。

将 p 指向的内存块调整大小为 n 字节。内容将保持不变，直至旧大小和新大小的最小值。

如果 p 为 NULL，则调用等效于 PyObject_Malloc(n)；否则，如果 n 等于零，则内存块会被调整大小但不会释放，并且返回的指针是非 NULL 的。

除非 p 为 NULL，否则它必须是由先前调用 PyObject_Malloc()、PyObject_Realloc() 或 PyObject_Calloc() 返回的。

如果请求失败，PyObject_Realloc() 返回 NULL 并且 p 仍然是指向前一个内存区域的有效指针。

void PyObject_Free(void *p)

属于 稳定 ABI 的一部分。

释放 p 指向的内存块，该内存块必须是由先前调用 PyObject_Malloc()、PyObject_Realloc() 或 PyObject_Calloc() 返回的。否则，或者如果之前已调用 PyObject_Free(p)，则会发生未定义的行为。

如果 p 为 NULL，则不执行任何操作。

默认内存分配器

默认内存分配器

配置	名称	PyMem_RawMalloc	PyMem_Malloc	PyObject_Malloc
发布版本	"pymalloc"	malloc	pymalloc	pymalloc
调试版本	"pymalloc_debug"	malloc + 调试	pymalloc + 调试	pymalloc + 调试
发布版本，无 pymalloc	"malloc"	malloc	malloc	malloc
调试版本，无 pymalloc	"malloc_debug"	malloc + 调试	malloc + 调试	malloc + 调试

图例

• 名称：PYTHONMALLOC 环境变量的值。

• malloc：标准 C 库中的系统分配器，C 函数：malloc()、calloc()、realloc() 和 free()。

• pymalloc：pymalloc 内存分配器。

• mimalloc：mimalloc 内存分配器。如果 mimalloc 支持不可用，则将使用 pymalloc 分配器。

• “+ 调试”：使用 Python 内存分配器上的调试钩子。

• “调试版本”：以调试模式构建的 Python。

自定义内存分配器

在 3.4 版本中添加。

type PyMemAllocatorEx

用于描述内存块分配器的结构。该结构具有以下字段

字段	含义
void *ctx	作为第一个参数传递的用户上下文
void* malloc(void *ctx, size_t size)	分配内存块
void* calloc(void *ctx, size_t nelem, size_t elsize)	分配用零初始化的内存块
void* realloc(void *ctx, void *ptr, size_t new_size)	分配或调整内存块的大小
void free(void *ctx, void *ptr)	释放内存块

在 3.5 版本中变更：PyMemAllocator 结构已重命名为 PyMemAllocatorEx，并添加了一个新的 calloc 字段。

type PyMemAllocatorDomain

用于标识分配器域的枚举。域

PYMEM_DOMAIN_RAW

函数

• PyMem_RawMalloc()

• PyMem_RawRealloc()

• PyMem_RawCalloc()

• PyMem_RawFree()

PYMEM_DOMAIN_MEM

函数

• PyMem_Malloc(),

• PyMem_Realloc()

• PyMem_Calloc()

• PyMem_Free()

PYMEM_DOMAIN_OBJ

函数

• PyObject_Malloc()

• PyObject_Realloc()

• PyObject_Calloc()

• PyObject_Free()

void PyMem_GetAllocator(PyMemAllocatorDomain domain, PyMemAllocatorEx *allocator)

获取指定域的内存块分配器。

void PyMem_SetAllocator(PyMemAllocatorDomain domain, PyMemAllocatorEx *allocator)

设置指定域的内存块分配器。

新的分配器在请求零字节时必须返回一个不同的非 NULL 指针。

对于 PYMEM_DOMAIN_RAW 域，分配器必须是线程安全的：当调用分配器时，全局解释器锁（GIL） 不会被持有。

对于其余域，分配器也必须是线程安全的：分配器可能会在不共享 GIL 的不同解释器中被调用。

如果新的分配器不是钩子（不调用之前的分配器），则必须调用 PyMem_SetupDebugHooks() 函数，以在新分配器的基础上重新安装调试钩子。

另请参阅 PyPreConfig.allocator 和 使用 PyPreConfig 预初始化 Python。

警告

PyMem_SetAllocator() 具有以下约定

• 它可以在 Py_PreInitialize() 之后和 Py_InitializeFromConfig() 之前调用，以安装自定义内存分配器。除了域施加的限制（例如，Raw 域允许在不持有 GIL 的情况下调用分配器）之外，对安装的分配器没有任何限制。有关更多信息，请参见 关于分配器域的部分。

• 如果在 Python 完成初始化之后（在调用 Py_InitializeFromConfig() 之后）调用，则分配器 **必须** 包装现有的分配器。 **不支持** 将当前分配器替换为其他任意分配器。

在 3.12 版本中更改: 所有分配器必须是线程安全的。

void PyMem_SetupDebugHooks(void)

在 Python 内存分配器中设置调试钩子 以检测内存错误。

Python 内存分配器上的调试钩子

当 Python 以调试模式构建时，PyMem_SetupDebugHooks() 函数会在 Python 预初始化 时调用，以便在 Python 内存分配器上设置调试钩子，以检测内存错误。

可以使用 PYTHONMALLOC 环境变量在以发布模式编译的 Python 上安装调试钩子（例如：PYTHONMALLOC=debug）。

可以在调用 PyMem_SetAllocator() 之后使用 PyMem_SetupDebugHooks() 函数来设置调试钩子。

这些调试钩子会用特殊的、可识别的位模式填充动态分配的内存块。新分配的内存填充字节 0xCD (PYMEM_CLEANBYTE)，释放的内存填充字节 0xDD (PYMEM_DEADBYTE)。内存块周围环绕着用字节 0xFD (PYMEM_FORBIDDENBYTE) 填充的 “禁止字节”。这些字节的字符串不太可能是有效的地址、浮点数或 ASCII 字符串。

运行时检查

• 检测 API 违规。例如，检测是否在 PyMem_Malloc() 分配的内存块上调用了 PyObject_Free()。

• 检测在缓冲区开始之前的写入（缓冲区下溢）。

• 检测在缓冲区结束之后的写入（缓冲区溢出）。

• 检查当调用 PYMEM_DOMAIN_OBJ （例如： PyObject_Malloc()） 和 PYMEM_DOMAIN_MEM （例如： PyMem_Malloc()） 域的分配器函数时，是否持有 GIL。

发生错误时，调试钩子会使用 tracemalloc 模块来获取分配内存块的回溯。只有在 tracemalloc 正在跟踪 Python 内存分配，并且内存块被跟踪时才会显示回溯。

设 S = sizeof(size_t)。在请求的每个 N 字节块的每一端都会添加 2*S 字节。内存布局如下所示，其中 p 表示 malloc 或 realloc 类函数返回的地址（p[i:j] 表示从 *(p+i) (包含) 到 *(p+j) (不包含) 的字节切片；请注意，负索引的处理方式与 Python 切片不同）

p[-2*S:-S]

最初请求的字节数。这是一个 size_t，大端字节序（在内存转储中更容易读取）。

p[-S]

API 标识符（ASCII 字符）

• 'r' 用于 PYMEM_DOMAIN_RAW。

• 'm' 用于 PYMEM_DOMAIN_MEM。

• 'o' 用于 PYMEM_DOMAIN_OBJ。

p[-S+1:0]

PYMEM_FORBIDDENBYTE 的副本。用于捕获下写和下读。

p[0:N]

请求的内存，填充 PYMEM_CLEANBYTE 的副本，用于捕获对未初始化内存的引用。当调用 realloc 类函数请求更大的内存块时，新的多余字节也会填充 PYMEM_CLEANBYTE。当调用 free 类函数时，这些字节会被 PYMEM_DEADBYTE 覆盖，以捕获对已释放内存的引用。当调用 realloc 类函数请求较小的内存块时，多余的旧字节也会填充 PYMEM_DEADBYTE。

p[N:N+S]

PYMEM_FORBIDDENBYTE 的副本。用于捕获溢写和溢读。

p[N+S:N+2*S]

仅当定义了 PYMEM_DEBUG_SERIALNO 宏时才使用（默认情况下未定义）。

一个序列号，每次调用 malloc 或 realloc 类函数时加 1。大端字节序 size_t。如果稍后检测到“坏内存”，则序列号提供了一个极好的方法，可以在下次运行时设置断点，以捕获此块被传递出去的瞬间。obmalloc.c 中的静态函数 bumpserialno() 是唯一会递增序列号的地方，它的存在是为了方便您轻松设置此类断点。

realloc 或 free 类函数首先检查每一端的 PYMEM_FORBIDDENBYTE 字节是否完好无损。如果它们被更改，则会将诊断输出写入 stderr，并通过 Py_FatalError() 中止程序。另一个主要的故障模式是当程序读取其中一种特殊的位模式并尝试将其用作地址时，会引发内存错误。如果进入调试器并查看对象，您可能会看到它完全填充了 PYMEM_DEADBYTE（表示正在使用已释放的内存）或 PYMEM_CLEANBYTE（表示正在使用未初始化的内存）。

在 3.6 版本中更改: PyMem_SetupDebugHooks() 函数现在也适用于以发布模式编译的 Python。发生错误时，调试钩子现在使用 tracemalloc 来获取分配内存块的回溯。当调用 PYMEM_DOMAIN_OBJ 和 PYMEM_DOMAIN_MEM 域的函数时，调试钩子现在还会检查是否持有 GIL。

3.8 版本更改: 字节模式 0xCB (PYMEM_CLEANBYTE), 0xDB (PYMEM_DEADBYTE) 和 0xFB (PYMEM_FORBIDDENBYTE) 已被替换为 0xCD, 0xDD 和 0xFD，以使用与 Windows CRT 调试 malloc() 和 free() 相同的值。

pymalloc 分配器

Python 有一个 pymalloc 分配器，针对具有短生命周期的小对象（小于或等于 512 字节）进行了优化。它使用称为“arena”的内存映射，在 32 位平台上固定大小为 256 KiB，在 64 位平台上固定大小为 1 MiB。对于大于 512 字节的分配，它会回退到 PyMem_RawMalloc() 和 PyMem_RawRealloc()。

pymalloc 是 默认分配器，适用于 PYMEM_DOMAIN_MEM (例如：PyMem_Malloc()) 和 PYMEM_DOMAIN_OBJ (例如：PyObject_Malloc()) 域。

arena 分配器使用以下函数

• VirtualAlloc() 和 VirtualFree() (在 Windows 上),

• mmap() 和 munmap() (如果可用),

• malloc() 和 free() (否则)。

如果 Python 配置了 --without-pymalloc 选项，则禁用此分配器。它也可以在运行时使用 PYTHONMALLOC 环境变量禁用 (例如：PYTHONMALLOC=malloc)。

自定义 pymalloc Arena 分配器

在 3.4 版本中添加。

type PyObjectArenaAllocator

用于描述 arena 分配器的结构。该结构有三个字段

字段	含义
void *ctx	作为第一个参数传递的用户上下文
void* alloc(void *ctx, size_t size)	分配一个大小为 size 字节的 arena
void free(void *ctx, void *ptr, size_t size)	释放一个 arena

void PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator)

获取 arena 分配器。

void PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator)

设置 arena 分配器。

mimalloc 分配器

3.13 版本新增。

当底层平台支持可用时，Python 支持 mimalloc 分配器。mimalloc “是一个具有出色性能特征的通用分配器。最初由 Daan Leijen 为 Koka 和 Lean 语言的运行时系统开发。”

tracemalloc C API

3.7 版本新增。

int PyTraceMalloc_Track(unsigned int domain, uintptr_t ptr, size_t size)

在 tracemalloc 模块中跟踪已分配的内存块。

成功返回 0，错误（未能分配内存来存储跟踪）返回 -1。如果 tracemalloc 被禁用，则返回 -2。

如果内存块已被跟踪，则更新现有跟踪。

int PyTraceMalloc_Untrack(unsigned int domain, uintptr_t ptr)

在 tracemalloc 模块中取消跟踪已分配的内存块。如果该块未被跟踪，则不执行任何操作。

如果 tracemalloc 被禁用，则返回 -2，否则返回 0。

示例

这是 概述 部分中的示例，经过重写，以便 I/O 缓冲区通过使用第一个函数集从 Python 堆中分配

PyObject *res;
char *buf = (char *) PyMem_Malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Free(buf); /* allocated with PyMem_Malloc */
return res;

使用面向类型的函数集的相同代码

PyObject *res;
char *buf = PyMem_New(char, BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Del(buf); /* allocated with PyMem_New */
return res;

请注意，在上面的两个示例中，缓冲区始终通过属于同一集合的函数进行操作。实际上，对于给定的内存块，需要使用相同的内存 API 系列，以便将混合使用不同分配器的风险降至最低。以下代码序列包含两个错误，其中一个被标记为致命错误，因为它混合了在不同堆上运行的两个不同的分配器。

char *buf1 = PyMem_New(char, BUFSIZ);
char *buf2 = (char *) malloc(BUFSIZ);
char *buf3 = (char *) PyMem_Malloc(BUFSIZ);
...
PyMem_Del(buf3);  /* Wrong -- should be PyMem_Free() */
free(buf2);       /* Right -- allocated via malloc() */
free(buf1);       /* Fatal -- should be PyMem_Del()  */

除了用于处理 Python 堆中原始内存块的函数外，Python 中的对象还使用 PyObject_New, PyObject_NewVar 和 PyObject_Del() 进行分配和释放。

这些将在下一章关于在 C 中定义和实现新对象类型的内容中进行解释。