概述
****

Python 的应用编程接口（API）使得 C 和 C++ 程序员可以在多个层级上访问
Python 解释器。该 API 在 C++ 中同样可用，但为简化描述，通常将其称为
Python/C API。使用 Python/C API 有两个基本的理由。第一个理由是为了特定
目的而编写 *扩展模块*；它们是扩展 Python 解释器功能的 C 模块。这可能是
最常见的使用场景。第二个理由是将 Python 用作更大规模应用的组件；这种技
巧通常被称为在一个应用中 *embedding* Python。

编写扩展模块的过程相对来说更易于理解，可以通过“菜谱”的形式分步骤介绍。
使用某些工具可在一定程度上自动化这一过程。虽然人们在其他应用中嵌入
Python 的做法早已有之，但嵌入 Python 的过程没有编写扩展模块那样方便直
观。

许多 API 函数在你嵌入或是扩展 Python 这两种场景下都能发挥作用；此外，
大多数嵌入 Python 的应用程序也需要提供自定义扩展，因此在尝试在实际应用
中嵌入 Python 之前先熟悉编写扩展应该会是个好主意。


代码标准
========

如果你想要编写可包含于 CPython 的 C 代码，你 **必须** 遵循在 **PEP 7**
中定义的指导原则和标准。这些指导原则适用于任何你所要扩展的 Python 版本
。在编写你自己的第三方扩展模块时可以不必遵循这些规范，除非你准备在日后
向 Python 贡献这些模块。


包含文件
========

使用 Python/C API 所需要的全部函数、类型和宏定义可通过下面这行语句包含
到你的代码之中：

   #define PY_SSIZE_T_CLEAN
   #include <Python.h>

这意味着包含以下标准头文件："<stdio.h>"，"<string.h>"，"<errno.h>"，
"<limits.h>"，"<assert.h>" 和 "<stdlib.h>"（如果可用）。

注解:

  由于 Python 可能会定义一些能在某些系统上影响标准头文件的预处理器定义
  ，因此在包含任何标准头文件之前，你 *必须* 先包含 "Python.h"。It is
  recommended to always define "PY_SSIZE_T_CLEAN" before including
  "Python.h".  See 语句解释及变量编译 for a description of this macro.

Python.h 所定义的全部用户可见名称（由包含的标准头文件所定义的除外）都
带有前缀 "Py" 或者 "_Py"。以 "_Py" 打头的名称是供 Python 实现内部使用
的，不应被扩展编写者使用。结构成员名称没有保留前缀。

注解:

  User code should never define names that begin with "Py" or "_Py".
  This confuses the reader, and jeopardizes the portability of the
  user code to future Python versions, which may define additional
  names beginning with one of these prefixes.

头文件通常会与 Python 一起安装。在 Unix 上，它们位于以下目录：
"*prefix*/include/pythonversion/" 和
"*exec_prefix*/include/pythonversion/"，其中 "prefix" 和 "exec_prefix"
是由向 Python 的 **configure** 脚本传入的对应形参所定义，而 *version*
则为 "'%d.%d' % sys.version_info[:2]"。在 Windows 上，头文件安装于
"*prefix*/include"，其中 "prefix" 是向安装程序指定的安装目录。

要包含头文件，请将两个目录（如果不同）都放到你所用编译器的包含搜索路径
中。请 *不要* 将父目录放入搜索路径然后使用 "#include
<pythonX.Y/Python.h>"；这将使得多平台编译不可用，因为 "prefix" 下平台
无关的头文件需要包含来自 "exec_prefix" 下特定平台的头文件。

C++ users should note that although the API is defined entirely using
C, the header files properly declare the entry points to be "extern
"C"". As a result, there is no need to do anything special to use the
API from C++.


有用的宏
========

Python 头文件中定义了一些有用的宏。许多是在靠近它们被使用的地方定义的
（例如 "Py_RETURN_NONE"）。其他更为通用的则定义在这里。这里所显示的并
不是一个完整的列表。

Py_UNREACHABLE()

   Use this when you have a code path that cannot be reached by
   design. For example, in the "default:" clause in a "switch"
   statement for which all possible values are covered in "case"
   statements.  Use this in places where you might be tempted to put
   an "assert(0)" or "abort()" call.

   In release mode, the macro helps the compiler to optimize the code,
   and avoids a warning about unreachable code.  For example, the
   macro is implemented with "__builtin_unreachable()" on GCC in
   release mode.

   A use for "Py_UNREACHABLE()" is following a call a function that
   never returns but that is not declared "_Py_NO_RETURN".

   If a code path is very unlikely code but can be reached under
   exceptional case, this macro must not be used.  For example, under
   low memory condition or if a system call returns a value out of the
   expected range.  In this case, it's better to report the error to
   the caller.  If the error cannot be reported to caller,
   "Py_FatalError()" can be used.

   3.7 新版功能.

Py_ABS(x)

   返回 "x" 的绝对值。

   3.3 新版功能.

Py_MIN(x, y)

   返回 "x" 和 "y" 当中的最小值。

   3.3 新版功能.

Py_MAX(x, y)

   返回 "x" 和 "y" 当中的最大值。

   3.3 新版功能.

Py_STRINGIFY(x)

   将 "x" 转换为 C 字符串。例如 "Py_STRINGIFY(123)" 返回 ""123""。

   3.4 新版功能.

Py_MEMBER_SIZE(type, member)

   返回结构 ("type") "member" 的大小，以字节表示。

   3.6 新版功能.

Py_CHARMASK(c)

   参数必须为 [-128, 127] 或 [0, 255] 范围内的字符或整数类型。这个宏将
   "c" 强制转换为 "unsigned char" 返回。

Py_GETENV(s)

   Like "getenv(s)", but returns "NULL" if "-E" was passed on the
   command line (i.e. if "Py_IgnoreEnvironmentFlag" is set).

Py_UNUSED(arg)

   Use this for unused arguments in a function definition to silence
   compiler warnings. Example: "int func(int a, int Py_UNUSED(b)) {
   return a; }".

   3.4 新版功能.

Py_DEPRECATED(version)

   Use this for deprecated declarations.  The macro must be placed
   before the symbol name.

   示例:

      Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void);

   在 3.8 版更改: MSVC support was added.

PyDoc_STRVAR(name, str)

   Creates a variable with name "name" that can be used in docstrings.
   If Python is built without docstrings, the value will be empty.

   Use "PyDoc_STRVAR" for docstrings to support building Python
   without docstrings, as specified in **PEP 7**.

   示例:

      PyDoc_STRVAR(pop_doc, "Remove and return the rightmost element.");

      static PyMethodDef deque_methods[] = {
          // ...
          {"pop", (PyCFunction)deque_pop, METH_NOARGS, pop_doc},
          // ...
      }

PyDoc_STR(str)

   Creates a docstring for the given input string or an empty string
   if docstrings are disabled.

   Use "PyDoc_STR" in specifying docstrings to support building Python
   without docstrings, as specified in **PEP 7**.

   示例:

      static PyMethodDef pysqlite_row_methods[] = {
          {"keys", (PyCFunction)pysqlite_row_keys, METH_NOARGS,
              PyDoc_STR("Returns the keys of the row.")},
          {NULL, NULL}
      };


对象、类型和引用计数
====================

Most Python/C API functions have one or more arguments as well as a
return value of type "PyObject*".  This type is a pointer to an opaque
data type representing an arbitrary Python object.  Since all Python
object types are treated the same way by the Python language in most
situations (e.g., assignments, scope rules, and argument passing), it
is only fitting that they should be represented by a single C type.
Almost all Python objects live on the heap: you never declare an
automatic or static variable of type "PyObject", only pointer
variables of type "PyObject*" can  be declared.  The sole exception
are the type objects; since these must never be deallocated, they are
typically static "PyTypeObject" objects.

所有 Python 对象（甚至 Python 整数）都有一个 *type* 和一个 *reference
count*。对象的类型确定它是什么类型的对象（例如整数、列表或用户定义函数
；还有更多，如 标准类型层级结构 中所述）。对于每个众所周知的类型，都有
一个宏来检查对象是否属于该类型；例如，当（且仅当） *a* 所指的对象是
Python 列表时 "PyList_Check(a)" 为真。


引用计数
--------

The reference count is important because today's computers have a
finite (and often severely limited) memory size; it counts how many
different places there are that have a reference to an object.  Such a
place could be another object, or a global (or static) C variable, or
a local variable in some C function. When an object's reference count
becomes zero, the object is deallocated.  If it contains references to
other objects, their reference count is decremented. Those other
objects may be deallocated in turn, if this decrement makes their
reference count become zero, and so on.  (There's an obvious problem
with objects that reference each other here; for now, the solution is
"don't do that.")

Reference counts are always manipulated explicitly.  The normal way is
to use the macro "Py_INCREF()" to increment an object's reference
count by one, and "Py_DECREF()" to decrement it by   one.  The
"Py_DECREF()" macro is considerably more complex than the incref one,
since it must check whether the reference count becomes zero and then
cause the object's deallocator to be called. The deallocator is a
function pointer contained in the object's type structure.  The type-
specific deallocator takes care of decrementing the reference counts
for other objects contained in the object if this is a compound object
type, such as a list, as well as performing any additional
finalization that's needed.  There's no chance that the reference
count can overflow; at least as many bits are used to hold the
reference count as there are distinct memory locations in virtual
memory (assuming "sizeof(Py_ssize_t) >= sizeof(void*)"). Thus, the
reference count increment is a simple operation.

It is not necessary to increment an object's reference count for every
local variable that contains a pointer to an object.  In theory, the
object's reference count goes up by one when the variable is made to
point to it and it goes down by one when the variable goes out of
scope.  However, these two cancel each other out, so at the end the
reference count hasn't changed.  The only real reason to use the
reference count is to prevent the object from being deallocated as
long as our variable is pointing to it.  If we know that there is at
least one other reference to the object that lives at least as long as
our variable, there is no need to increment the reference count
temporarily. An important situation where this arises is in objects
that are passed as arguments to C functions in an extension module
that are called from Python; the call mechanism guarantees to hold a
reference to every argument for the duration of the call.

However, a common pitfall is to extract an object from a list and hold
on to it for a while without incrementing its reference count. Some
other operation might conceivably remove the object from the list,
decrementing its reference count and possibly deallocating it. The
real danger is that innocent-looking operations may invoke arbitrary
Python code which could do this; there is a code path which allows
control to flow back to the user from a "Py_DECREF()", so almost any
operation is potentially dangerous.

A safe approach is to always use the generic operations (functions
whose name begins with "PyObject_", "PyNumber_", "PySequence_" or
"PyMapping_"). These operations always increment the reference count
of the object they return. This leaves the caller with the
responsibility to call "Py_DECREF()" when they are done with the
result; this soon becomes second nature.


Reference Count Details
~~~~~~~~~~~~~~~~~~~~~~~

The reference count behavior of functions in the Python/C API is best
explained in terms of *ownership of references*.  Ownership pertains
to references, never to objects (objects are not owned: they are
always shared).  "Owning a reference" means being responsible for
calling Py_DECREF on it when the reference is no longer needed.
Ownership can also be transferred, meaning that the code that receives
ownership of the reference then becomes responsible for eventually
decref'ing it by calling "Py_DECREF()" or "Py_XDECREF()" when it's no
longer needed---or passing on this responsibility (usually to its
caller). When a function passes ownership of a reference on to its
caller, the caller is said to receive a *new* reference.  When no
ownership is transferred, the caller is said to *borrow* the
reference. Nothing needs to be done for a borrowed reference.

Conversely, when a calling function passes in a reference to an
object, there are two possibilities: the function *steals* a
reference to the object, or it does not.  *Stealing a reference* means
that when you pass a reference to a function, that function assumes
that it now owns that reference, and you are not responsible for it
any longer.

Few functions steal references; the two notable exceptions are
"PyList_SetItem()" and "PyTuple_SetItem()", which  steal a reference
to the item (but not to the tuple or list into which the item is
put!).  These functions were designed to steal a reference because of
a common idiom for populating a tuple or list with newly created
objects; for example, the code to create the tuple "(1, 2, "three")"
could look like this (forgetting about error handling for the moment;
a better way to code this is shown below):

   PyObject *t;

   t = PyTuple_New(3);
   PyTuple_SetItem(t, 0, PyLong_FromLong(1L));
   PyTuple_SetItem(t, 1, PyLong_FromLong(2L));
   PyTuple_SetItem(t, 2, PyUnicode_FromString("three"));

Here, "PyLong_FromLong()" returns a new reference which is immediately
stolen by "PyTuple_SetItem()".  When you want to keep using an object
although the reference to it will be stolen, use "Py_INCREF()" to grab
another reference before calling the reference-stealing function.

Incidentally, "PyTuple_SetItem()" is the *only* way to set tuple
items; "PySequence_SetItem()" and "PyObject_SetItem()" refuse to do
this since tuples are an immutable data type.  You should only use
"PyTuple_SetItem()" for tuples that you are creating yourself.

Equivalent code for populating a list can be written using
"PyList_New()" and "PyList_SetItem()".

However, in practice, you will rarely use these ways of creating and
populating a tuple or list.  There's a generic function,
"Py_BuildValue()", that can create most common objects from C values,
directed by a *format string*. For example, the above two blocks of
code could be replaced by the following (which also takes care of the
error checking):

   PyObject *tuple, *list;

   tuple = Py_BuildValue("(iis)", 1, 2, "three");
   list = Py_BuildValue("[iis]", 1, 2, "three");

It is much more common to use "PyObject_SetItem()" and friends with
items whose references you are only borrowing, like arguments that
were passed in to the function you are writing.  In that case, their
behaviour regarding reference counts is much saner, since you don't
have to increment a reference count so you can give a reference away
("have it be stolen").  For example, this function sets all items of a
list (actually, any mutable sequence) to a given item:

   int
   set_all(PyObject *target, PyObject *item)
   {
       Py_ssize_t i, n;

       n = PyObject_Length(target);
       if (n < 0)
           return -1;
       for (i = 0; i < n; i++) {
           PyObject *index = PyLong_FromSsize_t(i);
           if (!index)
               return -1;
           if (PyObject_SetItem(target, index, item) < 0) {
               Py_DECREF(index);
               return -1;
           }
           Py_DECREF(index);
       }
       return 0;
   }

The situation is slightly different for function return values.
While passing a reference to most functions does not change your
ownership responsibilities for that reference, many functions that
return a reference to an object give you ownership of the reference.
The reason is simple: in many cases, the returned object is created
on the fly, and the reference you get is the only reference to the
object.  Therefore, the generic functions that return object
references, like "PyObject_GetItem()" and  "PySequence_GetItem()",
always return a new reference (the caller becomes the owner of the
reference).

It is important to realize that whether you own a reference returned
by a function depends on which function you call only --- *the
plumage* (the type of the object passed as an argument to the
function) *doesn't enter into it!* Thus, if you  extract an item from
a list using "PyList_GetItem()", you don't own the reference --- but
if you obtain the same item from the same list using
"PySequence_GetItem()" (which happens to take exactly the same
arguments), you do own a reference to the returned object.

Here is an example of how you could write a function that computes the
sum of the items in a list of integers; once using
"PyList_GetItem()", and once using "PySequence_GetItem()".

   long
   sum_list(PyObject *list)
   {
       Py_ssize_t i, n;
       long total = 0, value;
       PyObject *item;

       n = PyList_Size(list);
       if (n < 0)
           return -1; /* Not a list */
       for (i = 0; i < n; i++) {
           item = PyList_GetItem(list, i); /* Can't fail */
           if (!PyLong_Check(item)) continue; /* Skip non-integers */
           value = PyLong_AsLong(item);
           if (value == -1 && PyErr_Occurred())
               /* Integer too big to fit in a C long, bail out */
               return -1;
           total += value;
       }
       return total;
   }

   long
   sum_sequence(PyObject *sequence)
   {
       Py_ssize_t i, n;
       long total = 0, value;
       PyObject *item;
       n = PySequence_Length(sequence);
       if (n < 0)
           return -1; /* Has no length */
       for (i = 0; i < n; i++) {
           item = PySequence_GetItem(sequence, i);
           if (item == NULL)
               return -1; /* Not a sequence, or other failure */
           if (PyLong_Check(item)) {
               value = PyLong_AsLong(item);
               Py_DECREF(item);
               if (value == -1 && PyErr_Occurred())
                   /* Integer too big to fit in a C long, bail out */
                   return -1;
               total += value;
           }
           else {
               Py_DECREF(item); /* Discard reference ownership */
           }
       }
       return total;
   }


类型
----

There are few other data types that play a significant role in  the
Python/C API; most are simple C types such as "int",  "long", "double"
and "char*".  A few structure types  are used to describe static
tables used to list the functions exported  by a module or the data
attributes of a new object type, and another is used to describe the
value of a complex number.  These will  be discussed together with the
functions that use them.


异常
====

Python程序员只需要处理特定需要处理的错误异常；未处理的异常会自动传递给
调用者，然后传递给调用者的调用者，依此类推，直到他们到达顶级解释器，在
那里将它们报告给用户并伴随堆栈回溯。

For C programmers, however, error checking always has to be explicit.
All functions in the Python/C API can raise exceptions, unless an
explicit claim is made otherwise in a function's documentation.  In
general, when a function encounters an error, it sets an exception,
discards any object references that it owns, and returns an error
indicator.  If not documented otherwise, this indicator is either
"NULL" or "-1", depending on the function's return type. A few
functions return a Boolean true/false result, with false indicating an
error.  Very few functions return no explicit error indicator or have
an ambiguous return value, and require explicit testing for errors
with "PyErr_Occurred()".  These exceptions are always explicitly
documented.

Exception state is maintained in per-thread storage (this is
equivalent to using global storage in an unthreaded application).  A
thread can be in one of two states: an exception has occurred, or not.
The function "PyErr_Occurred()" can be used to check for this: it
returns a borrowed reference to the exception type object when an
exception has occurred, and "NULL" otherwise.  There are a number of
functions to set the exception state: "PyErr_SetString()" is the most
common (though not the most general) function to set the exception
state, and "PyErr_Clear()" clears the exception state.

The full exception state consists of three objects (all of which can
be "NULL"): the exception type, the corresponding exception  value,
and the traceback.  These have the same meanings as the Python result
of "sys.exc_info()"; however, they are not the same: the Python
objects represent the last exception being handled by a Python  "try"
... "except" statement, while the C level exception state only exists
while an exception is being passed on between C functions until it
reaches the Python bytecode interpreter's  main loop, which takes care
of transferring it to "sys.exc_info()" and friends.

Note that starting with Python 1.5, the preferred, thread-safe way to
access the exception state from Python code is to call the function
"sys.exc_info()", which returns the per-thread exception state for
Python code.  Also, the semantics of both ways to access the exception
state have changed so that a function which catches an exception will
save and restore its thread's exception state so as to preserve the
exception state of its caller.  This prevents common bugs in exception
handling code caused by an innocent-looking function overwriting the
exception being handled; it also reduces the often unwanted lifetime
extension for objects that are referenced by the stack frames in the
traceback.

As a general principle, a function that calls another function to
perform some task should check whether the called function raised an
exception, and if so, pass the exception state on to its caller.  It
should discard any object references that it owns, and return an
error indicator, but it should *not* set another exception --- that
would overwrite the exception that was just raised, and lose important
information about the exact cause of the error.

A simple example of detecting exceptions and passing them on is shown
in the "sum_sequence()" example above.  It so happens that this
example doesn't need to clean up any owned references when it detects
an error.  The following example function shows some error cleanup.
First, to remind you why you like Python, we show the equivalent
Python code:

   def incr_item(dict, key):
       try:
           item = dict[key]
       except KeyError:
           item = 0
       dict[key] = item + 1

Here is the corresponding C code, in all its glory:

   int
   incr_item(PyObject *dict, PyObject *key)
   {
       /* Objects all initialized to NULL for Py_XDECREF */
       PyObject *item = NULL, *const_one = NULL, *incremented_item = NULL;
       int rv = -1; /* Return value initialized to -1 (failure) */

       item = PyObject_GetItem(dict, key);
       if (item == NULL) {
           /* Handle KeyError only: */
           if (!PyErr_ExceptionMatches(PyExc_KeyError))
               goto error;

           /* Clear the error and use zero: */
           PyErr_Clear();
           item = PyLong_FromLong(0L);
           if (item == NULL)
               goto error;
       }
       const_one = PyLong_FromLong(1L);
       if (const_one == NULL)
           goto error;

       incremented_item = PyNumber_Add(item, const_one);
       if (incremented_item == NULL)
           goto error;

       if (PyObject_SetItem(dict, key, incremented_item) < 0)
           goto error;
       rv = 0; /* Success */
       /* Continue with cleanup code */

    error:
       /* Cleanup code, shared by success and failure path */

       /* Use Py_XDECREF() to ignore NULL references */
       Py_XDECREF(item);
       Py_XDECREF(const_one);
       Py_XDECREF(incremented_item);

       return rv; /* -1 for error, 0 for success */
   }

This example represents an endorsed use of the "goto" statement  in C!
It illustrates the use of "PyErr_ExceptionMatches()" and
"PyErr_Clear()" to handle specific exceptions, and the use of
"Py_XDECREF()" to dispose of owned references that may be "NULL" (note
the "'X'" in the name; "Py_DECREF()" would crash when confronted with
a "NULL" reference).  It is important that the variables used to hold
owned references are initialized to "NULL" for this to work; likewise,
the proposed return value is initialized to "-1" (failure) and only
set to success after the final call made is successful.


嵌入Python
==========

The one important task that only embedders (as opposed to extension
writers) of the Python interpreter have to worry about is the
initialization, and possibly the finalization, of the Python
interpreter.  Most functionality of the interpreter can only be used
after the interpreter has been initialized.

The basic initialization function is "Py_Initialize()". This
initializes the table of loaded modules, and creates the fundamental
modules "builtins", "__main__", and "sys".  It also initializes the
module search path ("sys.path").

"Py_Initialize()" does not set the "script argument list"
("sys.argv"). If this variable is needed by Python code that will be
executed later, it must be set explicitly with a call to
"PySys_SetArgvEx(argc, argv, updatepath)" after the call to
"Py_Initialize()".

On most systems (in particular, on Unix and Windows, although the
details are slightly different), "Py_Initialize()" calculates the
module search path based upon its best guess for the location of the
standard Python interpreter executable, assuming that the Python
library is found in a fixed location relative to the Python
interpreter executable.  In particular, it looks for a directory named
"lib/python*X.Y*" relative to the parent directory where the
executable named "python" is found on the shell command search path
(the environment variable "PATH").

For instance, if the Python executable is found in
"/usr/local/bin/python", it will assume that the libraries are in
"/usr/local/lib/python*X.Y*".  (In fact, this particular path is also
the "fallback" location, used when no executable file named "python"
is found along "PATH".)  The user can override this behavior by
setting the environment variable "PYTHONHOME", or insert additional
directories in front of the standard path by setting "PYTHONPATH".

The embedding application can steer the search by calling
"Py_SetProgramName(file)" *before* calling  "Py_Initialize()".  Note
that "PYTHONHOME" still overrides this and "PYTHONPATH" is still
inserted in front of the standard path.  An application that requires
total control has to provide its own implementation of "Py_GetPath()",
"Py_GetPrefix()", "Py_GetExecPrefix()", and "Py_GetProgramFullPath()"
(all defined in "Modules/getpath.c").

Sometimes, it is desirable to "uninitialize" Python.  For instance,
the application may want to start over (make another call to
"Py_Initialize()") or the application is simply done with its  use of
Python and wants to free memory allocated by Python.  This can be
accomplished by calling "Py_FinalizeEx()".  The function
"Py_IsInitialized()" returns true if Python is currently in the
initialized state.  More information about these functions is given in
a later chapter. Notice that "Py_FinalizeEx()" does *not* free all
memory allocated by the Python interpreter, e.g. memory allocated by
extension modules currently cannot be released.


调试构建
========

Python can be built with several macros to enable extra checks of the
interpreter and extension modules.  These checks tend to add a large
amount of overhead to the runtime so they are not enabled by default.

A full list of the various types of debugging builds is in the file
"Misc/SpecialBuilds.txt" in the Python source distribution. Builds are
available that support tracing of reference counts, debugging the
memory allocator, or low-level profiling of the main interpreter loop.
Only the most frequently-used builds will be described in the
remainder of this section.

Compiling the interpreter with the "Py_DEBUG" macro defined produces
what is generally meant by "a debug build" of Python. "Py_DEBUG" is
enabled in the Unix build by adding "--with-pydebug" to the
"./configure" command.  It is also implied by the presence of the not-
Python-specific "_DEBUG" macro.  When "Py_DEBUG" is enabled in the
Unix build, compiler optimization is disabled.

除了前面描述的引用计数调试之外，还执行以下额外检查：

* 额外检查将添加到对象分配器。

* 额外的检查将添加到解析器和编译器中。

* Downcasts from wide types to narrow types are checked for loss of
  information.

* 许多断言被添加到字典和集合实现中。另外，集合对象需要 "test_c_api()"
  方法。

* 输入参数的完整性检查被添加到框架创建中。

* 使用已知的无效模式初始化整型的存储，以捕获对未初始化数字的引用。

* 添加底层跟踪和额外的异常检查到虚拟机的运行时中。

* Extra checks are added to the memory arena implementation.

* 添加额外调试到线程模块。

这里可能没有提到的额外的检查。

Defining "Py_TRACE_REFS" enables reference tracing.  When defined, a
circular doubly linked list of active objects is maintained by adding
two extra fields to every "PyObject".  Total allocations are tracked
as well.  Upon exit, all existing references are printed.  (In
interactive mode this happens after every statement run by the
interpreter.)  Implied by "Py_DEBUG".

有关更多详细信息，请参阅Python源代码中的 "Misc/SpecialBuilds.txt" 。
