Python概述

异常¶

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:

defincr_item(dict,key):
try:
item=dict[key]
exceptKeyError:
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;
intrv=-1;/* Return value initialized to -1 (failure) */
item=PyObject_GetItem(dict,key);
if(item==NULL){
/* Handle KeyError only: */
if(!PyErr_ExceptionMatches(PyExc_KeyError))
gotoerror;
/* Clear the error and use zero: */
PyErr_Clear();
item=PyLong_FromLong(0L);
if(item==NULL)
gotoerror;
}
const_one=PyLong_FromLong(1L);
if(const_one==NULL)
gotoerror;
incremented_item=PyNumber_Add(item,const_one);
if(incremented_item==NULL)
gotoerror;
if(PyObject_SetItem(dict,key,incremented_item)<0)
gotoerror;
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);
returnrv;/* -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 。