# Вступ

Інтерфейс прикладного програміста для Python надає програмістам C і C++ доступ до інтерпретатора Python на різних рівнях. API так само можна використовувати з C++, але для стислості його зазвичай називають Python/C API. Є дві принципово різні причини використання Python/C API. Перша причина полягає в написанні модулів розширення для певних цілей; це модулі C, які розширюють інтерпретатор Python. Мабуть, це найпоширеніше використання. Друга причина полягає в тому, щоб використовувати Python як компонент у більшій програмі; цей прийом зазвичай називають embedding Python у програму.

Написання модуля розширення є відносно добре зрозумілим процесом, де добре працює підхід «кулінарної книги». Є кілька інструментів, які певною мірою автоматизують процес. Хоча люди вбудовували Python в інші програми з самого початку його існування, процес вбудовування Python менш простий, ніж написання розширення.

Багато функцій API корисні незалежно від того, чи ви вбудовуєте чи розширюєте Python; крім того, більшість програм, які вбудовують Python, потребуватимуть також надати спеціальне розширення, тому, мабуть, доцільно ознайомитися з написанням розширення перед тим, як намагатися вставити Python у реальну програму.

## Стандарти кодування

Якщо ви пишете код C для включення в CPython, ви повинні дотримуватися вказівок і стандартів, визначених у PEP 7. Ці вказівки застосовуються незалежно від версії Python, до якої ви робите внесок. Дотримання цих умов не є обов’язковим для ваших власних модулів розширення сторонніх розробників, якщо тільки ви не плануєте додати їх до Python.

## Включати файли

Усі визначення функцій, типів і макросів, необхідні для використання API Python/C, включено у ваш код у такий рядок:

    #define PY_SSIZE_T_CLEAN
    #include <Python.h>

This implies inclusion of the following standard headers: `<stdio.h>`, `<string.h>`, `<errno.h>`, `<limits.h>`, `<assert.h>` and `<stdlib.h>` (if available).

Примітка

Оскільки Python може визначати деякі визначення попереднього процесора, які впливають на стандартні заголовки в деяких системах, ви мусите включити `Python.h` перед тим, як включити будь-які стандартні заголовки.

Рекомендується завжди визначати `PY_SSIZE_T_CLEAN` перед включенням `Python.h`. Перегляньте Розбір аргументів і створення значень для опису цього макросу.

Усі видимі для користувача імена, визначені Python.h (крім тих, що визначені включеними стандартними заголовками), мають один із префіксів `Py` або `_Py`. Імена, що починаються з `_Py` призначені для внутрішнього використання реалізацією Python і не повинні використовуватися розробниками розширень. Імена членів структури не мають зарезервованого префікса.

Примітка

Код користувача ніколи не повинен визначати імена, які починаються з `Py` або `_Py`. Це заплутує читача та ставить під загрозу перенесення коду користувача на майбутні версії Python, які можуть визначати додаткові імена, що починаються з одного з цих префіксів.

The header files are typically installed with Python. On Unix, these are located in the directories `prefix/include/pythonversion/` and `exec_prefix/include/pythonversion/`, where `prefix` and `exec_prefix` are defined by the corresponding parameters to Python’s configure script and version is `'%d.%d' % sys.version_info[:2]`. On Windows, the headers are installed in `prefix/include`, where `prefix` is the installation directory specified to the installer.

To include the headers, place both directories (if different) on your compiler’s search path for includes. Do not place the parent directories on the search path and then use `#include <pythonX.Y/Python.h>`; this will break on multi-platform builds since the platform independent headers under `prefix` include the platform specific headers from `exec_prefix`.

Користувачі C++ повинні мати на увазі, що хоча API повністю визначено за допомогою C, файли заголовків належним чином оголошують точки входу як `extern "C"`. Як наслідок, немає потреби робити щось особливе для використання API із C++.

## Корисні макроси

У файлах заголовків Python визначено кілька корисних макросів. Багато визначено ближче до того, де вони корисні (наприклад, `Py_RETURN_NONE`). Тут визначено інші більш загальні корисності. Це не обов’язково повний список.

`Py_UNREACHABLE`()

  Використовуйте це, якщо у вас є шлях коду, який неможливий за проектом. Наприклад, у реченні `default:` в операторі `switch`, для якого всі можливі значення охоплюються в операторах `case`. Використовуйте це в місцях, де у вас може виникнути спокуса викликати `assert(0)` або `abort()`.

  У режимі випуску макрос допомагає компілятору оптимізувати код і уникає попередження про недоступність коду. Наприклад, макрос реалізовано за допомогою `__builtin_unreachable()` на GCC у режимі випуску.

  Використання `Py_UNREACHABLE()` — це виклик функції, яка ніколи не повертається, але не оголошена `_Py_NO_RETURN`.

  Якщо кодовий шлях є дуже малоймовірним кодом, але його можна досягти у виняткових випадках, цей макрос не можна використовувати. Наприклад, у разі недостатнього обсягу пам’яті або якщо системний виклик повертає значення за межами очікуваного діапазону. У цьому випадку краще повідомити про помилку абонента. Якщо про помилку неможливо повідомити абоненту, можна використати `Py_FatalError()`.

  Нове в версії 3.7.

`Py_ABS`(x)

  Повертає абсолютне значення `x`.

  Нове в версії 3.3.

`Py_MIN`(x, y)

  Повертає мінімальне значення між `x` і `y`.

  Нове в версії 3.3.

`Py_MAX`(x, y)

  Повертає максимальне значення між `x` і `y`.

  Нове в версії 3.3.

`Py_STRINGIFY`(x)

  Перетворіть `x` на рядок C. наприклад `Py_STRINGIFY(123)` повертає `"123"`.

  Нове в версії 3.4.

`Py_MEMBER_SIZE`(type, member)

  Повертає розмір члена структури (`type`) у байтах.

  Нове в версії 3.6.

`Py_CHARMASK`(c)

  Аргумент має бути символом або цілим числом у діапазоні [-128, 127] або [0, 255]. Цей макрос повертає `c`, приведений до `unsigned char`.

`Py_GETENV`(s)

  Like `getenv(s)`, but returns `NULL` if `-E` was passed on the command line (i.e. if `Py_IgnoreEnvironmentFlag` is set).

`Py_UNUSED`(arg)

  Використовуйте це для невикористаних аргументів у визначенні функції, щоб заглушити попередження компілятора. Приклад: `int func(int a, int Py_UNUSED(b)) { return a; }`.

  Нове в версії 3.4.

`Py_DEPRECATED`(version)

  Використовуйте це для застарілих декларацій. Макрос необхідно розмістити перед назвою символу.

  Приклад:

      Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void);

  Змінено в версії 3.8: Додано підтримку MSVC.

`PyDoc_STRVAR`(name, str)

  Створює змінну з назвою `name`, яку можна використовувати в рядках документів. Якщо Python створено без рядків документації, значення буде порожнім.

  Використовуйте `PyDoc_STRVAR` для рядків документів, щоб підтримувати створення Python без рядків документів, як зазначено в PEP 7.

  Приклад:

      PyDoc_STRVAR(pop_doc, "Remove and return the rightmost element.");

      static PyMethodDef deque_methods[] = {
          // ...
          {"pop", (PyCFunction)deque_pop, METH_NOARGS, pop_doc},
          // ...
      }

`PyDoc_STR`(str)

  Створює рядок документації для заданого рядка введення або порожній рядок, якщо рядки документації вимкнено.

  Використовуйте `PyDoc_STR` у визначенні рядків документів, щоб підтримувати створення Python без рядків документів, як зазначено в PEP 7.

  Приклад:

      static PyMethodDef pysqlite_row_methods[] = {
          {"keys", (PyCFunction)pysqlite_row_keys, METH_NOARGS,
              PyDoc_STR("Returns the keys of the row.")},
          {NULL, NULL}
      };

## Об’єкти, типи та кількість посилань

Most Python/C API functions have one or more arguments as well as a return value of type `PyObject*`. This type is a pointer to an opaque data type representing an arbitrary Python object. Since all Python object types are treated the same way by the Python language in most situations (e.g., assignments, scope rules, and argument passing), it is only fitting that they should be represented by a single C type. Almost all Python objects live on the heap: you never declare an automatic or static variable of type `PyObject`, only pointer variables of type `PyObject*` can be declared. The sole exception are the type objects; since these must never be deallocated, they are typically static `PyTypeObject` objects.

Усі об’єкти Python (навіть цілі числа Python) мають type і reference counting. Тип об’єкта визначає тип об’єкта (наприклад, ціле число, список або визначена користувачем функція; їх багато інших, як пояснюється в Стандартна ієрархія типів). Для кожного з добре відомих типів існує макрос, щоб перевірити, чи належить об’єкт до цього типу; наприклад, `PyList_Check(a)` є істинним, якщо (і тільки якщо) об’єкт, на який вказує a, є списком Python.

### Довідкова кількість

The reference count is important because today’s computers have a finite (and often severely limited) memory size; it counts how many different places there are that have a strong reference to an object. Such a place could be another object, or a global (or static) C variable, or a local variable in some C function. When the last strong reference to an object is released (i.e. its reference count becomes zero), the object is deallocated. If it contains references to other objects, those references are released. Those other objects may be deallocated in turn, if there are no more references to them, and so on. (There’s an obvious problem with objects that reference each other here; for now, the solution is «don’t do that.»)

Reference counts are always manipulated explicitly. The normal way is to use the macro `Py_INCREF()` to take a new reference to an object (i.e. increment its reference count by one), and `Py_DECREF()` to release that reference (i.e. decrement the reference count by one). The `Py_DECREF()` macro is considerably more complex than the incref one, since it must check whether the reference count becomes zero and then cause the object’s deallocator to be called. The deallocator is a function pointer contained in the object’s type structure. The type-specific deallocator takes care of releasing references for other objects contained in the object if this is a compound object type, such as a list, as well as performing any additional finalization that’s needed. There’s no chance that the reference count can overflow; at least as many bits are used to hold the reference count as there are distinct memory locations in virtual memory (assuming `sizeof(Py_ssize_t) >= sizeof(void*)`). Thus, the reference count increment is a simple operation.

It is not necessary to hold a strong reference (i.e. increment the reference count) for every local variable that contains a pointer to an object. In theory, the object’s reference count goes up by one when the variable is made to point to it and it goes down by one when the variable goes out of scope. However, these two cancel each other out, so at the end the reference count hasn’t changed. The only real reason to use the reference count is to prevent the object from being deallocated as long as our variable is pointing to it. If we know that there is at least one other reference to the object that lives at least as long as our variable, there is no need to take a new strong reference (i.e. increment the reference count) temporarily. An important situation where this arises is in objects that are passed as arguments to C functions in an extension module that are called from Python; the call mechanism guarantees to hold a reference to every argument for the duration of the call.

However, a common pitfall is to extract an object from a list and hold on to it for a while without taking a new reference. Some other operation might conceivably remove the object from the list, releasing that reference, and possibly 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.

A safe approach is to always use the generic operations (functions whose name begins with `PyObject_`, `PyNumber_`, `PySequence_` or `PyMapping_`). These operations always create a new strong reference (i.e. increment the reference count) of the object they return. This leaves the caller with the responsibility to call `Py_DECREF()` when they are done with the result; this soon becomes second nature.

#### Деталі кількості посилань

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 releasing 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.

І навпаки, коли функція, що викликає, передає посилання на об’єкт, є дві можливості: функція вкрадає посилання на об’єкт або ні. Крадіжка посилання означає, що коли ви передаєте посилання на функцію, ця функція припускає, що вона тепер володіє цим посиланням, і ви більше не несете за це відповідальності.

Кілька функцій викрадають посилання; двома помітними винятками є `PyList_SetItem()` і `PyTuple_SetItem()`, які викрадають посилання на елемент (але не на кортеж або список, до якого поміщено елемент!). Ці функції були розроблені для викрадення посилання через загальну ідіому для заповнення кортежу або списку новоствореними об’єктами; наприклад, код для створення кортежу `(1, 2, "three")` може виглядати так (наразі забувши про обробку помилок; кращий спосіб кодування цього показано нижче):

    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"));

Тут `PyLong_FromLong()` повертає нове посилання, яке негайно викрадає `PyTuple_SetItem()`. Якщо ви хочете продовжувати використовувати об’єкт, хоча посилання на нього буде вкрадено, використовуйте `Py_INCREF()`, щоб захопити інше посилання перед викликом функції викрадання посилань.

До речі, `PyTuple_SetItem()` є єдиним способом встановлення елементів кортежу; `PySequence_SetItem()` і `PyObject_SetItem()` відмовляються робити це, оскільки кортежі є незмінним типом даних. Ви повинні використовувати лише `PyTuple_SetItem()` для кортежів, які ви створюєте самостійно.

Еквівалентний код для заповнення списку можна написати за допомогою `PyList_New()` і `PyList_SetItem()`.

Однак на практиці ви рідко будете використовувати ці способи створення та заповнення кортежу чи списку. Існує загальна функція, `Py_BuildValue()`, яка може створювати найбільш поширені об’єкти зі значень C, керованих format string. Наприклад, наведені вище два блоки коду можна замінити наступним (який також піклується про перевірку помилок):

    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 references is much saner, since you don’t have to take a new reference just so you can give that 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;
    }

Ситуація дещо інша для значень, що повертаються функцією. Хоча передача посилання на більшість функцій не змінює вашу відповідальність за це посилання, багато функцій, які повертають посилання на об’єкт, передають вам право власності на посилання. Причина проста: у багатьох випадках повернутий об’єкт створюється на льоту, і отримане вами посилання є єдиним посиланням на об’єкт. Тому загальні функції, які повертають посилання на об’єкти, як-от `PyObject_GetItem()` і `PySequence_GetItem()`, завжди повертають нове посилання (викликач стає власником посилання).

Важливо розуміти, що чи володієте ви посиланням, яке повертає функція, залежить лише від того, яку функцію ви викликаєте — оперення (тип об’єкта, переданого як аргумент функції) не входить до нього ! Таким чином, якщо ви витягуєте елемент зі списку за допомогою `PyList_GetItem()`, ви не володієте посиланням — але якщо ви отримуєте той самий елемент із того самого списку за допомогою `PySequence_GetItem()` (який приймає точно ті самі аргументи), у вас є посилання на повернутий об’єкт.

Ось приклад того, як можна написати функцію, яка обчислює суму елементів у списку цілих чисел; один раз за допомогою `PyList_GetItem()` і один раз за допомогою `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.

type `Py_ssize_t`
  Part of the Stable ABI.

  Інтегральний тип зі знаком, такий що `sizeof(Py_ssize_t) == sizeof(size_t)`. C99 не визначає таку річ безпосередньо (size_t є беззнаковим інтегральним типом). Подробиці див. PEP 353. `PY_SSIZE_T_MAX` є найбільшим додатним значенням типу `Py_ssize_t`.

## Винятки

Програміст на Python має мати справу лише з винятками, якщо потрібна спеціальна обробка помилок; необроблені винятки автоматично поширюються до абонента, потім до абонента, що викликає, і так далі, доки вони не досягнуть інтерпретатора верхнього рівня, де про них повідомляється користувачеві в супроводі стека.

Однак для програмістів на C перевірка помилок завжди має бути явною. Усі функції в Python/C API можуть викликати винятки, якщо в документації до функції не вказано інше. Загалом, коли функція стикається з помилкою, вона встановлює виняток, відкидає будь-які посилання на об’єкти, якими вона володіє, і повертає індикатор помилки. Якщо не задокументовано інше, цей індикатор має значення `NULL` або `-1`, залежно від типу повернення функції. Кілька функцій повертають логічний результат true/false, де false вказує на помилку. Дуже небагато функцій не повертають явного індикатора помилки або мають неоднозначне значення, що повертається, і вимагають явного тестування помилок за допомогою `PyErr_Occurred()`. Ці винятки завжди чітко задокументовані.

Винятковий стан підтримується в потоковому сховищі (це еквівалентно використанню глобального сховища в непотоковій програмі). Потік може перебувати в одному з двох станів: сталася виняток чи ні. Для перевірки цього можна використати функцію `PyErr_Occurred()`: вона повертає запозичене посилання на об’єкт типу винятку, коли виняток стався, і `NULL` в іншому випадку. Існує кілька функцій для встановлення виняткового стану: `PyErr_SetString()` є найпоширенішою (хоча і не найзагальнішою) функцією для встановлення виняткового стану, а `PyErr_Clear()` очищає виняток стан.

Повний винятковий стан складається з трьох об’єктів (усі з яких можуть бути `NULL`): типу винятку, відповідного значення винятку та зворотного відстеження. Вони мають ті самі значення, що й результат Python для `sys.exc_info()`; однак вони не однакові: об’єкти Python представляють останній виняток, який обробляється оператором Python `try` … `except`, тоді як винятковий стан рівня C існує лише під час виключення передається між функціями C, доки він не досягне головного циклу інтерпретатора байт-коду Python, який піклується про його передачу до `sys.exc_info()` та друзів.

Зауважте, що, починаючи з Python 1.5, бажаним, потоково-безпечним способом доступу до виняткового стану з коду Python є виклик функції `sys.exc_info()`, яка повертає винятковий стан для кожного потоку для коду Python. Крім того, семантика обох способів доступу до виняткового стану була змінена таким чином, що функція, яка перехоплює виняток, збереже та відновить винятковий стан свого потоку, щоб зберегти винятковий стан свого викликаючого. Це запобігає поширеним помилкам у коді обробки виключень, спричинених невинною функцією, яка перезаписує виняток, що обробляється; це також зменшує часто небажане подовження тривалості життя для об’єктів, на які посилаються фрейми стека в трасуванні.

Як загальний принцип, функція, яка викликає іншу функцію для виконання певного завдання, повинна перевіряти, чи викликана функція викликала виняток, і якщо так, передати стан винятку її викликаючому. Він має відкидати будь-які посилання на об’єкти, якими він володіє, і повертати індикатор помилки, але не встановлювати інший виняток — який би перезаписував щойно викликаний виняток і втрачав важливу інформацію про точну причину помилки.

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 */
    }

Цей приклад представляє схвалене використання оператора `goto` у C! Він ілюструє використання `PyErr_ExceptionMatches()` і `PyErr_Clear()` для обробки конкретних винятків, а також використання `Py_XDECREF()` для утилізації власних посилань, які можуть бути `NULL` (зверніть увагу на `'X'` в назві; `Py_DECREF()` аварійно завершував би роботу, якщо зіткнутися з посиланням `NULL`). Щоб це працювало, важливо, щоб змінні, які використовуються для зберігання належних посилань, були ініціалізовані як `NULL`; аналогічно запропоноване значення, що повертається, ініціалізується як `-1` (помилка) і встановлюється як успішне лише після успішного останнього виклику.

## Вбудовування Python

Єдине важливе завдання, про яке мають турбуватися лише вбудовувачі (на відміну від авторів розширень) інтерпретатора Python, це ініціалізація та, можливо, фіналізація інтерпретатора Python. Більшість функцій інтерпретатора можна використовувати лише після ініціалізації інтерпретатора.

Основною функцією ініціалізації є `Py_Initialize()`. Це ініціалізує таблицю завантажених модулів і створює фундаментальні модулі `builtins`, `__main__` і `sys`. Він також ініціалізує шлях пошуку модуля (`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()`.

У більшості систем (зокрема, в Unix і Windows, хоча деталі дещо відрізняються), `Py_Initialize()` обчислює шлях пошуку модуля на основі свого найкращого припущення щодо розташування стандартного виконуваного файлу інтерпретатора Python, припускаючи, що бібліотека Python знаходиться у фіксованому місці відносно виконуваного файлу інтерпретатора Python. Зокрема, він шукає каталог під назвою `lib/pythonX.Y` відносно батьківського каталогу, де виконуваний файл під назвою `python` знайдено на шляху пошуку команд оболонки (змінна середовища `PATH`).

Наприклад, якщо виконуваний файл Python знайдено в `/usr/local/bin/python`, буде вважатися, що бібліотеки знаходяться в `/usr/local/lib/pythonX.Y`. (Насправді цей конкретний шлях також є «резервним» розташуванням, яке використовується, коли вздовж `PATH` не знайдено виконуваного файлу з назвою `python`.) Користувач може змінити цю поведінку, встановивши змінну середовища `PYTHONHOME`, або вставте додаткові каталоги перед стандартним шляхом, встановивши `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`).

Іноді бажано «деініціалізувати» Python. Наприклад, програма може захотіти почати спочатку (здійснити ще один виклик `Py_Initialize()`) або програма просто завершила роботу з Python і хоче звільнити пам’ять, виділену Python. Це можна зробити, викликавши `Py_FinalizeEx()`. Функція `Py_IsInitialized()` повертає істину, якщо Python зараз перебуває в ініціалізованому стані. Більше інформації про ці функції наведено в наступному розділі. Зауважте, що `Py_FinalizeEx()` не звільняє всю пам’ять, виділену інтерпретатором Python, напр. Пам’ять, виділена модулями розширення, наразі не може бути звільнена.

## Налагодження збірок

Python можна створити з кількома макросами, щоб увімкнути додаткові перевірки інтерпретатора та модулів розширення. Ці перевірки, як правило, додають велику кількість накладних витрат до середовища виконання, тому їх не ввімкнено за замовчуванням.

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.

На додаток до налагодження кількості посилань, описаного нижче, виконуються додаткові перевірки, див. Python Debug Build.

Визначення `Py_TRACE_REFS` увімкне трасування посилань (див. опцію `configure --with-trace-refs`). Коли визначено, круговий подвійний зв’язаний список активних об’єктів підтримується шляхом додавання двох додаткових полів до кожного `PyObject`. Також відстежуються загальні асигнування. Після виходу друкуються всі наявні посилання. (В інтерактивному режимі це відбувається після кожного оператора, виконаного інтерпретатором.)

Будь ласка, зверніться до `Misc/SpecialBuilds.txt` у дистрибутиві вихідних кодів Python для отримання більш детальної інформації.