CPython C API: 5 вопросов на собеседовании17.03.2025 22:16

06bd0a90602721464dc320f26ff12002.jpg

Привет, Хабр!

Сегодня разберём несколько вопросов на собеседованиях, связанных с устройством CPython и его C API.

Вопрос 1: как Python взаимодействует с C через PyObject?

В CPython каждый объект — это C‑структура, унаследованная от базовой: 

typedef struct _object {
    Py_ssize_t ob_refcnt;         // Счётчик ссылок
    struct _typeobject *ob_type;  // Указатель на тип объекта
} PyObject;

Счётчик ссылок отвечает за управление жизненным циклом объекта. Каждый новый указатель увеличивает счётчик, а при удалении — уменьшается. Когда он достигает нуля, объект уничтожается.

Указатель на тип позволяет динамически вызывать методы. Благодаря этому можно, например, вызвать repr(obj), и CPython найдёт нужную функцию tp_repr в таблице виртуальных функций типа объекта.

Каждый тип в Python описывается структурой PyTypeObject, которая содержит информацию о типе, включая функции для операций над объектами: 

typedef struct _typeobject {
    PyVarObject_HEAD_INIT(NULL, 0)
    const char *tp_name;        // Имя типа
    reprfunc tp_repr;           // Функция представления объекта
    // Другие функции, например, dealloc, getattr и т.д.
} PyTypeObject;

Когда вы вызываете, например, PyObject_Repr(obj), происходит:

  1. Извлечение ob_type объекта.

  2. Вызов функции tp_repr, реализованной для данного типа.

Чтобы создать новый тип, наследуемый от PyObject, используют макрос PyObject_HEAD для добавления обязательных полей: 

#include 

typedef struct {
    PyObject_HEAD
    char *data;   // Дополнительное поле для хранения данных
} MyStringObject;

static PyObject* MyString_repr(MyStringObject *self) {
    return PyUnicode_FromFormat("MyString: %s", self->data);
}

static PyTypeObject MyStringType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "mymodule.MyString",
    .tp_basicsize = sizeof(MyStringObject),
    .tp_flags = Py_TPFLAGS_DEFAULT,
    .tp_repr = (reprfunc)MyString_repr,
};

static PyModuleDef mymodule = {
    PyModuleDef_HEAD_INIT,
    "mymodule",
    "Пример модуля с собственным типом",
    -1,
};

PyMODINIT_FUNC PyInit_mymodule(void) {
    PyObject *m;
    if (PyType_Ready(&MyStringType) < 0)
        return NULL;
    m = PyModule_Create(&mymodule);
    if (m == NULL)
        return NULL;
    Py_INCREF(&MyStringType);
    PyModule_AddObject(m, "MyString", (PyObject *)&MyStringType);
    return m;
}

Ключ к стабильности — правильное управление ссылками с помощью Py_INCREF и Py_DECREF. Ошибки здесь могут привести к утечкам памяти или завершению программы.

Пример функции освобождения памяти: 

#include 

typedef struct {
    PyObject_HEAD
    char *data;
} MyStringObject;

static PyObject* MyString_repr(MyStringObject *self) {
    // Создаем строку вида "MyString: <данные>"
    return PyUnicode_FromFormat("MyString: %s", self->data);
}

static PyTypeObject MyStringType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "mymodule.MyString",
    .tp_basicsize = sizeof(MyStringObject),
    .tp_flags = Py_TPFLAGS_DEFAULT,
    .tp_repr = (reprfunc)MyString_repr,
    // Здесь можно добавить больше функций, например, dealloc, getattr и т.д.
};

static PyModuleDef mymodule = {
    PyModuleDef_HEAD_INIT,
    "mymodule",
    "Пример модуля с собственным типом",
    -1,
};

PyMODINIT_FUNC PyInit_mymodule(void) {
    PyObject *m;
    if (PyType_Ready(&MyStringType) < 0)
        return NULL;
    m = PyModule_Create(&mymodule);
    if (m == NULL)
        return NULL;
    Py_INCREF(&MyStringType);
    PyModule_AddObject(m, "MyString", (PyObject *)&MyStringType);
    return m;
}

Вопрос 2: какая роль Py_INCREF () и Py_DECREF () в C-расширениях?

CPython использует счётчики ссылок для управления памятью. Каждая функция, работающая с объектами, должна учитывать, сколько ссылок на объект существует, чтобы избежать утечек или преждевременного уничтожения.

  • Py_INCREF (obj): увеличивает счётчик ссылок объекта obj на 1. Это сигнал системе, что объект ещё используется.

  • Py_DECREF (obj): уменьшает счётчик ссылок. Если значение становится 0, вызывается деструктор объекта и память освобождается.

Неправильное использование этих функций может привести к двум основным проблемам:

  1. Утечки памяти: если забыть вызвать Py_DECREF (), объект никогда не будет уничтожен, что приводит к постепенному росту потребления памяти.

  2. Обращение к освобождённой памяти: если Py_DECREF () вызван слишком рано, объект может быть уничтожен, а последующие обращения к нему вызовут ошибки.

Рассмотрим функцию, которая создаёт объект, использует его, а затем освобождает: 

static PyObject* create_and_use_object(void) {
    // Создаем новый Python-объект (целое число 42)
    PyObject *obj = PyLong_FromLong(42);
    if (!obj) {
        // Если произошла ошибка создания объекта, возвращаем NULL
        return NULL;
    }

    // Предположим, что мы передаем этот объект куда-то ещё
    // Здесь нам может понадобиться увеличить счётчик ссылок, если объект будет использоваться параллельно
    Py_INCREF(obj);  // Дополнительная ссылка, гарантирующая, что obj не будет уничтожен

    // ... Выполняем какие-либо операции с объектом ...

    // После завершения работы, снимаем дополнительную ссылку
    Py_DECREF(obj);

    // Возвращаем объект; важно помнить, что возвращаемая ссылка уже должна быть корректно обработана вызывающей стороной
    return obj;
}

Каждая операция с объектом сопровождается корректным управлением ссылками.

Вопрос 3: напишите минимальный модуль на C, который экспортирует функцию add (a, b).

Задача создать минимальный модуль, который предоставляет функцию сложения двух целых чисел.

Исходный код модуля: 

#include 

// Функция, реализующая сложение двух целых чисел
static PyObject* py_add(PyObject *self, PyObject *args) {
    int a, b;
    // Ожидаем два целых числа ("ii" означает два типа int)
    if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
        // Если аргументы не соответствуют формату, возвращаем NULL для генерации исключения
        return NULL;
    }
    int result = a + b;
    // Возвращаем результат, обернутый в Python-объект типа int
    return PyLong_FromLong(result);
}

// Список методов, экспортируемых модулем
static PyMethodDef ModuleMethods[] = {
    {"add", py_add, METH_VARARGS, "Возвращает сумму двух целых чисел"},
    {NULL, NULL, 0, NULL}  // Завершающий элемент массива
};

// Описание модуля
static struct PyModuleDef addmodule = {
    PyModuleDef_HEAD_INIT,
    "addmodule",         // Имя модуля
    "Минимальный модуль для сложения чисел",  // Докстринг модуля
    -1,                  // Использование глобального состояния модуля
    ModuleMethods
};

// Функция инициализации модуля
PyMODINIT_FUNC PyInit_addmodule(void) {
    return PyModule_Create(&addmodule);
}

Чтобы скомпилировать модуль, создаем файл setup.py: 

from setuptools import setup, Extension

module = Extension('addmodule', sources=['addmodule.c'])

setup(
    name='addmodule',
    version='1.0',
    description='Минимальный модуль для сложения чисел на C',
    ext_modules=[module],
)

Компиляция и установка производится следующими командами: 

python setup.py build
python setup.py install

После установки можно импортировать модуль в Python и проверить работу функции: 

import addmodule
print(addmodule.add(10, 20))  # Должно вывести 30

Вопрос 4: как работает механизм Buffer Protocol и memoryview в CPython?

Buffer Protocol — это соглашение, позволяющее объектам предоставлять прямой доступ к своим внутренним данным (байтовым массивам, например), не выполняя лишнего копирования. Объекты, поддерживающие этот протокол (например, bytes, bytearray, array.array), могут быть использованы для обмена данными между разными компонентами, работающими на низком уровне.

Объект memoryview позволяет создать представление над буфером, полученным от объекта, поддерживающего Buffer Protocol. С помощью memoryview можно:

  • Читать данные без их копирования;

  • Модифицировать данные, если исходный объект поддерживает запись;

  • Работать с срезами и представлениями многомерных данных.

Пример: 

# Создаем изменяемый байтовый массив
data = bytearray(b"CPython Buffer")
# Получаем объект memoryview для доступа к внутренним данным
mv = memoryview(data)
# Изменяем данные напрямую через memoryview
mv[0] = ord('c')
print(data)  # Вывод: bytearray(b'cPython Buffer')

Иногда необходимо создать свой тип, поддерживающий Buffer Protocol. Пример реализации на C: 

#include 

typedef struct {
    PyObject_HEAD
    char *buffer;
    Py_ssize_t size;
} BufferObject;

// Функция заполнения структуры Py_buffer информацией о буфере
static int Buffer_getbuffer(BufferObject *self, Py_buffer *view, int flags) {
    return PyBuffer_FillInfo(view, (PyObject *)self, self->buffer, self->size, 0, flags);
}

// Функция освобождения буфера (в простом случае ничего не требуется)
static void Buffer_releasebuffer(BufferObject *self, Py_buffer *view) {
    // Здесь можно добавить код для освобождения ресурсов, если это необходимо
}

// Структура, описывающая методы работы с буфером
static PyBufferProcs Buffer_as_buffer = {
    (getbufferproc)Buffer_getbuffer,
    (releasebufferproc)Buffer_releasebuffer
};

static PyTypeObject BufferType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "mymodule.Buffer",
    .tp_basicsize = sizeof(BufferObject),
    .tp_flags = Py_TPFLAGS_DEFAULT,
    .tp_as_buffer = &Buffer_as_buffer,
    // Дополнительные методы и атрибуты можно добавить при необходимости
};

static PyModuleDef mymodule = {
    PyModuleDef_HEAD_INIT,
    "mymodule",
    "Модуль с примером реализации Buffer Protocol",
    -1,
};

PyMODINIT_FUNC PyInit_mymodule(void) {
    PyObject *m;
    if (PyType_Ready(&BufferType) < 0)
        return NULL;
    m = PyModule_Create(&mymodule);
    if (m == NULL)
        return NULL;
    Py_INCREF(&BufferType);
    PyModule_AddObject(m, "Buffer", (PyObject *)&BufferType);
    return m;
}

Создаем тип Buffer, который предоставляет доступ к своему внутреннему буферу. Функция PyBuffer_FillInfo заполняет структуру Py_buffer, что позволяет объектам, таким как memoryview, работать с данными напрямую.

Вопрос 5: почему нельзя просто вызвать free (ptr) в C-коде, работающем с объектами Python?

CPython использует свою систему аллокации и систему счётчиков ссылок для управления жизненным циклом объектов. При создании объектов память выделяется через специализированные аллокаторы, а освобождение происходит не напрямую через стандартный free (), а через внутренние механизмы CPython.

Итак, основные причины:

  1. Нарушение логики reference counting:
    Если вызвать free (ptr) напрямую, не будет выполнено уменьшение счётчика ссылок. Это приведёт к тому, что другие части кода могут продолжать обращаться к уже освобождённой памяти, вызывая аварийное завершение программы.

  2. Несовместимость с внутренними аллокаторами:
    Объекты Python выделяются не просто через malloc/free, а через специализированные функции (например, PyObject_Malloc). Стандартный free () может нарушить внутреннюю логику работы аллокатора, что приведёт к повреждению памяти.

  3. Правильное завершение объекта:
    При вызове Py_DECREF () не только уменьшается счётчик ссылок, но и вызывается деструктор объекта (если он определён), освобождаются внутренние ресурсы, вызывается метод del() и выполняется другая необходимая логика очистки.

Пример неправильного подхода: 

PyObject *obj = PyLong_FromLong(123);
// Некорректное освобождение памяти – обход системы управления ссылками CPython
free(obj);  // Это приведет к неопределенному поведению и аварийному завершению программы!

Правильный способ освобождения памяти:

Всегда используйте встроенные механизмы CPython: 

PyObject *obj = PyLong_FromLong(123);
// Работа с объектом...
Py_DECREF(obj);  // Правильное освобождение, которое учитывает все внутренние зависимости

free(ptr) не только не учитывает логику reference counting, но и может привести к ошибкам, которые крайне сложно отладить.

Спасибо за внимание, и удачи на собеседование!

Статья подготовлена для будущих студентов специализации «Python Developer». Хорошая новость: в рамках этого курса студенты получат поддержку карьерного центра Otus. Узнать подробнее

© Habrahabr.ru