Python/C-API-Referenzhandbuch
*****************************

Dieses Handbuch dokumentiert die API, die von C- und
C++-Programmierern verwendet wird, die Erweiterungsmodule schreiben
oder Python einbinden möchten. Es ist eine Ergänzung zu Extending and
Embedding the Python Interpreter, das die allgemeinen Grundsätze zum
Erstellen von Erweiterungen beschreibt, die API-Funktionen jedoch
nicht im Detail dokumentiert.

* Einführung

  * Language version compatibility

  * Coding standards

  * Include Files

  * Useful macros

  * Objects, Types and Reference Counts

  * Ausnahmen

  * Embedding Python

  * Debugging Builds

  * Recommended third party tools

* C API and ABI Stability

  * Unstable C API

  * Stable Application Binary Interfaces

  * Platform Considerations

  * ABI Checking

  * Contents of Limited API

* The Very High Level Layer

  * Available start symbols

  * Stack Effects

* Reference Counting

* Exception Handling

  * Printing and clearing

  * Raising exceptions

  * Issuing warnings

  * Querying the error indicator

  * Signal Handling

  * Exception Classes

  * Exception Objects

  * Unicode Exception Objects

  * Recursion Control

  * Exception and warning types

  * Tracebacks

* Defining extension modules

  * Extension export hook

  * Multi-phase initialization

  * Multiple module instances

  * "PyInit" function

* Definition slots

  * Convenience macros

  * Common slot IDs

* Utilities

  * Operating System Utilities

  * System Functions

  * Process Control

  * Importing Modules

  * Data marshalling support

  * Argumente auswerten und Werte bilden

  * String conversion and formatting

  * Character classification and conversion

  * PyHash API

  * Reflection

  * Codec registry and support functions

  * PyTime C API

  * Support for Perf Maps

* Abstrakte Objekte Schicht

  * Object Protocol

  * Call Protocol

  * Number Protocol

  * Sequence Protocol

  * Mapping Protocol

  * Iterator Protocol

  * Buffer-Protokoll

* Concrete Objects Layer

  * Fundamental Objects

  * Numeric Objects

  * Sequence Objects

  * Container Objects

  * Function Objects

  * Other Objects

  * C API for extension modules

* Interpreter initialization and finalization

  * Before Python initialization

  * Global configuration variables

  * Initializing and finalizing the interpreter

  * Cautions regarding interpreter finalization

  * Interpreter views

  * Process-wide parameters

* Thread states and the global interpreter lock

  * Detaching the thread state from extension code

  * Using the C API from foreign threads

  * GIL-state APIs

  * Cautions about fork()

  * High-level APIs

  * Low-level APIs

* Asynchronous notifications

* Operating system thread APIs

* Synchronization primitives

  * Python critical section API

  * Legacy locking APIs

* Thread-local storage support

  * Thread-specific storage API

  * Dynamic allocation

  * Methods

  * Legacy APIs

* Multiple interpreters in a Python process

  * A per-interpreter GIL

  * Bugs and caveats

  * High-level APIs

  * Low-level APIs

  * Advanced debugger support

* Profiling and tracing

* Reference tracing

* Python Initialization Configuration

  * PyInitConfig C API

  * Configuration Options

  * Runtime Python configuration API

  * PyConfig C API

  * Py_GetArgcArgv()

  * Multi-Phase Initialization Private Provisional API

* Memory Management

  * Overview

  * Allocator Domains

  * Raw Memory Interface

  * Memory Interface

  * Object allocators

  * Default Memory Allocators

  * Customize Memory Allocators

  * Debug hooks on the Python memory allocators

  * The pymalloc allocator

  * The mimalloc allocator

  * tracemalloc C API

  * Examples

* Object Implementation Support

  * Objekte auf dem Heap zuweisen

  * Object Life Cycle

  * Common Object Structures

  * Type Object Structures

  * Supporting Cyclic Garbage Collection

* API- und ABI-Versionierung

  * Versionskonstanten zur Kompilierungszeit

  * Laufzeitversion

  * Bit-Packing-Makros

* Monitoring C API

* Generating Execution Events

  * Managing the Monitoring State
