# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Rafael Fontenelle <[email protected]>, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-07-25 16:03+0000\n"

"PO-Revision-Date: 2025-07-18 19:57+0000\n"

"Last-Translator: Rafael Fontenelle <[email protected]>, 2025\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../c-api/memory.rst:8

msgid "Memory Management"

msgstr "内存管理"

#: ../../c-api/memory.rst:17

msgid "Overview"

msgstr "概述"

#: ../../c-api/memory.rst:19

msgid ""

"Memory management in Python involves a private heap containing all Python "

"objects and data structures. The management of this private heap is ensured "

"internally by the *Python memory manager*. The Python memory manager has "

"different components which deal with various dynamic storage management "

"aspects, like sharing, segmentation, preallocation or caching."

msgstr ""

"在 Python 中，内存管理涉及到一个包含所有 Python 对象和数据结构的私有堆（heap）。这个私有堆的管理由内部的 *Python "

"内存管理器（Python memory manager）* 保证。Python "

"内存管理器有不同的组件来处理各种动态存储管理方面的问题，如共享、分割、预分配或缓存。"

#: ../../c-api/memory.rst:25

msgid ""

"At the lowest level, a raw memory allocator ensures that there is enough "

"room in the private heap for storing all Python-related data by interacting "

"with the memory manager of the operating system. On top of the raw memory "

"allocator, several object-specific allocators operate on the same heap and "

"implement distinct memory management policies adapted to the peculiarities "

"of every object type. For example, integer objects are managed differently "

"within the heap than strings, tuples or dictionaries because integers imply "

"different storage requirements and speed/space tradeoffs. The Python memory "

"manager thus delegates some of the work to the object-specific allocators, "

"but ensures that the latter operate within the bounds of the private heap."

msgstr ""

"在最底层，一个原始内存分配器通过与操作系统的内存管理器交互，确保私有堆中有足够的空间来存储所有与 Python "

"相关的数据。在原始内存分配器的基础上，几个对象特定的分配器在同一堆上运行，并根据每种对象类型的特点实现不同的内存管理策略。例如，整数对象在堆内的管理方式不同于字符串、元组或字典，因为整数需要不同的存储需求和速度与空间的权衡。因此，Python"

" 内存管理器将一些工作分配给对象特定分配器，但确保后者在私有堆的范围内运行。"

#: ../../c-api/memory.rst:36

msgid ""

"It is important to understand that the management of the Python heap is "

"performed by the interpreter itself and that the user has no control over "

"it, even if they regularly manipulate object pointers to memory blocks "

"inside that heap. The allocation of heap space for Python objects and other"

" internal buffers is performed on demand by the Python memory manager "

"through the Python/C API functions listed in this document."

msgstr ""

"Python 堆内存的管理是由解释器来执行，用户对它没有控制权，即使他们经常操作指向堆内内存块的对象指针，理解这一点十分重要。Python "

"对象和其他内部缓冲区的堆空间分配是由 Python 内存管理器按需通过本文档中列出的 Python/C API 函数进行的。"

#: ../../c-api/memory.rst:49

msgid ""

"To avoid memory corruption, extension writers should never try to operate on"

" Python objects with the functions exported by the C library: "

":c:func:`malloc`, :c:func:`calloc`, :c:func:`realloc` and :c:func:`free`. "

"This will result in mixed calls between the C allocator and the Python "

"memory manager with fatal consequences, because they implement different "

"algorithms and operate on different heaps. However, one may safely allocate"

" and release memory blocks with the C library allocator for individual "

"purposes, as shown in the following example::"

msgstr ""

"为了避免内存破坏，扩展的作者永远不应该试图用 C 库函数导出的函数来对 Python 对象进行操作，这些函数包括： :c:func:`malloc`, "

":c:func:`calloc`, :c:func:`realloc` 和 :c:func:`free`。这将导致 C 分配器和 Python "

"内存管理器之间的混用，引发严重后果，这是由于它们实现了不同的算法，并在不同的堆上操作。但是，我们可以安全地使用 C "

"库分配器为单独的目的分配和释放内存块，如下例所示："

#: ../../c-api/memory.rst:58

msgid ""

"PyObject *res;\n"

"char *buf = (char *) malloc(BUFSIZ); /* for I/O */\n"

"\n"

"if (buf == NULL)\n"

" return PyErr_NoMemory();\n"

"...Do some I/O operation involving buf...\n"

"res = PyBytes_FromString(buf);\n"

"free(buf); /* malloc'ed */\n"

"return res;"

msgstr ""

"PyObject *res;\n"

"char *buf = (char *) malloc(BUFSIZ); /* for I/O */\n"

"\n"

"if (buf == NULL)\n"

" return PyErr_NoMemory();\n"

"...执行一些涉及 buf 的 I/O 操作...\n"

"res = PyBytes_FromString(buf);\n"

"free(buf); /* 已分配的 */\n"

"return res;"

#: ../../c-api/memory.rst:68

msgid ""

"In this example, the memory request for the I/O buffer is handled by the C "

"library allocator. The Python memory manager is involved only in the "

"allocation of the bytes object returned as a result."

msgstr "在这个例子中，I/O 缓冲区的内存请求是由 C 库分配器处理的。Python 内存管理器只参与了分配作为结果返回的字节对象。"

#: ../../c-api/memory.rst:72

msgid ""

"In most situations, however, it is recommended to allocate memory from the "

"Python heap specifically because the latter is under control of the Python "

"memory manager. For example, this is required when the interpreter is "

"extended with new object types written in C. Another reason for using the "

"Python heap is the desire to *inform* the Python memory manager about the "

"memory needs of the extension module. Even when the requested memory is used"

" exclusively for internal, highly specific purposes, delegating all memory "

"requests to the Python memory manager causes the interpreter to have a more "

"accurate image of its memory footprint as a whole. Consequently, under "

"certain circumstances, the Python memory manager may or may not trigger "

"appropriate actions, like garbage collection, memory compaction or other "

"preventive procedures. Note that by using the C library allocator as shown "

"in the previous example, the allocated memory for the I/O buffer escapes "

"completely the Python memory manager."

msgstr ""

"然而，在大多数情况下，都建议专门基于 Python 堆来分配内存，因为后者是由 Python 内存管理器控制的。 例如，当解释器使用 C "

"编写的新对象类型进行扩展时就必须这样做。 使用 Python 堆的另一个理由是需要能 *通知* Python 内存管理器有关扩展模块的内存需求。 "

"即使所请求的内存全部只用于内部的、高度特定的目的，将所有的内存请求交给 Python 内存管理器能让解释器对其内存占用的整体情况有更准确的了解。 "

"因此，在特定情况下，Python 内存管理器可能会触发或不触发适当的操作，如垃圾回收、内存压缩或其他的预防性操作。 请注意通过使用前面例子所演示的 C "

"库分配器，为 I/O 缓冲区分配的内存将完全不受 Python 内存管理器的控制。"

#: ../../c-api/memory.rst:88

msgid ""

"The :envvar:`PYTHONMALLOC` environment variable can be used to configure the"

" memory allocators used by Python."

msgstr "环境变量 :envvar:`PYTHONMALLOC` 可被用来配置 Python 所使用的内存分配器。"

#: ../../c-api/memory.rst:91

msgid ""

"The :envvar:`PYTHONMALLOCSTATS` environment variable can be used to print "

"statistics of the :ref:`pymalloc memory allocator <pymalloc>` every time a "

"new pymalloc object arena is created, and on shutdown."

msgstr ""

"环境变量 :envvar:`PYTHONMALLOCSTATS` 可以用来在每次创建和关闭新的 pymalloc 对象区域时打印 "

":ref:`pymalloc 内存分配器 <pymalloc>` 的统计数据。"

#: ../../c-api/memory.rst:96

msgid "Allocator Domains"

msgstr "分配器域"

#: ../../c-api/memory.rst:100

msgid ""

"All allocating functions belong to one of three different \"domains\" (see "

"also :c:type:`PyMemAllocatorDomain`). These domains represent different "

"allocation strategies and are optimized for different purposes. The specific"

" details on how every domain allocates memory or what internal functions "

"each domain calls is considered an implementation detail, but for debugging "

"purposes a simplified table can be found at :ref:`here <default-memory-"

"allocators>`. There is no hard requirement to use the memory returned by the"

" allocation functions belonging to a given domain for only the purposes "

"hinted by that domain (although this is the recommended practice). For "

"example, one could use the memory returned by :c:func:`PyMem_RawMalloc` for "

"allocating Python objects or the memory returned by "

":c:func:`PyObject_Malloc` for allocating memory for buffers."

msgstr ""

"所有分配函数都属于三个不同的“分配器域”之一（见 "

":c:type:`PyMemAllocatorDomain`）。这些域代表了不同的分配策略，并为不同目的进行了优化。每个域如何分配内存和每个域调用哪些内部函数的具体细节被认为是实现细节，但是出于调试目的，可以在"

" :ref:`此处<default-memory-allocators>` "

"找到一张简化的表格。没有硬性要求将属于给定域的分配函数返回的内存，仅用于该域提示的目的（虽然这是推荐的做法）。例如，你可以将 "

":c:func:`PyMem_RawMalloc` 返回的内存用于分配 Python 对象，或者将 :c:func:`PyObject_Malloc` "

"返回的内存用作缓冲区。"

#: ../../c-api/memory.rst:112

msgid "The three allocation domains are:"

msgstr "三个分配域分别是："

#: ../../c-api/memory.rst:114

msgid ""

"Raw domain: intended for allocating memory for general-purpose memory "

"buffers where the allocation *must* go to the system allocator or where the "

"allocator can operate without the :term:`GIL`. The memory is requested "

"directly to the system."

msgstr ""

"原始域：用于为通用内存缓冲区分配内存，分配*必须*转到系统分配器并且分配器可以在没有 :term:`GIL` 的情况下运行。内存直接请求自系统。"

#: ../../c-api/memory.rst:119

msgid ""

"\"Mem\" domain: intended for allocating memory for Python buffers and "

"general-purpose memory buffers where the allocation must be performed with "

"the :term:`GIL` held. The memory is taken from the Python private heap."

msgstr ""

"\"Mem\" 域：用于为 Python 缓冲区和通用内存缓冲区分配内存，分配时必须持有 :term:`GIL`。内存取自于 Python 私有堆。"

#: ../../c-api/memory.rst:123

msgid ""

"Object domain: intended for allocating memory belonging to Python objects. "

"The memory is taken from the Python private heap."

msgstr "对象域：用于分配属于 Python 对象的内存。内存取自于 Python 私有堆。"

#: ../../c-api/memory.rst:126

msgid ""

"When freeing memory previously allocated by the allocating functions "

"belonging to a given domain,the matching specific deallocating functions "

"must be used. For example, :c:func:`PyMem_Free` must be used to free memory "

"allocated using :c:func:`PyMem_Malloc`."

msgstr ""

"当释放属于给定域的分配函数先前分配的内存时，必须使用对应的释放函数。例如，:c:func:`PyMem_Free` 来释放 "

":c:func:`PyMem_Malloc` 分配的内存。"

#: ../../c-api/memory.rst:131

msgid "Raw Memory Interface"

msgstr "原始内存接口"

#: ../../c-api/memory.rst:133

msgid ""

"The following function sets are wrappers to the system allocator. These "

"functions are thread-safe, the :term:`GIL <global interpreter lock>` does "

"not need to be held."

msgstr ""

"以下函数集封装了系统分配器。这些函数是线程安全的，不需要持有 :term:`全局解释器锁 <global interpreter lock>`。"

#: ../../c-api/memory.rst:137

msgid ""

"The :ref:`default raw memory allocator <default-memory-allocators>` uses the"

" following functions: :c:func:`malloc`, :c:func:`calloc`, :c:func:`realloc` "

"and :c:func:`!free`; call ``malloc(1)`` (or ``calloc(1, 1)``) when "

"requesting zero bytes."

msgstr ""

":ref:`默认原始内存分配器 <default-memory-allocators>` 使用以下函数: :c:func:`malloc`, "

":c:func:`calloc`, :c:func:`realloc` 和 :c:func:`!free`；当请求零个字节时则调用 "

"``malloc(1)`` (或 ``calloc(1, 1)``)。"

#: ../../c-api/memory.rst:146 ../../c-api/memory.rst:217

#: ../../c-api/memory.rst:325

msgid ""

"Allocates *n* bytes and returns a pointer of type :c:expr:`void*` to the "

"allocated memory, or ``NULL`` if the request fails."

msgstr "分配 *n* 个字节并返回一个指向所分配内存的 :c:expr:`void*` 类型指针，如果请求失败则返回 ``NULL``。"

#: ../../c-api/memory.rst:149

msgid ""

"Requesting zero bytes returns a distinct non-``NULL`` pointer if possible, "

"as if ``PyMem_RawMalloc(1)`` had been called instead. The memory will not "

"have been initialized in any way."

msgstr ""

"请求零字节可能返回一个独特的非 ``NULL`` 指针，就像调用了 ``PyMem_RawMalloc(1)`` 一样。但是内存不会以任何方式被初始化。"

#: ../../c-api/memory.rst:156 ../../c-api/memory.rst:227

#: ../../c-api/memory.rst:335

msgid ""

"Allocates *nelem* elements each whose size in bytes is *elsize* and returns "

"a pointer of type :c:expr:`void*` to the allocated memory, or ``NULL`` if "

"the request fails. The memory is initialized to zeros."

msgstr ""

"分配 *nelem* 个元素，每个元素的大小为 *elsize* 个字节，并返回指向所分配的内存的 :c:expr:`void*` "

"类型指针，如果请求失败则返回 ``NULL``。 内存会被初始化为零。"

#: ../../c-api/memory.rst:160

msgid ""

"Requesting zero elements or elements of size zero bytes returns a distinct "

"non-``NULL`` pointer if possible, as if ``PyMem_RawCalloc(1, 1)`` had been "

"called instead."

msgstr "请求零字节可能返回一个独特的非 ``NULL`` 指针，就像调用了 ``PyMem_RawCalloc(1, 1)`` 一样。"

#: ../../c-api/memory.rst:169 ../../c-api/memory.rst:240

#: ../../c-api/memory.rst:348

msgid ""

"Resizes the memory block pointed to by *p* to *n* bytes. The contents will "

"be unchanged to the minimum of the old and the new sizes."

msgstr "将 *p* 指向的内存块大小调整为 *n* 字节。以新旧内存块大小中的最小值为准，其中内容保持不变，"

#: ../../c-api/memory.rst:172

msgid ""

"If *p* is ``NULL``, the call is equivalent to ``PyMem_RawMalloc(n)``; else "

"if *n* is equal to zero, the memory block is resized but is not freed, and "

"the returned pointer is non-``NULL``."

msgstr ""

"如果 *p* 是 ``NULL`` ，则相当于调用 ``PyMem_RawMalloc(n)`` ；如果 *n* 等于 "

"0，则内存块大小会被调整，但不会被释放，返回非 ``NULL`` 指针。"

#: ../../c-api/memory.rst:176

msgid ""

"Unless *p* is ``NULL``, it must have been returned by a previous call to "

":c:func:`PyMem_RawMalloc`, :c:func:`PyMem_RawRealloc` or "

":c:func:`PyMem_RawCalloc`."

msgstr ""

"除非 *p* 是 ``NULL`` ，否则它必须是之前调用 :c:func:`PyMem_RawMalloc` 、 "

":c:func:`PyMem_RawRealloc` 或 :c:func:`PyMem_RawCalloc` 所返回的。"

#: ../../c-api/memory.rst:180

msgid ""

"If the request fails, :c:func:`PyMem_RawRealloc` returns ``NULL`` and *p* "

"remains a valid pointer to the previous memory area."

msgstr "如果请求失败，:c:func:`PyMem_RawRealloc` 返回 ``NULL`` ， *p* 仍然是指向先前内存区域的有效指针。"

#: ../../c-api/memory.rst:186

msgid ""

"Frees the memory block pointed to by *p*, which must have been returned by a"

" previous call to :c:func:`PyMem_RawMalloc`, :c:func:`PyMem_RawRealloc` or "

":c:func:`PyMem_RawCalloc`. Otherwise, or if ``PyMem_RawFree(p)`` has been "

"called before, undefined behavior occurs."

msgstr ""

"释放 *p* 指向的内存块。 *p* 必须是之前调用 :c:func:`PyMem_RawMalloc` 、 "

":c:func:`PyMem_RawRealloc` 或 :c:func:`PyMem_RawCalloc` 所返回的指针。否则，或在 "

"``PyMem_RawFree(p)`` 之前已经调用过的情况下，未定义的行为会发生。"

#: ../../c-api/memory.rst:191 ../../c-api/memory.rst:261

#: ../../c-api/memory.rst:369

msgid "If *p* is ``NULL``, no operation is performed."

msgstr "如果 *p* 是 ``NULL``, 那么什么操作也不会进行。"

#: ../../c-api/memory.rst:197

msgid "Memory Interface"

msgstr "内存接口"

#: ../../c-api/memory.rst:199 ../../c-api/memory.rst:305

msgid ""

"The following function sets, modeled after the ANSI C standard, but "

"specifying behavior when requesting zero bytes, are available for allocating"

" and releasing memory from the Python heap."

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

#: ../../c-api/memory.rst:203

msgid ""

"The :ref:`default memory allocator <default-memory-allocators>` uses the "

":ref:`pymalloc memory allocator <pymalloc>`."

msgstr ""

":ref:`默认内存分配器 <default-memory-allocators>` 使用了 :ref:`pymalloc 内存分配器 "

"<pymalloc>`."

#: ../../c-api/memory.rst:208 ../../c-api/memory.rst:320

msgid ""

"The :term:`GIL <global interpreter lock>` must be held when using these "

"functions."

msgstr "在使用这些函数时，必须持有 :term:`全局解释器锁（GIL） <global interpreter lock>` 。"

#: ../../c-api/memory.rst:213

msgid ""

"The default allocator is now pymalloc instead of system :c:func:`malloc`."

msgstr "现在默认的分配器是 pymalloc 而非系统的 :c:func:`malloc` 。"

#: ../../c-api/memory.rst:220

msgid ""

"Requesting zero bytes returns a distinct non-``NULL`` pointer if possible, "

"as if ``PyMem_Malloc(1)`` had been called instead. The memory will not have "

"been initialized in any way."

msgstr ""

"请求零字节可能返回一个独特的非 ``NULL`` 指针，就像调用了 ``PyMem_Malloc(1)`` 一样。但是内存不会以任何方式被初始化。"

#: ../../c-api/memory.rst:231

msgid ""

"Requesting zero elements or elements of size zero bytes returns a distinct "

"non-``NULL`` pointer if possible, as if ``PyMem_Calloc(1, 1)`` had been "

"called instead."

msgstr "请求零字节可能返回一个独特的非 ``NULL`` 指针，就像调用了 ``PyMem_Calloc(1, 1)`` 一样。"

#: ../../c-api/memory.rst:243

msgid ""

"If *p* is ``NULL``, the call is equivalent to ``PyMem_Malloc(n)``; else if "

"*n* is equal to zero, the memory block is resized but is not freed, and the "

"returned pointer is non-``NULL``."

msgstr ""

"如果 *p* 是 ``NULL`` ，则相当于调用 ``PyMem_Malloc(n)`` ；如果 *n* 等于 "

"0，则内存块大小会被调整，但不会被释放，返回非 ``NULL`` 指针。"

#: ../../c-api/memory.rst:247

msgid ""

"Unless *p* is ``NULL``, it must have been returned by a previous call to "

":c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc` or :c:func:`PyMem_Calloc`."

msgstr ""

"除非 *p* 是 ``NULL`` ，否则它必须是之前调用 :c:func:`PyMem_Malloc` 、 "

":c:func:`PyMem_Realloc` 或 :c:func:`PyMem_Calloc` 所返回的。"

#: ../../c-api/memory.rst:250

msgid ""

"If the request fails, :c:func:`PyMem_Realloc` returns ``NULL`` and *p* "

"remains a valid pointer to the previous memory area."

msgstr "如果请求失败，:c:func:`PyMem_Realloc` 返回 ``NULL`` ， *p* 仍然是指向先前内存区域的有效指针。"

#: ../../c-api/memory.rst:256

msgid ""

"Frees the memory block pointed to by *p*, which must have been returned by a"

" previous call to :c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc` or "

":c:func:`PyMem_Calloc`. Otherwise, or if ``PyMem_Free(p)`` has been called "

"before, undefined behavior occurs."

msgstr ""

"释放 *p* 指向的内存块。 *p* 必须是之前调用 :c:func:`PyMem_Malloc` 、 :c:func:`PyMem_Realloc` "

"或 :c:func:`PyMem_Calloc` 所返回的指针。否则，或在 ``PyMem_Free(p)`` "

"之前已经调用过的情况下，未定义的行为会发生。"

#: ../../c-api/memory.rst:263

msgid ""

"The following type-oriented macros are provided for convenience. Note that"

" *TYPE* refers to any C type."

msgstr "以下面向类型的宏为方便而提供。 注意 *TYPE* 可以指任何 C 类型。"

#: ../../c-api/memory.rst:269

msgid ""

"Same as :c:func:`PyMem_Malloc`, but allocates ``(n * sizeof(TYPE))`` bytes "

"of memory. Returns a pointer cast to ``TYPE*``. The memory will not have "

"been initialized in any way."

msgstr ""

"与 :c:func:`PyMem_Malloc` 相同，但会分配 ``(n * sizeof(TYPE))`` 字节的内存。 返回一个转换为 "

"``TYPE*`` 的指针。 内存不会以任何方式被初始化。"

#: ../../c-api/memory.rst:276

msgid ""

"Same as :c:func:`PyMem_Realloc`, but the memory block is resized to ``(n * "

"sizeof(TYPE))`` bytes. Returns a pointer cast to ``TYPE*``. On return, *p* "

"will be a pointer to the new memory area, or ``NULL`` in the event of "

"failure."

msgstr ""

"与 :c:func:`PyMem_Realloc` 类似，但内存块的大小被调整为 ``(n * sizeof(TYPE))`` 个字节。 返回一个转换为"

" ``TYPE*`` 的指针。 在返回时，*p* 将是一个指向新内存区域的指针，或者如果执行失败则为 ``NULL``。"

#: ../../c-api/memory.rst:281

msgid ""

"This is a C preprocessor macro; *p* is always reassigned. Save the original"

" value of *p* to avoid losing memory when handling errors."

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

#: ../../c-api/memory.rst:287

msgid "Same as :c:func:`PyMem_Free`."

msgstr "与 :c:func:`PyMem_Free` 相同"

#: ../../c-api/memory.rst:289

msgid ""

"In addition, the following macro sets are provided for calling the Python "

"memory allocator directly, without involving the C API functions listed "

"above. However, note that their use does not preserve binary compatibility "

"across Python versions and is therefore deprecated in extension modules."

msgstr ""

"此外，我们还提供了以下宏集用于直接调用 Python 内存分配器，而不涉及上面列出的 C API 函数。但是请注意，使用它们并不能保证跨 Python "

"版本的二进制兼容性，因此在扩展模块被弃用。"

#: ../../c-api/memory.rst:294

msgid "``PyMem_MALLOC(size)``"

msgstr "``PyMem_MALLOC(size)``"

#: ../../c-api/memory.rst:295

msgid "``PyMem_NEW(type, size)``"

msgstr "``PyMem_NEW(type, size)``"

#: ../../c-api/memory.rst:296

msgid "``PyMem_REALLOC(ptr, size)``"

msgstr "``PyMem_REALLOC(ptr, size)``"

#: ../../c-api/memory.rst:297

msgid "``PyMem_RESIZE(ptr, type, size)``"

msgstr "``PyMem_RESIZE(ptr, type, size)``"

#: ../../c-api/memory.rst:298

msgid "``PyMem_FREE(ptr)``"

msgstr "``PyMem_FREE(ptr)``"

#: ../../c-api/memory.rst:299

msgid "``PyMem_DEL(ptr)``"

msgstr "``PyMem_DEL(ptr)``"

#: ../../c-api/memory.rst:303

msgid "Object allocators"

msgstr "对象分配器"

#: ../../c-api/memory.rst:310

msgid ""

"There is no guarantee that the memory returned by these allocators can be "

"successfully cast to a Python object when intercepting the allocating "

"functions in this domain by the methods described in the :ref:`Customize "

"Memory Allocators <customize-memory-allocators>` section."

msgstr ""

"当通过 :ref:`自定义内存分配器 <customize-memory-allocators>` "

"部分描述的方法拦截该域中的分配函数时，无法保证这些分配器返回的内存可以被成功地转换成 Python 对象。"

#: ../../c-api/memory.rst:315

msgid ""

"The :ref:`default object allocator <default-memory-allocators>` uses the "

":ref:`pymalloc memory allocator <pymalloc>`."

msgstr ""

":ref:`默认对象分配器 <default-memory-allocators>` 使用 :ref:`pymalloc 内存分配器 "

"<pymalloc>`."

#: ../../c-api/memory.rst:328

msgid ""

"Requesting zero bytes returns a distinct non-``NULL`` pointer if possible, "

"as if ``PyObject_Malloc(1)`` had been called instead. The memory will not "

"have been initialized in any way."

msgstr ""

"请求零字节可能返回一个独特的非 ``NULL`` 指针，就像调用了 ``PyObject_Malloc(1)`` 一样。但是内存不会以任何方式被初始化。"

#: ../../c-api/memory.rst:339

msgid ""

"Requesting zero elements or elements of size zero bytes returns a distinct "

"non-``NULL`` pointer if possible, as if ``PyObject_Calloc(1, 1)`` had been "

"called instead."

msgstr "请求零字节可能返回一个独特的非 ``NULL`` 指针，就像调用了 ``PyObject_Calloc(1, 1)`` 一样。"

#: ../../c-api/memory.rst:351

msgid ""

"If *p* is ``NULL``, the call is equivalent to ``PyObject_Malloc(n)``; else "

"if *n* is equal to zero, the memory block is resized but is not freed, and "

"the returned pointer is non-``NULL``."

msgstr ""

"如果*p*是 ``NULL``，则相当于调用 ``PyObject_Malloc(n)`` ；如果 *n* 等于 "

"0，则内存块大小会被调整，但不会被释放，返回非 ``NULL`` 指针。"

#: ../../c-api/memory.rst:355

msgid ""

"Unless *p* is ``NULL``, it must have been returned by a previous call to "

":c:func:`PyObject_Malloc`, :c:func:`PyObject_Realloc` or "

":c:func:`PyObject_Calloc`."

msgstr ""

"除非 *p* 是 ``NULL`` ，否则它必须是之前调用 :c:func:`PyObject_Malloc` 、 "

":c:func:`PyObject_Realloc` 或 :c:func:`PyObject_Calloc` 所返回的。"

#: ../../c-api/memory.rst:358

msgid ""

"If the request fails, :c:func:`PyObject_Realloc` returns ``NULL`` and *p* "

"remains a valid pointer to the previous memory area."

msgstr "如果请求失败，:c:func:`PyObject_Realloc` 返回 ``NULL`` ， *p* 仍然是指向先前内存区域的有效指针。"

#: ../../c-api/memory.rst:364

msgid ""

"Frees the memory block pointed to by *p*, which must have been returned by a"

" previous call to :c:func:`PyObject_Malloc`, :c:func:`PyObject_Realloc` or "

":c:func:`PyObject_Calloc`. Otherwise, or if ``PyObject_Free(p)`` has been "

"called before, undefined behavior occurs."

msgstr ""

"释放 *p* 指向的内存块。 *p* 必须是之前调用 :c:func:`PyObject_Malloc` 、 "

":c:func:`PyObject_Realloc` 或 :c:func:`PyObject_Calloc` 所返回的指针。否则，或在 "

"``PyObject_Free(p)`` 之前已经调用过的情况下，未定义行为会发生。"

#: ../../c-api/memory.rst:375

msgid "Default Memory Allocators"

msgstr "默认内存分配器"

#: ../../c-api/memory.rst:377

msgid "Default memory allocators:"

msgstr "默认内存分配器："

#: ../../c-api/memory.rst:380

msgid "Configuration"

msgstr "配置"

#: ../../c-api/memory.rst:380

msgid "Name"

msgstr "名称"

#: ../../c-api/memory.rst:380

msgid "PyMem_RawMalloc"

msgstr "PyMem_RawMalloc"

#: ../../c-api/memory.rst:380

msgid "PyMem_Malloc"

msgstr "PyMem_Malloc"

#: ../../c-api/memory.rst:380

msgid "PyObject_Malloc"

msgstr "PyObject_Malloc"

#: ../../c-api/memory.rst:382

msgid "Release build"

msgstr "发布版本"

#: ../../c-api/memory.rst:382

msgid "``\"pymalloc\"``"

msgstr "``\"pymalloc\"``"

#: ../../c-api/memory.rst:382 ../../c-api/memory.rst:384

msgid "``malloc``"

msgstr "``malloc``"

#: ../../c-api/memory.rst:382

msgid "``pymalloc``"

msgstr "``pymalloc``"

#: ../../c-api/memory.rst:383

msgid "Debug build"

msgstr "调试构建"

#: ../../c-api/memory.rst:383

msgid "``\"pymalloc_debug\"``"

msgstr "``\"pymalloc_debug\"``"

#: ../../c-api/memory.rst:383 ../../c-api/memory.rst:385

msgid "``malloc`` + debug"

msgstr "``malloc`` + debug"

#: ../../c-api/memory.rst:383

msgid "``pymalloc`` + debug"

msgstr "``pymalloc`` + debug"

#: ../../c-api/memory.rst:384

msgid "Release build, without pymalloc"

msgstr "没有 pymalloc 的发布版本"

#: ../../c-api/memory.rst:384

msgid "``\"malloc\"``"

msgstr "``\"malloc\"``"

#: ../../c-api/memory.rst:385

msgid "Debug build, without pymalloc"

msgstr "没有 pymalloc 的调试构建"

#: ../../c-api/memory.rst:385

msgid "``\"malloc_debug\"``"

msgstr "``\"malloc_debug\"``"

#: ../../c-api/memory.rst:388

msgid "Legend:"

msgstr "说明："

#: ../../c-api/memory.rst:390

msgid "Name: value for :envvar:`PYTHONMALLOC` environment variable."

msgstr "名称：:envvar:`PYTHONMALLOC` 环境变量的值。"

#: ../../c-api/memory.rst:391

msgid ""

"``malloc``: system allocators from the standard C library, C functions: "

":c:func:`malloc`, :c:func:`calloc`, :c:func:`realloc` and :c:func:`free`."

msgstr ""

"``malloc``：来自 C 标准库的系统分配器，C "

"函数：:c:func:`malloc`、:c:func:`calloc`、:c:func:`realloc` 和 :c:func:`free`。"

#: ../../c-api/memory.rst:393

msgid "``pymalloc``: :ref:`pymalloc memory allocator <pymalloc>`."

msgstr "``pymalloc``：:ref:`pymalloc 内存分配器 <pymalloc>`."

#: ../../c-api/memory.rst:394

msgid ""

"\"+ debug\": with :ref:`debug hooks on the Python memory allocators <pymem-"

"debug-hooks>`."

msgstr "\"+ debug\": 附带 :ref:`Python 内存分配器的调试钩子 <pymem-debug-hooks>`."

#: ../../c-api/memory.rst:396

msgid "\"Debug build\": :ref:`Python build in debug mode <debug-build>`."

msgstr "“调试构建”：:ref:`调试模式下的 Python 构建 <debug-build>`。"

#: ../../c-api/memory.rst:401

msgid "Customize Memory Allocators"

msgstr "自定义内存分配器"

#: ../../c-api/memory.rst:407

msgid ""

"Structure used to describe a memory block allocator. The structure has the "

"following fields:"

msgstr "用于描述内存块分配器的结构体。 该结构体下列字段:"

#: ../../c-api/memory.rst:411 ../../c-api/memory.rst:658

msgid "Field"

msgstr "域"

#: ../../c-api/memory.rst:411 ../../c-api/memory.rst:658

msgid "Meaning"

msgstr "含意"

#: ../../c-api/memory.rst:413 ../../c-api/memory.rst:660

msgid "``void *ctx``"

msgstr "``void *ctx``"

#: ../../c-api/memory.rst:413 ../../c-api/memory.rst:660

msgid "user context passed as first argument"

msgstr "作为第一个参数传入的用户上下文"

#: ../../c-api/memory.rst:415

msgid "``void* malloc(void *ctx, size_t size)``"

msgstr "``void* malloc(void *ctx, size_t size)``"

#: ../../c-api/memory.rst:415

msgid "allocate a memory block"

msgstr "分配一个内存块"

#: ../../c-api/memory.rst:417

msgid "``void* calloc(void *ctx, size_t nelem, size_t elsize)``"

msgstr "``void* calloc(void *ctx, size_t nelem, size_t elsize)``"

#: ../../c-api/memory.rst:417

msgid "allocate a memory block initialized with zeros"

msgstr "分配一个初始化为 0 的内存块"

#: ../../c-api/memory.rst:420

msgid "``void* realloc(void *ctx, void *ptr, size_t new_size)``"

msgstr "``void* realloc(void *ctx, void *ptr, size_t new_size)``"

#: ../../c-api/memory.rst:420

msgid "allocate or resize a memory block"

msgstr "分配一个内存块或调整其大小"

#: ../../c-api/memory.rst:422

msgid "``void free(void *ctx, void *ptr)``"

msgstr "``void free(void *ctx, void *ptr)``"

#: ../../c-api/memory.rst:422

msgid "free a memory block"

msgstr "释放一个内存块"

#: ../../c-api/memory.rst:425

msgid ""

"The :c:type:`!PyMemAllocator` structure was renamed to "

":c:type:`PyMemAllocatorEx` and a new ``calloc`` field was added."

msgstr ""

":c:type:`!PyMemAllocator` 结构被重命名为 :c:type:`PyMemAllocatorEx` 并新增了一个 "

"``calloc`` 字段。"

#: ../../c-api/memory.rst:432

msgid "Enum used to identify an allocator domain. Domains:"

msgstr "用来识别分配器域的枚举类。域有："

#: ../../c-api/memory.rst:438 ../../c-api/memory.rst:447

#: ../../c-api/memory.rst:456

msgid "Functions:"

msgstr "函数"

#: ../../c-api/memory.rst:440

msgid ":c:func:`PyMem_RawMalloc`"

msgstr ":c:func:`PyMem_RawMalloc`"

#: ../../c-api/memory.rst:441

msgid ":c:func:`PyMem_RawRealloc`"

msgstr ":c:func:`PyMem_RawRealloc`"

#: ../../c-api/memory.rst:442

msgid ":c:func:`PyMem_RawCalloc`"

msgstr ":c:func:`PyMem_RawCalloc`"

#: ../../c-api/memory.rst:443

msgid ":c:func:`PyMem_RawFree`"

msgstr ":c:func:`PyMem_RawFree`"

#: ../../c-api/memory.rst:449

msgid ":c:func:`PyMem_Malloc`,"

msgstr ":c:func:`PyMem_Malloc`,"

#: ../../c-api/memory.rst:450

msgid ":c:func:`PyMem_Realloc`"

msgstr ":c:func:`PyMem_Realloc`"

#: ../../c-api/memory.rst:451

msgid ":c:func:`PyMem_Calloc`"

msgstr ":c:func:`PyMem_Calloc`"

#: ../../c-api/memory.rst:452

msgid ":c:func:`PyMem_Free`"

msgstr ":c:func:`PyMem_Free`"

#: ../../c-api/memory.rst:458

msgid ":c:func:`PyObject_Malloc`"

msgstr ":c:func:`PyObject_Malloc`"

#: ../../c-api/memory.rst:459

msgid ":c:func:`PyObject_Realloc`"

msgstr ":c:func:`PyObject_Realloc`"

#: ../../c-api/memory.rst:460

msgid ":c:func:`PyObject_Calloc`"

msgstr ":c:func:`PyObject_Calloc`"

#: ../../c-api/memory.rst:461

msgid ":c:func:`PyObject_Free`"

msgstr ":c:func:`PyObject_Free`"

#: ../../c-api/memory.rst:465

msgid "Get the memory block allocator of the specified domain."

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

#: ../../c-api/memory.rst:470

msgid "Set the memory block allocator of the specified domain."

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

#: ../../c-api/memory.rst:472

msgid ""

"The new allocator must return a distinct non-``NULL`` pointer when "

"requesting zero bytes."

msgstr "当请求零字节时，新的分配器必须返回一个独特的非 ``NULL`` 指针。"

#: ../../c-api/memory.rst:475

msgid ""

"For the :c:macro:`PYMEM_DOMAIN_RAW` domain, the allocator must be thread-"

"safe: the :term:`GIL <global interpreter lock>` is not held when the "

"allocator is called."

msgstr ""

"对于 :c:macro:`PYMEM_DOMAIN_RAW` 域，分配器必须是线程安全的：当分配器被调用时将不持有 :term:`GIL <global"

" interpreter lock>`。"

#: ../../c-api/memory.rst:479

msgid ""

"For the remaining domains, the allocator must also be thread-safe: the "

"allocator may be called in different interpreters that do not share a "

"``GIL``."

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

#: ../../c-api/memory.rst:483

msgid ""

"If the new allocator is not a hook (does not call the previous allocator), "

"the :c:func:`PyMem_SetupDebugHooks` function must be called to reinstall the"

" debug hooks on top on the new allocator."

msgstr ""

"如果新的分配器不是钩子（不调用之前的分配器），必须调用 :c:func:`PyMem_SetupDebugHooks` "

"函数在新分配器上重新安装调试钩子。"

#: ../../c-api/memory.rst:487

msgid ""

"See also :c:member:`PyPreConfig.allocator` and :ref:`Preinitialize Python "

"with PyPreConfig <c-preinit>`."

msgstr ""

"另请参阅 :c:member:`PyPreConfig.allocator` 和 :ref:`Preinitialize Python with "

"PyPreConfig <c-preinit>`。"

#: ../../c-api/memory.rst:492

msgid ":c:func:`PyMem_SetAllocator` does have the following contract:"

msgstr ":c:func:`PyMem_SetAllocator` 没有以下合约:"

#: ../../c-api/memory.rst:494

msgid ""

"It can be called after :c:func:`Py_PreInitialize` and before "

":c:func:`Py_InitializeFromConfig` to install a custom memory allocator. "

"There are no restrictions over the installed allocator other than the ones "

"imposed by the domain (for instance, the Raw Domain allows the allocator to "

"be called without the GIL held). See :ref:`the section on allocator domains "

"<allocator-domains>` for more information."

msgstr ""

"可以在 :c:func:`Py_PreInitialize` 之后 :c:func:`Py_InitializeFromConfig` "

"之前调用它来安装自定义的内存分配器。 对于所安装的分配器除了域的规定以外没有任何其他限制（例如 Raw Domain 允许分配器在不持有 GIL "

"的情况下被调用）。 请参阅 :ref:`有关分配器域的章节 <allocator-domains>` 来了解详情。"

#: ../../c-api/memory.rst:502

msgid ""

"If called after Python has finish initializing (after "

":c:func:`Py_InitializeFromConfig` has been called) the allocator **must** "

"wrap the existing allocator. Substituting the current allocator for some "

"other arbitrary one is **not supported**."

msgstr ""

"如果在 Python 已完成初始化之后（即 :c:func:`Py_InitializeFromConfig` 被调用之后）被调用则自定义分配器 "

"**must** 必须包装现有的分配器。 将现有分配器替换为任意的其他分配器是 **不受支持的**。"

#: ../../c-api/memory.rst:507

msgid "All allocators must be thread-safe."

msgstr "所有分配器都必须是线程安全的。"

#: ../../c-api/memory.rst:513

msgid ""

"Setup :ref:`debug hooks in the Python memory allocators <pymem-debug-hooks>`"

" to detect memory errors."

msgstr "设置 :ref:`Python 内存分配器的调试钩子 <pymem-debug-hooks>` 以检测内存错误。"

#: ../../c-api/memory.rst:520

msgid "Debug hooks on the Python memory allocators"

msgstr "Python 内存分配器的调试钩子"

#: ../../c-api/memory.rst:522

msgid ""

"When :ref:`Python is built in debug mode <debug-build>`, the "

":c:func:`PyMem_SetupDebugHooks` function is called at the :ref:`Python "

"preinitialization <c-preinit>` to setup debug hooks on Python memory "

"allocators to detect memory errors."

msgstr ""

"当 :ref:`Python 在调试模式下构建 <debug-build>`，:c:func:`PyMem_SetupDebugHooks` 函数在 "

":ref:`Python 预初始化 <c-preinit>` 时被调用，以在 Python 内存分配器上设置调试钩子以检测内存错误。"

#: ../../c-api/memory.rst:527

msgid ""

"The :envvar:`PYTHONMALLOC` environment variable can be used to install debug"

" hooks on a Python compiled in release mode (ex: ``PYTHONMALLOC=debug``)."

msgstr ""

":envvar:`PYTHONMALLOC` 环境变量可被用于在以发行模式下编译的 Python "

"上安装调试钩子（例如：``PYTHONMALLOC=debug``）。"

#: ../../c-api/memory.rst:530

msgid ""

"The :c:func:`PyMem_SetupDebugHooks` function can be used to set debug hooks "

"after calling :c:func:`PyMem_SetAllocator`."

msgstr ""

":c:func:`PyMem_SetupDebugHooks` 函数可被用于在调用了 :c:func:`PyMem_SetAllocator` "

"之后设置调试钩子。"

#: ../../c-api/memory.rst:533

msgid ""

"These debug hooks fill dynamically allocated memory blocks with special, "

"recognizable bit patterns. Newly allocated memory is filled with the byte "

"``0xCD`` (``PYMEM_CLEANBYTE``), freed memory is filled with the byte "

"``0xDD`` (``PYMEM_DEADBYTE``). Memory blocks are surrounded by \"forbidden "

"bytes\" filled with the byte ``0xFD`` (``PYMEM_FORBIDDENBYTE``). Strings of "

"these bytes are unlikely to be valid addresses, floats, or ASCII strings."

msgstr ""

"这些调试钩子用特殊的、可辨认的位模式填充动态分配的内存块。新分配的内存用字节 ``0xCD`` （``PYMEM_CLEANBYTE`` "

"）填充，释放的内存用字节 ``0xDD`` （``PYMEM_DEADBYTE`` ）填充。内存块被填充了字节 ``0xFD`` "

"（``PYMEM_FORBIDDENBYTE`` ）的“禁止字节”包围。这些字节串不太可能是合法的地址、浮点数或ASCII字符串"

#: ../../c-api/memory.rst:540

msgid "Runtime checks:"

msgstr "运行时检查："

#: ../../c-api/memory.rst:542

msgid ""

"Detect API violations. For example, detect if :c:func:`PyObject_Free` is "

"called on a memory block allocated by :c:func:`PyMem_Malloc`."

msgstr ""

"检测对 API 的违反。例如：检测对 :c:func:`PyMem_Malloc` 分配的内存块调用 :c:func:`PyObject_Free`。"

#: ../../c-api/memory.rst:544

msgid "Detect write before the start of the buffer (buffer underflow)."

msgstr "检测缓冲区起始位置前的写入（缓冲区下溢）。"

#: ../../c-api/memory.rst:545

msgid "Detect write after the end of the buffer (buffer overflow)."

msgstr "检测缓冲区终止位置后的写入（缓冲区溢出）。"

#: ../../c-api/memory.rst:546

msgid ""

"Check that the :term:`GIL <global interpreter lock>` is held when allocator "

"functions of :c:macro:`PYMEM_DOMAIN_OBJ` (ex: :c:func:`PyObject_Malloc`) and"

" :c:macro:`PYMEM_DOMAIN_MEM` (ex: :c:func:`PyMem_Malloc`) domains are "

"called."

msgstr ""

"检测当调用 :c:macro:`PYMEM_DOMAIN_OBJ` (如: :c:func:`PyObject_Malloc`) 和 "

":c:macro:`PYMEM_DOMAIN_MEM` (如: :c:func:`PyMem_Malloc`) 域的分配器函数时是否持有 "

":term:`GIL <global interpreter lock>`。"

#: ../../c-api/memory.rst:551

msgid ""

"On error, the debug hooks use the :mod:`tracemalloc` module to get the "

"traceback where a memory block was allocated. The traceback is only "

"displayed if :mod:`tracemalloc` is tracing Python memory allocations and the"

" memory block was traced."

msgstr ""

"在出错时，调试钩子使用 :mod:`tracemalloc` 模块来回溯内存块被分配的位置。只有当 :mod:`tracemalloc` 正在追踪 "

"Python 内存分配，并且内存块被追踪时，才会显示回溯。"

#: ../../c-api/memory.rst:556

msgid ""

"Let *S* = ``sizeof(size_t)``. ``2*S`` bytes are added at each end of each "

"block of *N* bytes requested. The memory layout is like so, where p "

"represents the address returned by a malloc-like or realloc-like function "

"(``p[i:j]`` means the slice of bytes from ``*(p+i)`` inclusive up to "

"``*(p+j)`` exclusive; note that the treatment of negative indices differs "

"from a Python slice):"

msgstr ""

"让 *S* = ``sizeof(size_t)``。 将 ``2*S`` 个字节添加到每个被请求的 *N* 字节数据块的两端。 "

"内存的布局像是这样，其中 p 代表由类似 malloc 或类似 realloc 的函数所返回的地址 (``p[i:j]`` 表示从 ``*(p+i)``"

" 左侧开始到 ``*(p+j)`` 左侧止的字节数据切片；请注意对负索引号的处理与 Python 切片是不同的）:"

#: ../../c-api/memory.rst:562

msgid "``p[-2*S:-S]``"

msgstr "``p[-2*S:-S]``"

#: ../../c-api/memory.rst:563

msgid ""

"Number of bytes originally asked for. This is a size_t, big-endian (easier "

"to read in a memory dump)."

msgstr "最初所要求的字节数。 这是一个 size_t，为大端序（易于在内存转储中读取）。"

#: ../../c-api/memory.rst:565

msgid "``p[-S]``"

msgstr "``p[-S]``"

#: ../../c-api/memory.rst:566

msgid "API identifier (ASCII character):"

msgstr "API 标识符（ASCII 字符）:"

#: ../../c-api/memory.rst:568

msgid "``'r'`` for :c:macro:`PYMEM_DOMAIN_RAW`."

msgstr "``'r'`` 表示 :c:macro:`PYMEM_DOMAIN_RAW`。"

#: ../../c-api/memory.rst:569

msgid "``'m'`` for :c:macro:`PYMEM_DOMAIN_MEM`."

msgstr "``'m'`` 表示 :c:macro:`PYMEM_DOMAIN_MEM`。"

#: ../../c-api/memory.rst:570

msgid "``'o'`` for :c:macro:`PYMEM_DOMAIN_OBJ`."

msgstr "``'o'`` 表示 :c:macro:`PYMEM_DOMAIN_OBJ`。"

#: ../../c-api/memory.rst:572

msgid "``p[-S+1:0]``"

msgstr "``p[-S+1:0]``"

#: ../../c-api/memory.rst:573

msgid "Copies of PYMEM_FORBIDDENBYTE. Used to catch under- writes and reads."

msgstr "PYMEM_FORBIDDENBYTE 的副本。 用于捕获下层的写入和读取。"

#: ../../c-api/memory.rst:575

msgid "``p[0:N]``"

msgstr "``p[0:N]``"

#: ../../c-api/memory.rst:576

msgid ""

"The requested memory, filled with copies of PYMEM_CLEANBYTE, used to catch "

"reference to uninitialized memory. When a realloc-like function is called "

"requesting a larger memory block, the new excess bytes are also filled with "

"PYMEM_CLEANBYTE. When a free-like function is called, these are overwritten"

" with PYMEM_DEADBYTE, to catch reference to freed memory. When a realloc- "

"like function is called requesting a smaller memory block, the excess old "

"bytes are also filled with PYMEM_DEADBYTE."