簡介¶
Python 的应用编程接口(API)使得 C 和 C++ 程序员可以在多个层级上访问 Python 解释器。该 API 在 C++ 中同样可用,但为简化描述,通常将其称为 Python/C API。使用 Python/C API 有两个基本的理由。第一个理由是为了特定目的而编写 扩展模块;它们是扩展 Python 解释器功能的 C 模块。这可能是最常见的使用场景。第二个理由是将 Python 用作更大规模应用的组件;这种技巧通常被称为在一个应用中 embedding Python。
Writing an extension module is a relatively well-understood process, where a 「cookbook」 approach works well. There are several tools that automate the process to some extent. While people have embedded Python in other applications since its early existence, the process of embedding Python is less straightforward than writing an extension.
许多 API 函数在你嵌入或是扩展 Python 这两种场景下都能发挥作用;此外,大多数嵌入 Python 的应用程序也需要提供自定义扩展,因此在尝试在实际应用中嵌入 Python 之前先熟悉编写扩展应该会是个好主意。
包含文件¶
使用 Python/C API 所需要的全部函数、类型和宏定义可通过下面这行语句包含到你的代码之中:
#include "Python.h"
这意味着包含以下标准头文件:<stdio.h>
,<string.h>
,<errno.h>
,<limits.h>
,<assert.h>
和 <stdlib.h>
(如果可用)。
備註
由于 Python 可能会定义一些能在某些系统上影响标准头文件的预处理器定义,因此在包含任何标准头文件之前,你 必须 先包含 Python.h
。
Python.h 所定义的全部用户可见名称(由包含的标准头文件所定义的除外)都带有前缀 Py
或者 _Py
。以 _Py
打头的名称是供 Python 实现内部使用的,不应被扩展编写者使用。结构成员名称没有保留前缀。
Important: 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 though the API is defined entirely using C, the
header files do properly declare the entry points to be extern "C"
, so there
is no need to do anything special to use the API from C++.
对象、类型和引用计数¶
大多数 Python/C API 函数都有一个或多个参数以及一个 PyObject*
类型的返回值。此类型是一个指针,指向表示一个任意 Python 对象的不透明数据类型。由于在大多数情况下(例如赋值、作用域规则和参数传递) Python 语言都会以同样的方式处理所有 Python 对象类型,因此它们由一个单独的 C 类型来表示是很适宜的。几乎所有 Python 对象都生存在堆上:你绝不会声明一个 PyObject
类型的自动或静态变量,只有 PyObject*
类型的指针变量可以被声明。唯一的例外是 type 对象;由于此种对象永远不能被释放,所以它们通常是静态 PyTypeObject
对象。
所有 Python 对象(甚至 Python 整数)都有一个 type 和一个 reference count。对象的类型确定它是什么类型的对象(例如整数、列表或用户定义函数;还有更多,如 标准类型层级结构 中所述)。对于每个众所周知的类型,都有一个宏来检查对象是否属于该类型;例如,当(且仅当) a 所指的对象是 Python 列表时 PyList_Check(a)
为真。
引用计数¶
引用计数非常重要,因为现代计算机内存(通常十分)有限;它计算有多少不同的地方引用同一个对象。这样的地方可以是某个对象,或者是某个全局(或静态)C 变量,亦或是某个 C 函数的局部变量。当一个对象的引用计数变为 0,释放该对象。如果这个已释放的对象包含其它对象的引用计数,则递减这些对象的引用计数。如果这些对象的引用计数减少为零,则可以依次释放这些对象,依此类推。(这里有一个很明显的问题——对象之间相互引用;目前,解决方案是“不要那样做”。)
总是显式操作引用计数。通常的方法是使用宏 Py_INCREF()
来增加一个对象的引用计数,使用宏 Py_DECREF()
来减少一个对象的引用计数。宏 Py_DECREF()
必须检查引用计数是否为零,然后调用对象的释放器, 因此它比 incref 宏复杂得多。释放器是一个包含在对象类型结构中的函数指针。如果对象是复合对象类型(例如列表),则类型特定的释放器负责递减包含在对象中的其他对象的引用计数,并执行所需的终结。引用计数不会溢出,至少用与虚拟内存中不同内存位置一样多的位用于保存引用计数(即 sizeof(Py_ssize_t) >= sizeof(void*)
)。因此,引用计数递增是一个简单的操作。
没有必要为每个包含指向对象的指针的局部变量增加对象的引用计数。理论上,当变量指向对象时,对象的引用计数增加 1 ,当变量超出范围时,对象的引用计数减少 1 。但是,这两者相互抵消,所以最后引用计数没有改变。使用引用计数的唯一真正原因是只要我们的变量指向它,就可以防止对象被释放。如果知道至少有一个对该对象的其他引用存活时间至少和我们的变量一样长,则没必要临时增加引用计数。一个典型的情形是,对象作为参数从 Python 中传递给被调用的扩展模块中的 C 函数时,调用机制会保证在调用期间持有对所有参数的引用。
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 possible 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.
一个安全的方式是始终使用泛型操作(名称以 PyObject_
, PyNumber_
, PySequence_
或 PyMapping_
开头的函数)。这些操作总是增加它们返回的对象的引用计数。这让调用者有责任在获得结果后调用 Py_DECREF()
。习惯这种方式很简单。
引用计数细节¶
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
下面是对应的闪耀荣光的 C 代码:
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/pythonX.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/pythonX.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.
除了前面描述的引用计数调试之外,还执行以下额外检查:
额外检查将添加到对象分配器。
额外的检查将添加到解析器和编译器中。
检查从宽类型向窄类型的向下强转是否损失了信息。
许多断言被添加到字典和集合实现中。另外,集合对象包含
test_c_api()
方法。添加输入参数的完整性检查到框架创建中。
使用已知的无效模式初始化整型的存储,以捕获对未初始化数字的引用。
添加底层跟踪和额外的异常检查到虚拟机的运行时中。
添加额外的检查到 arena 内存实现。
添加额外调试到线程模块。
这里可能没有提到的额外的检查。
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
。