This is /home/pdm/install/Python-2.1/Doc/api/python-api.info, produced by makeinfo version 4.0 from api.texi. April 15, 2001 2.1  File: python-api.info, Node: Supporting Cyclic Garbarge Collection, Prev: Buffer Object Structures, Up: Defining New Object Types Supporting Cyclic Garbarge Collection ===================================== Python's support for detecting and collecting garbage which involves circular references requires support from object types which are "containers" for other objects which may also be containers. Types which do not store references to other objects, or which only store references to atomic types (such as numbers or strings), do not need to provide any explicit support for garbage collection. To create a container type, the `tp_flags' field of the type object must include the `Py_TPFLAGS_GC' and provide an implementation of the `tp_traverse' handler. The computed value of the `tp_basicsize' field must include `PyGC_HEAD_SIZE' as well. If instances of the type are mutable, a `tp_clear' implementation must also be provided. `Py_TPFLAGS_GC' Objects with a type with this flag set must conform with the rules documented here. For convenience these objects will be referred to as container objects. `PyGC_HEAD_SIZE' Extra memory needed for the garbage collector. Container objects must include this in the calculation of their tp_basicsize. If the collector is disabled at compile time then this is `0'. Constructors for container types must conform to two rules: 1. The memory for the object must be allocated using `PyObject_New()' or `PyObject_VarNew()'. 2. Once all the fields which may contain references to other containers are initialized, it must call `PyObject_GC_Init()'. `void PyObject_GC_Init(PyObject *op)' Adds the object OP to the set of container objects tracked by the collector. The collector can run at unexpected times so objects must be valid while being tracked. This should be called once all the fields followed by the `tp_traverse' handler become valid, usually near the end of the constructor. Similarly, the deallocator for the object must conform to a similar pair of rules: 1. Before fields which refer to other containers are invalidated, `PyObject_GC_Fini()' must be called. 2. The object's memory must be deallocated using `PyObject_Del()'. `void PyObject_GC_Fini(PyObject *op)' Remove the object OP from the set of container objects tracked by the collector. Note that `PyObject_GC_Init()' can be called again on this object to add it back to the set of tracked objects. The deallocator (`tp_dealloc' handler) should call this for the object before any of the fields used by the `tp_traverse' handler become invalid. *Note:* Any container which may be referenced from another object reachable by the collector must itself be tracked by the collector, so it is generally not safe to call this function anywhere but in the object's deallocator. The `tp_traverse' handler accepts a function parameter of this type: `int (*visitproc)(PyObject *object, void *arg)' Type of the visitor function passed to the `tp_traverse' handler. The function should be called with an object to traverse as OBJECT and the third parameter to the `tp_traverse' handler as ARG. The `tp_traverse' handler must have the following type: `int (*traverseproc)(PyObject *self, visitproc visit, void *arg)' Traversal function for a container object. Implementations must call the VISIT function for each object directly contained by SELF, with the parameters to VISIT being the contained object and the ARG value passed to the handler. If VISIT returns a non-zero value then an error has occurred and that value should be returned immediately. The `tp_clear' handler must be of the `inquiry' type, or `NULL' if the object is immutable. `int (*inquiry)(PyObject *self)' Drop references that may have created reference cycles. Immutable objects do not have to define this method since they can never directly create reference cycles. Note that the object must still be valid after calling this method (i.e., don't just call `Py_DECREF()' on a reference). The collector will call this method if it detects that this object is involved in a reference cycle. * Menu: * Example Cycle Collector Support::  File: python-api.info, Node: Example Cycle Collector Support, Prev: Supporting Cyclic Garbarge Collection, Up: Supporting Cyclic Garbarge Collection Example Cycle Collector Support ------------------------------- This example shows only enough of the implementation of an extension type to show how the garbage collector support needs to be added. It shows the definition of the object structure, the `tp_traverse', `tp_clear' and `tp_dealloc' implementations, the type structure, and a constructor -- the module initialization needed to export the constructor to Python is not shown as there are no special considerations there for the collector. To make this interesting, assume that the module exposes ways for the `container' field of the object to be modified. Note that since no checks are made on the type of the object used to initialize `container', we have to assume that it may be a container. #include "Python.h" typedef struct { PyObject_HEAD PyObject *container; } MyObject; static int my_traverse(MyObject *self, visitproc visit, void *arg) { if (self->container != NULL) return visit(self->container, arg); else return 0; } static int my_clear(MyObject *self) { Py_XDECREF(self->container); self->container = NULL; return 0; } static void my_dealloc(MyObject *self) { PyObject_GC_Fini((PyObject *) self); Py_XDECREF(self->container); PyObject_Del(self); } statichere PyTypeObject MyObject_Type = { PyObject_HEAD_INIT(NULL) 0, "MyObject", sizeof(MyObject) + PyGC_HEAD_SIZE, 0, (destructor)my_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, 0, /* tp_doc */ (traverseproc)my_traverse, /* tp_traverse */ (inquiry)my_clear, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ }; /* This constructor should be made accessible from Python. */ static PyObject * new_object(PyObject *unused, PyObject *args) { PyObject *container = NULL; MyObject *result = NULL; if (PyArg_ParseTuple(args, "|O:new_object", &container)) { result = PyObject_New(MyObject, &MyObject_Type); if (result != NULL) { result->container = container; PyObject_GC_Init(); } } return (PyObject *) result; }  File: python-api.info, Node: Reporting Bugs, Next: Module Index, Prev: Defining New Object Types, Up: Top Reporting Bugs ************** Python is a mature programming language which has established a reputation for stability. In order to maintain this reputation, the developers would like to know of any deficiencies you find in Python or its documentation. All bug reports should be submitted via the Python Bug Tracker on SourceForge (). The bug tracker offers a Web form which allows pertinent information to be entered and submitted to the developers. Before submitting a report, please log into SourceForge if you are a member; this will make it possible for the developers to contact you for additional information if needed. If you are not a SourceForge member but would not mind the developers contacting you, you may include your email address in your bug description. In this case, please realize that the information is publically available and cannot be protected. The first step in filing a report is to determine whether the problem has already been reported. The advantage in doing so, aside from saving the developers time, is that you learn what has been done to fix it; it may be that the problem has already been fixed for the next release, or additional information is needed (in which case you are welcome to provide it if you can!). To do this, search the bug database using the search box near the bottom of the page. If the problem you're reporting is not already in the bug tracker, go back to the Python Bug Tracker (). Select the "Submit a Bug" link at the top of the page to open the bug reporting form. The submission form has a number of fields. The only fields that are required are the "Summary" and "Details" fields. For the summary, enter a _very_ short description of the problem; less than ten words is good. In the Details field, describe the problem in detail, including what you expected to happen and what did happen. Be sure to include the version of Python you used, whether any extension modules were involved, and what hardware and software platform you were using (including version information as appropriate). The only other field that you may want to set is the "Category" field, which allows you to place the bug report into a broad category (such as "Documentation" or "Library"). Each bug report will be assigned to a developer who will determine what needs to be done to correct the problem. If you have a SourceForge account and logged in to report the problem, you will receive an update each time action is taken on the bug. See also: `How to Report Bugs Effectively'{Article which goes into some detail about how to create a useful bug report. This describes what kind of information is useful and why it is useful.} `Bug Writing Guidelines'{Information about writing a good bug report. Some of this is specific to the Mozilla project, but describes general good practices.}  File: python-api.info, Node: Module Index, Next: Class-Exception-Object Index, Prev: Reporting Bugs, Up: Top Module Index ************ * Menu: * __builtin__ <1>: Initialization. * __builtin__: Embedding Python. * __main__ <1>: Initialization. * __main__: Embedding Python. * ihooks: Importing Modules. * rexec: Importing Modules. * signal: Exception Handling. * sys <1>: Initialization. * sys: Embedding Python. * thread: Thread State and the Global Interpreter Lock.  File: python-api.info, Node: Class-Exception-Object Index, Next: Function-Method-Variable Index, Prev: Module Index, Up: Top Class, Exception, and Object Index ********************************** * Menu: * buffer: Buffer Objects. * CObject: CObjects. * complex number: Complex Number Objects. * dictionary: Dictionary Objects. * file: File Objects. * floating point: Floating Point Objects. * instance: Instance Objects. * integer: Plain Integer Objects. * list: List Objects. * long integer: Long Integer Objects. * mapping: Mapping Objects. * module: Module Objects. * None@None: None Object. * numeric: Numeric Objects. * sequence: Sequence Objects. * string: String Objects. * tuple: Tuple Objects. * type <1>: Type Objects. * type: Objects.  File: python-api.info, Node: Function-Method-Variable Index, Next: Miscellaneous Index, Prev: Class-Exception-Object Index, Up: Top Function, Method, and Variable Index ************************************ * Menu: * __import__: Importing Modules. * _Py_c_diff: Complex Numbers as C Structures. * _Py_c_neg: Complex Numbers as C Structures. * _Py_c_pow: Complex Numbers as C Structures. * _Py_c_prod: Complex Numbers as C Structures. * _Py_c_quot: Complex Numbers as C Structures. * _Py_c_sum: Complex Numbers as C Structures. * _PyImport_FindExtension: Importing Modules. * _PyImport_Fini: Importing Modules. * _PyImport_FixupExtension: Importing Modules. * _PyImport_Init: Importing Modules. * _PyObject_Del: Defining New Object Types. * _PyObject_New: Defining New Object Types. * _PyObject_NewVar: Defining New Object Types. * _PyString_Resize: String Objects. * _PyTuple_Resize: Tuple Objects. * abs: Number Protocol. * apply: Object Protocol. * cmp: Object Protocol. * coerce: Number Protocol. * compile: Importing Modules. * divmod: Number Protocol. * float: Number Protocol. * hash: Object Protocol. * int: Number Protocol. * len <1>: Dictionary Objects. * len <2>: List Objects. * len <3>: Mapping Protocol. * len <4>: Sequence Protocol. * len: Object Protocol. * long: Number Protocol. * pow: Number Protocol. * Py_AtExit: Process Control. * Py_CompileString: Very High Level Layer. * Py_DECREF: Reference Counting. * Py_END_OF_BUFFER: Buffer Objects. * Py_EndInterpreter: Initialization. * Py_eval_input: Very High Level Layer. * Py_Exit: Process Control. * Py_FatalError: Process Control. * Py_FdIsInteractive: OS Utilities. * Py_file_input: Very High Level Layer. * Py_Finalize: Initialization. * Py_FindMethod: Common Object Structures. * Py_GetBuildInfo: Initialization. * Py_GetCompiler: Initialization. * Py_GetCopyright: Initialization. * Py_GetExecPrefix: Initialization. * Py_GetPath: Initialization. * Py_GetPlatform: Initialization. * Py_GetPrefix: Initialization. * Py_GetProgramFullPath: Initialization. * Py_GetProgramName: Initialization. * Py_GetVersion: Initialization. * Py_INCREF: Reference Counting. * Py_Initialize: Initialization. * Py_InitModule: Defining New Object Types. * Py_InitModule3: Defining New Object Types. * Py_InitModule4: Defining New Object Types. * Py_IsInitialized: Initialization. * Py_NewInterpreter: Initialization. * Py_None: None Object. * Py_SetProgramName: Initialization. * Py_single_input: Very High Level Layer. * Py_TPFLAGS_GC: Supporting Cyclic Garbarge Collection. * Py_TPFLAGS_HAVE_GETCHARBUFFER: Buffer Object Structures. * Py_UNICODE_ISALNUM: Unicode Objects. * Py_UNICODE_ISALPHA: Unicode Objects. * Py_UNICODE_ISDECIMAL: Unicode Objects. * Py_UNICODE_ISDIGIT: Unicode Objects. * Py_UNICODE_ISLINEBREAK: Unicode Objects. * Py_UNICODE_ISLOWER: Unicode Objects. * Py_UNICODE_ISNUMERIC: Unicode Objects. * Py_UNICODE_ISSPACE: Unicode Objects. * Py_UNICODE_ISTITLE: Unicode Objects. * Py_UNICODE_ISUPPER: Unicode Objects. * Py_UNICODE_TODECIMAL: Unicode Objects. * Py_UNICODE_TODIGIT: Unicode Objects. * Py_UNICODE_TOLOWER: Unicode Objects. * Py_UNICODE_TONUMERIC: Unicode Objects. * Py_UNICODE_TOTITLE: Unicode Objects. * Py_UNICODE_TOUPPER: Unicode Objects. * Py_XDECREF: Reference Counting. * Py_XINCREF: Reference Counting. * PyBuffer_Check: Buffer Objects. * PyBuffer_FromMemory: Buffer Objects. * PyBuffer_FromObject: Buffer Objects. * PyBuffer_FromReadWriteMemory: Buffer Objects. * PyBuffer_FromReadWriteObject: Buffer Objects. * PyBuffer_New: Buffer Objects. * PyBuffer_Type: Buffer Objects. * PyCallable_Check: Object Protocol. * PyCObject_AsVoidPtr: CObjects. * PyCObject_Check: CObjects. * PyCObject_FromVoidPtr: CObjects. * PyCObject_FromVoidPtrAndDesc: CObjects. * PyCObject_GetDesc: CObjects. * PyComplex_AsCComplex: Complex Numbers as Python Objects. * PyComplex_Check: Complex Numbers as Python Objects. * PyComplex_FromCComplex: Complex Numbers as Python Objects. * PyComplex_FromDoubles: Complex Numbers as Python Objects. * PyComplex_ImagAsDouble: Complex Numbers as Python Objects. * PyComplex_RealAsDouble: Complex Numbers as Python Objects. * PyComplex_Type: Complex Numbers as Python Objects. * PyDict_Check: Dictionary Objects. * PyDict_Clear: Dictionary Objects. * PyDict_Copy: Dictionary Objects. * PyDict_DelItem: Dictionary Objects. * PyDict_DelItemString: Dictionary Objects. * PyDict_GetItem: Dictionary Objects. * PyDict_GetItemString: Dictionary Objects. * PyDict_Items: Dictionary Objects. * PyDict_Keys: Dictionary Objects. * PyDict_New: Dictionary Objects. * PyDict_Next: Dictionary Objects. * PyDict_SetItem: Dictionary Objects. * PyDict_SetItemString: Dictionary Objects. * PyDict_Size: Dictionary Objects. * PyDict_Type: Dictionary Objects. * PyDict_Values: Dictionary Objects. * PyErr_BadArgument: Exception Handling. * PyErr_BadInternalCall: Exception Handling. * PyErr_CheckSignals: Exception Handling. * PyErr_Clear: Exception Handling. * PyErr_ExceptionMatches: Exception Handling. * PyErr_Fetch: Exception Handling. * PyErr_Format: Exception Handling. * PyErr_GivenExceptionMatches: Exception Handling. * PyErr_NewException: Exception Handling. * PyErr_NoMemory: Exception Handling. * PyErr_NormalizeException: Exception Handling. * PyErr_Occurred: Exception Handling. * PyErr_Print: Exception Handling. * PyErr_Restore: Exception Handling. * PyErr_SetFromErrno: Exception Handling. * PyErr_SetInterrupt: Exception Handling. * PyErr_SetNone: Exception Handling. * PyErr_SetObject: Exception Handling. * PyErr_SetString: Exception Handling. * PyErr_Warn: Exception Handling. * PyErr_WarnExplicit: Exception Handling. * PyErr_WriteUnraisable: Exception Handling. * PyEval_AcquireLock: Thread State and the Global Interpreter Lock. * PyEval_AcquireThread: Thread State and the Global Interpreter Lock. * PyEval_InitThreads: Thread State and the Global Interpreter Lock. * PyEval_ReleaseLock: Thread State and the Global Interpreter Lock. * PyEval_ReleaseThread: Thread State and the Global Interpreter Lock. * PyEval_RestoreThread: Thread State and the Global Interpreter Lock. * PyEval_SaveThread: Thread State and the Global Interpreter Lock. * PyFile_AsFile: File Objects. * PyFile_Check: File Objects. * PyFile_FromFile: File Objects. * PyFile_FromString: File Objects. * PyFile_GetLine: File Objects. * PyFile_Name: File Objects. * PyFile_SetBufSize: File Objects. * PyFile_SoftSpace: File Objects. * PyFile_Type: File Objects. * PyFile_WriteObject: File Objects. * PyFile_WriteString: File Objects. * PyFloat_AS_DOUBLE: Floating Point Objects. * PyFloat_AsDouble: Floating Point Objects. * PyFloat_Check: Floating Point Objects. * PyFloat_FromDouble: Floating Point Objects. * PyFloat_Type: Floating Point Objects. * PyGC_HEAD_SIZE: Supporting Cyclic Garbarge Collection. * PyImport_AddModule: Importing Modules. * PyImport_AppendInittab: Importing Modules. * PyImport_Cleanup: Importing Modules. * PyImport_ExecCodeModule: Importing Modules. * PyImport_ExtendInittab: Importing Modules. * PyImport_FrozenModules: Importing Modules. * PyImport_GetMagicNumber: Importing Modules. * PyImport_GetModuleDict: Importing Modules. * PyImport_Import: Importing Modules. * PyImport_ImportFrozenModule: Importing Modules. * PyImport_ImportModule: Importing Modules. * PyImport_ImportModuleEx: Importing Modules. * PyImport_ReloadModule: Importing Modules. * PyInstance_Check: Instance Objects. * PyInstance_New: Instance Objects. * PyInstance_NewRaw: Instance Objects. * PyInstance_Type: Instance Objects. * PyInt_AS_LONG: Plain Integer Objects. * PyInt_AsLong: Plain Integer Objects. * PyInt_Check: Plain Integer Objects. * PyInt_FromLong: Plain Integer Objects. * PyInt_GetMax: Plain Integer Objects. * PyInt_Type: Plain Integer Objects. * PyInterpreterState_Clear: Thread State and the Global Interpreter Lock. * PyInterpreterState_Delete: Thread State and the Global Interpreter Lock. * PyInterpreterState_New: Thread State and the Global Interpreter Lock. * PyList_Append: List Objects. * PyList_AsTuple: List Objects. * PyList_Check: List Objects. * PyList_GET_ITEM: List Objects. * PyList_GET_SIZE: List Objects. * PyList_GetItem: List Objects. * PyList_GetSlice: List Objects. * PyList_Insert: List Objects. * PyList_New: List Objects. * PyList_Reverse: List Objects. * PyList_SET_ITEM: List Objects. * PyList_SetItem: List Objects. * PyList_SetSlice: List Objects. * PyList_Size: List Objects. * PyList_Sort: List Objects. * PyList_Type: List Objects. * PyLong_AsDouble: Long Integer Objects. * PyLong_AsLong: Long Integer Objects. * PyLong_AsUnsignedLong: Long Integer Objects. * PyLong_Check: Long Integer Objects. * PyLong_FromDouble: Long Integer Objects. * PyLong_FromLong: Long Integer Objects. * PyLong_FromString: Long Integer Objects. * PyLong_FromUnsignedLong: Long Integer Objects. * PyLong_Type: Long Integer Objects. * PyMapping_Check: Mapping Protocol. * PyMapping_DelItem: Mapping Protocol. * PyMapping_DelItemString: Mapping Protocol. * PyMapping_GetItemString: Mapping Protocol. * PyMapping_HasKey: Mapping Protocol. * PyMapping_HasKeyString: Mapping Protocol. * PyMapping_Items: Mapping Protocol. * PyMapping_Keys: Mapping Protocol. * PyMapping_Length: Mapping Protocol. * PyMapping_SetItemString: Mapping Protocol. * PyMapping_Values: Mapping Protocol. * PyMem_Del: Memory Interface. * PyMem_Free: Memory Interface. * PyMem_Malloc: Memory Interface. * PyMem_New: Memory Interface. * PyMem_Realloc: Memory Interface. * PyMem_Resize: Memory Interface. * PyModule_AddIntConstant: Module Objects. * PyModule_AddObject: Module Objects. * PyModule_AddStringConstant: Module Objects. * PyModule_Check: Module Objects. * PyModule_GetDict: Module Objects. * PyModule_GetFilename: Module Objects. * PyModule_GetName: Module Objects. * PyModule_New: Module Objects. * PyModule_Type: Module Objects. * PyNumber_Absolute: Number Protocol. * PyNumber_Add: Number Protocol. * PyNumber_And: Number Protocol. * PyNumber_Check: Number Protocol. * PyNumber_Coerce: Number Protocol. * PyNumber_Divide: Number Protocol. * PyNumber_Divmod: Number Protocol. * PyNumber_Float: Number Protocol. * PyNumber_InPlaceAdd: Number Protocol. * PyNumber_InPlaceAnd: Number Protocol. * PyNumber_InPlaceDivide: Number Protocol. * PyNumber_InPlaceLshift: Number Protocol. * PyNumber_InPlaceMultiply: Number Protocol. * PyNumber_InPlaceOr: Number Protocol. * PyNumber_InPlacePower: Number Protocol. * PyNumber_InPlaceRemainder: Number Protocol. * PyNumber_InPlaceRshift: Number Protocol. * PyNumber_InPlaceSubtract: Number Protocol. * PyNumber_InPlaceXor: Number Protocol. * PyNumber_Int: Number Protocol. * PyNumber_Invert: Number Protocol. * PyNumber_Long: Number Protocol. * PyNumber_Lshift: Number Protocol. * PyNumber_Multiply: Number Protocol. * PyNumber_Negative: Number Protocol. * PyNumber_Or: Number Protocol. * PyNumber_Positive: Number Protocol. * PyNumber_Power: Number Protocol. * PyNumber_Remainder: Number Protocol. * PyNumber_Rshift: Number Protocol. * PyNumber_Subtract: Number Protocol. * PyNumber_Xor: Number Protocol. * PyObject_AsFileDescriptor: Object Protocol. * PyObject_CallFunction: Object Protocol. * PyObject_CallMethod: Object Protocol. * PyObject_CallObject: Object Protocol. * PyObject_Cmp: Object Protocol. * PyObject_Compare: Object Protocol. * PyObject_DEL: Defining New Object Types. * PyObject_Del: Defining New Object Types. * PyObject_DelAttr: Object Protocol. * PyObject_DelAttrString: Object Protocol. * PyObject_DelItem: Object Protocol. * PyObject_GC_Fini: Supporting Cyclic Garbarge Collection. * PyObject_GC_Init: Supporting Cyclic Garbarge Collection. * PyObject_GetAttr: Object Protocol. * PyObject_GetAttrString: Object Protocol. * PyObject_GetItem: Object Protocol. * PyObject_HasAttr: Object Protocol. * PyObject_HasAttrString: Object Protocol. * PyObject_Hash: Object Protocol. * PyObject_Init: Defining New Object Types. * PyObject_InitVar: Defining New Object Types. * PyObject_IsInstance: Object Protocol. * PyObject_IsSubclass: Object Protocol. * PyObject_IsTrue: Object Protocol. * PyObject_Length: Object Protocol. * PyObject_NEW: Defining New Object Types. * PyObject_New: Defining New Object Types. * PyObject_NEW_VAR: Defining New Object Types. * PyObject_NewVar: Defining New Object Types. * PyObject_Print: Object Protocol. * PyObject_Repr: Object Protocol. * PyObject_SetAttr: Object Protocol. * PyObject_SetAttrString: Object Protocol. * PyObject_SetItem: Object Protocol. * PyObject_Str: Object Protocol. * PyObject_Type: Object Protocol. * PyObject_Unicode: Object Protocol. * PyOS_AfterFork: OS Utilities. * PyOS_CheckStack: OS Utilities. * PyOS_GetLastModificationTime: OS Utilities. * PyOS_getsig: OS Utilities. * PyOS_setsig: OS Utilities. * PyParser_SimpleParseFile: Very High Level Layer. * PyParser_SimpleParseString: Very High Level Layer. * PyRun_AnyFile: Very High Level Layer. * PyRun_File: Very High Level Layer. * PyRun_InteractiveLoop: Very High Level Layer. * PyRun_InteractiveOne: Very High Level Layer. * PyRun_SimpleFile: Very High Level Layer. * PyRun_SimpleString: Very High Level Layer. * PyRun_String: Very High Level Layer. * PySequence_Check: Sequence Protocol. * PySequence_Concat: Sequence Protocol. * PySequence_Contains: Sequence Protocol. * PySequence_Count: Sequence Protocol. * PySequence_DelItem: Sequence Protocol. * PySequence_DelSlice: Sequence Protocol. * PySequence_Fast: Sequence Protocol. * PySequence_Fast_GET_ITEM: Sequence Protocol. * PySequence_GetItem: Sequence Protocol. * PySequence_GetSlice: Sequence Protocol. * PySequence_Index: Sequence Protocol. * PySequence_InPlaceConcat: Sequence Protocol. * PySequence_InPlaceRepeat: Sequence Protocol. * PySequence_Length: Sequence Protocol. * PySequence_List: Sequence Protocol. * PySequence_Repeat: Sequence Protocol. * PySequence_SetItem: Sequence Protocol. * PySequence_SetSlice: Sequence Protocol. * PySequence_Size: Sequence Protocol. * PySequence_Tuple: Sequence Protocol. * PyString_AS_STRING: String Objects. * PyString_AsEncodedString: String Objects. * PyString_AsString: String Objects. * PyString_AsStringAndSize: String Objects. * PyString_Check: String Objects. * PyString_Concat: String Objects. * PyString_ConcatAndDel: String Objects. * PyString_Decode: String Objects. * PyString_Encode: String Objects. * PyString_Format: String Objects. * PyString_FromString: String Objects. * PyString_FromStringAndSize: String Objects. * PyString_GET_SIZE: String Objects. * PyString_InternFromString: String Objects. * PyString_InternInPlace: String Objects. * PyString_Size: String Objects. * PyString_Type: String Objects. * PySys_SetArgv: Initialization. * PyThreadState_Clear: Thread State and the Global Interpreter Lock. * PyThreadState_Delete: Thread State and the Global Interpreter Lock. * PyThreadState_Get: Thread State and the Global Interpreter Lock. * PyThreadState_New: Thread State and the Global Interpreter Lock. * PyThreadState_Swap: Thread State and the Global Interpreter Lock. * PyTuple_Check: Tuple Objects. * PyTuple_GET_ITEM: Tuple Objects. * PyTuple_GetItem: Tuple Objects. * PyTuple_GetSlice: Tuple Objects. * PyTuple_New: Tuple Objects. * PyTuple_SET_ITEM: Tuple Objects. * PyTuple_SetItem: Tuple Objects. * PyTuple_Size: Tuple Objects. * PyTuple_Type: Tuple Objects. * PyType_Check: Type Objects. * PyType_HasFeature: Type Objects. * PyType_Type: Type Objects. * PyUnicode_AS_DATA: Unicode Objects. * PyUnicode_AS_UNICODE: Unicode Objects. * PyUnicode_AsASCIIString: Builtin Codecs. * PyUnicode_AsCharmapString: Builtin Codecs. * PyUnicode_AsEncodedString: Builtin Codecs. * PyUnicode_AsLatin1String: Builtin Codecs. * PyUnicode_AsMBCSString: Builtin Codecs. * PyUnicode_AsRawUnicodeEscapeString: Builtin Codecs. * PyUnicode_AsUnicode: Unicode Objects. * PyUnicode_AsUnicodeEscapeString: Builtin Codecs. * PyUnicode_AsUTF16String: Builtin Codecs. * PyUnicode_AsUTF8String: Builtin Codecs. * PyUnicode_AsWideChar: Unicode Objects. * PyUnicode_Check: Unicode Objects. * PyUnicode_Compare: Methods and Slot Functions. * PyUnicode_Concat: Methods and Slot Functions. * PyUnicode_Contains: Methods and Slot Functions. * PyUnicode_Count: Methods and Slot Functions. * PyUnicode_Decode: Builtin Codecs. * PyUnicode_DecodeASCII: Builtin Codecs. * PyUnicode_DecodeCharmap: Builtin Codecs. * PyUnicode_DecodeLatin1: Builtin Codecs. * PyUnicode_DecodeMBCS: Builtin Codecs. * PyUnicode_DecodeRawUnicodeEscape: Builtin Codecs. * PyUnicode_DecodeUnicodeEscape: Builtin Codecs. * PyUnicode_DecodeUTF16: Builtin Codecs. * PyUnicode_DecodeUTF8: Builtin Codecs. * PyUnicode_Encode: Builtin Codecs. * PyUnicode_EncodeASCII: Builtin Codecs. * PyUnicode_EncodeCharmap: Builtin Codecs. * PyUnicode_EncodeLatin1: Builtin Codecs. * PyUnicode_EncodeMBCS: Builtin Codecs. * PyUnicode_EncodeRawUnicodeEscape: Builtin Codecs. * PyUnicode_EncodeUnicodeEscape: Builtin Codecs. * PyUnicode_EncodeUTF16: Builtin Codecs. * PyUnicode_EncodeUTF8: Builtin Codecs. * PyUnicode_Find: Methods and Slot Functions. * PyUnicode_Format: Methods and Slot Functions. * PyUnicode_FromEncodedObject: Unicode Objects. * PyUnicode_FromObject: Unicode Objects. * PyUnicode_FromUnicode: Unicode Objects. * PyUnicode_FromWideChar: Unicode Objects. * PyUnicode_GET_DATA_SIZE: Unicode Objects. * PyUnicode_GET_SIZE: Unicode Objects. * PyUnicode_GetSize: Unicode Objects. * PyUnicode_Join: Methods and Slot Functions. * PyUnicode_Replace: Methods and Slot Functions. * PyUnicode_Split: Methods and Slot Functions. * PyUnicode_Splitlines: Methods and Slot Functions. * PyUnicode_Tailmatch: Methods and Slot Functions. * PyUnicode_Translate: Methods and Slot Functions. * PyUnicode_TranslateCharmap: Builtin Codecs. * PyUnicode_Type: Unicode Objects. * reload: Importing Modules. * repr: Object Protocol. * str: Object Protocol. * tuple <1>: List Objects. * tuple: Sequence Protocol. * type: Object Protocol. * unistr: Object Protocol.  File: python-api.info, Node: Miscellaneous Index, Prev: Function-Method-Variable Index, Up: Top Miscellaneous Index ******************* * Menu: * __all__: Importing Modules. * __dict__: Module Objects. * __doc__: Module Objects. * __file__: Module Objects. * __name__: Module Objects. * abort(): Process Control. * argv: Initialization. * buffer interface: Buffer Objects. * BufferType: Buffer Objects. * calloc(): Overview. * cleanup functions: Process Control. * close(): Initialization. * copyright: Initialization. * DictionaryType: Dictionary Objects. * DictType: Dictionary Objects. * EOFError: File Objects. * errno: Thread State and the Global Interpreter Lock. * exc_info() <1>: Thread State and the Global Interpreter Lock. * exc_info(): Exceptions. * exc_traceback <1>: Exception Handling. * exc_traceback: Exceptions. * exc_type <1>: Exception Handling. * exc_type: Exceptions. * exc_value <1>: Exception Handling. * exc_value: Exceptions. * Exception: Deprecation of String Exceptions. * executable: Initialization. * exit(): Process Control. * FileType: File Objects. * FloatType: Floating Point Objects. * fopen(): File Objects. * free(): Overview. * freeze utility: Importing Modules. * global interpreter lock: Thread State and the Global Interpreter Lock. * incr_item(): Exceptions. * int (*getcharbufferproc) (PyObject *self, int segment, const char **ptrptr): Buffer Object Structures. * int (*getreadbufferproc) (PyObject *self, int segment, void **ptrptr): Buffer Object Structures. * int (*getsegcountproc) (PyObject *self, int *lenp): Buffer Object Structures. * int (*getwritebufferproc) (PyObject *self, int segment, void **ptrptr): Buffer Object Structures. * int (*inquiry)(PyObject *self): Supporting Cyclic Garbarge Collection. * int (*traverseproc)(PyObject *self, visitproc visit, void *arg): Supporting Cyclic Garbarge Collection. * int (*visitproc)(PyObject *object, void *arg): Supporting Cyclic Garbarge Collection. * interpreter lock: Thread State and the Global Interpreter Lock. * IntType: Plain Integer Objects. * KeyboardInterrupt: Exception Handling. * ListType: List Objects. * lock, interpreter: Thread State and the Global Interpreter Lock. * LONG_MAX <1>: Long Integer Objects. * LONG_MAX: Plain Integer Objects. * LongType: Long Integer Objects. * main(): Initialization. * malloc(): Overview. * module search path <1>: Initialization. * module search path: Embedding Python. * modules <1>: Initialization. * modules: Importing Modules. * ModuleType: Module Objects. * package variable!__all__: Importing Modules. * path <1>: Initialization. * path: Embedding Python. * platform: Initialization. * Py_BEGIN_ALLOW_THREADS: Thread State and the Global Interpreter Lock. * Py_BEGIN_BLOCK_THREADS: Thread State and the Global Interpreter Lock. * Py_BEGIN_UNBLOCK_THREADS: Thread State and the Global Interpreter Lock. * Py_CompileString(): Very High Level Layer. * Py_complex: Complex Numbers as C Structures. * Py_DECREF(): Reference Counts. * Py_END_ALLOW_THREADS: Thread State and the Global Interpreter Lock. * Py_FatalError(): Initialization. * Py_Finalize() <1>: Initialization. * Py_Finalize(): Process Control. * Py_GetExecPrefix(): Embedding Python. * Py_GetPath() <1>: Initialization. * Py_GetPath(): Embedding Python. * Py_GetPrefix(): Embedding Python. * Py_GetProgramFullPath(): Embedding Python. * Py_INCREF(): Reference Counts. * Py_Initialize() <1>: Thread State and the Global Interpreter Lock. * Py_Initialize() <2>: Initialization. * Py_Initialize(): Embedding Python. * Py_IsInitialized(): Embedding Python. * Py_PRINT_RAW: File Objects. * Py_SetProgramName() <1>: Initialization. * Py_SetProgramName(): Embedding Python. * Py_UNICODE: Unicode Objects. * Py_XDECREF(): Exceptions. * PyBufferObject: Buffer Objects. * PyBufferProcs <1>: Buffer Object Structures. * PyBufferProcs: Buffer Objects. * PyCFunction: Common Object Structures. * PyCObject: CObjects. * PyComplexObject: Complex Numbers as Python Objects. * PyDictObject: Dictionary Objects. * PyErr_Clear(): Exceptions. * PyErr_ExceptionMatches(): Exceptions. * PyErr_Occurred(): Exceptions. * PyErr_SetString(): Exceptions. * PyEval_AcquireLock() <1>: Thread State and the Global Interpreter Lock. * PyEval_AcquireLock(): Initialization. * PyEval_InitThreads(): Initialization. * PyEval_ReleaseLock() <1>: Thread State and the Global Interpreter Lock. * PyEval_ReleaseLock(): Initialization. * PyEval_ReleaseThread(): Thread State and the Global Interpreter Lock. * PyEval_RestoreThread(): Thread State and the Global Interpreter Lock. * PyEval_SaveThread(): Thread State and the Global Interpreter Lock. * PyFileObject: File Objects. * PyFloatObject: Floating Point Objects. * PyInterpreterState: Thread State and the Global Interpreter Lock. * PyIntObject: Plain Integer Objects. * PyList_GetItem(): Reference Count Details. * PyList_SetItem(): Reference Count Details. * PyListObject: List Objects. * PyLongObject: Long Integer Objects. * PyMappingMethods: Mapping Object Structures. * PyMethodDef: Common Object Structures. * PyNumberMethods: Number Object Structures. * PySequence_GetItem(): Reference Count Details. * PySequenceMethods: Sequence Object Structures. * PyString_FromString(): Dictionary Objects. * PyStringObject: String Objects. * PySys_SetArgv() <1>: Initialization. * PySys_SetArgv(): Embedding Python. * PyThreadState: Thread State and the Global Interpreter Lock. * PyTuple_SetItem(): Reference Count Details. * PyTupleObject: Tuple Objects. * PyType_HasFeature(): Buffer Object Structures. * PyTypeObject: Type Objects. * PyUnicodeObject: Unicode Objects. * realloc(): Overview. * set_all(): Reference Count Details. * setcheckinterval(): Thread State and the Global Interpreter Lock. * setvbuf(): File Objects. * SIGINT: Exception Handling. * softspace: File Objects. * stderr: Initialization. * stdin: Initialization. * stdout: Initialization. * strerror(): Exception Handling. * StringType: String Objects. * struct _frozen: Importing Modules. * struct _inittab: Importing Modules. * sum_list(): Reference Count Details. * sum_sequence() <1>: Exceptions. * sum_sequence(): Reference Count Details. * SystemError: Module Objects. * TupleType: Tuple Objects. * TypeType: Type Objects. * ULONG_MAX: Long Integer Objects. * version: Initialization.