Python/C API reference manual
*****************************

C'est la documentation de l'API utilisée par les développeurs C et C++
écrivant des modules d'extension ou intégrant Python. Elle va de pair
avec Extension et intégration de l'interpréteur Python, qui décrit les
principes généraux de l'écriture d'extensions, mais ne rentre pas dans
les détails de chaque fonction de l'API.

* Introduction

  * Language version compatibility

  * Coding standards

  * Include Files

  * Useful macros

  * Objects, Types and Reference Counts

  * Exceptions

  * Embarquer Python

  * Debugging Builds

  * Les outils tiers recommandés

* C API and ABI Stability

  * Unstable C API

  * Stable Application Binary Interfaces

  * Considérations relatives aux plateformes

  * ABI Checking

  * Contenu de l’API restreinte

* The Very High Level Layer

  * Available start symbols

  * Stack Effects

* Reference Counting

* Gestion des exceptions

  * Printing and clearing

  * Lever des exceptions

  * Issuing warnings

  * Querying the error indicator

  * Traitement des signaux

  * Exception Classes

  * Objets exception

  * Objets exception Unicode

  * Contrôle de la récursion

  * 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

* Utilitaires

  * Operating System Utilities

  * System Functions

  * Process Control

  * Importer des modules

  * Data marshalling support

  * Analyse des arguments et construction des valeurs

  * Conversion et formatage de chaînes

  * Character classification and conversion

  * PyHash API

  * Réflexion

  * Codec registry and support functions

  * PyTime C API

  * Support for Perf Maps

* Couche d'abstraction des objets

  * Protocole Objet

  * Call Protocol

  * Number Protocol

  * Sequence Protocol

  * Protocole de correspondance

  * Protocole d'itération

  * Protocole tampon

* Couche des objets concrets

  * Objets fondamentaux

  * Objets numériques

  * Objets séquences

  * Objets conteneurs

  * Objets fonctions

  * Autres objets

  * 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

  * Aperçu

  * 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

  * Exemples

* Implémentation d'objets

  * Allocating objects on the heap

  * Object Life Cycle

  * Common Object Structures

  * Type Object Structures

  * Supporting Cyclic Garbage Collection

* Version des API et ABI

  * Build-time version constants

  * Run-time version

  * Bit-packing macros

* Monitoring C API

* Generating Execution Events

  * Managing the Monitoring State
