Разработка C-модулей для интерпретатора Python

Расширенные примеры C-расширений

1. Обработка строк и управление памятью

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

static PyObject* example_len(PyObject* self, PyObject* args) {
    const char* s;
    if (!PyArg_ParseTuple(args, "s", &s))
        return NULL;
    return PyLong_FromSize_t(strlen(s));
}

import example
print(example.len('Hello'))  # 5

Важно: строка копируется в C-буфер; для больших данных используйте s# (с длиной).

2. Создание класса с методами

Определение нового типа Counter:

typedef struct {
    PyObject_HEAD
    long count;
} Counter;

static int Counter_init(Counter* self, PyObject* args, PyObject* kwds) {
    self->count = 0;
    return 0;
}

static PyObject* Counter_increment(Counter* self, PyObject* args) {
    self->count++;
    return PyLong_FromLong(self->count);
}

static PyMethodDef Counter_methods[] = {
    {"increment", (PyCFunction)Counter_increment, METH_NOARGS, "Increment counter"},
    {NULL}
};

static PyTypeObject CounterType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "example.Counter",
    .tp_basicsize = sizeof(Counter),
    .tp_itemsize = 0,
    .tp_flags = Py_TPFLAGS_DEFAULT,
    .tp_methods = Counter_methods,
    .tp_init = (initproc)Counter_init,
};

Регистрация типа в модуле:

PyMODINIT_FUNC PyInit_example(void) {
    PyObject* m = PyModule_Create(&examplemodule);
    if (PyType_Ready(&CounterType) < 0) return NULL;
    Py_INCREF(&CounterType);
    PyModule_AddObject(m, "Counter", (PyObject*)&CounterType);
    return m;
}

c = example.Counter()
print(c.increment())  # 1
print(c.increment())  # 2

3. Работа с GIL в многопоточных расширениях

Для выполнения длительных C-вычислений без блокировки GIL используйте Py_BEGIN_ALLOW_THREADS / Py_END_ALLOW_THREADS:

static PyObject* compute_heavy(PyObject* self, PyObject* args) {
    long n;
    if (!PyArg_ParseTuple(args, "l", &n)) return NULL;
    long result = 0;
    Py_BEGIN_ALLOW_THREADS
    // Долгий расчёт (n итераций)
    for (long i = 0; i < n; i++) {
        result += i;
    }
    Py_END_ALLOW_THREADS
    return PyLong_FromLong(result);
}

Важно: внутри освобождённого блока нельзя вызывать Python API, иначе возникнет deadlock.

4. Обработка исключений Python

Установка собственного исключения:

static PyObject* ExampleError = NULL;

static PyObject* divide(PyObject* self, PyObject* args) {
    double a, b;
    if (!PyArg_ParseTuple(args, "dd", &a, &b)) return NULL;
    if (b == 0.0) {
        PyErr_SetString(ExampleError, "Division by zero");
        return NULL;
    }
    return PyFloat_FromDouble(a / b);
}

PyMODINIT_FUNC PyInit_example(void) {
    PyObject* m = PyModule_Create(&examplemodule);
    ExampleError = PyErr_NewException("example.ExampleError", NULL, NULL);
    Py_INCREF(ExampleError);
    PyModule_AddObject(m, "ExampleError", ExampleError);
    return m;
}

import example
try:
    example.divide(10, 0)
except example.ExampleError as e:
    print(e)  # Division by zero

5. Работа с последовательностями (списки, кортежи)

Функция, суммирующая элементы списка:

static PyObject* sum_list(PyObject* self, PyObject* args) {
    PyObject* list;
    if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &list))
        return NULL;
    Py_ssize_t len = PyList_Size(list);
    double total = 0.0;
    for (Py_ssize_t i = 0; i < len; i++) {
        PyObject* item = PyList_GetItem(list, i);
        if (PyFloat_Check(item))
            total += PyFloat_AsDouble(item);
        else if (PyLong_Check(item))
            total += (double)PyLong_AsLong(item);
        else {
            PyErr_SetString(PyExc_TypeError, "List items must be numbers");
            return NULL;
        }
    }
    return PyFloat_FromDouble(total);
}

print(example.sum_list([1, 2.5, 3]))  # 6.5