Расширение возможностей Python внешними C модулями

Расширенные примеры интеграции C и Python

1. Работа с C-структурами через ctypes

// point.h
typedef struct {
    double x;
    double y;
} Point;

double distance(Point *a, Point *b);

// point.c
#include <math.h>
#include "point.h"
double distance(Point *a, Point *b) {
    double dx = a->x - b->x;
    double dy = a->y - b->y;
    return sqrt(dx*dx + dy*dy);
}

Компиляция библиотеки: gcc -shared -o libpoint.so -fPIC point.c -lm

# Python код
import ctypes

lib = ctypes.CDLL("./libpoint.so")

class Point(ctypes.Structure):
    _fields_ = [("x", ctypes.c_double),
                ("y", ctypes.c_double)]

lib.distance.argtypes = [ctypes.POINTER(Point), ctypes.POINTER(Point)]
lib.distance.restype = ctypes.c_double

a = Point(0.0, 0.0)
b = Point(3.0, 4.0)
result = lib.distance(ctypes.byref(a), ctypes.byref(b))
print(f"Расстояние: {result}")  # 5.0

Расстояние: 5.0

Пояснение:

Структура Point объявлена в Python как класс, наследующий ctypes.Structure. Поле _fields_ отображает имена и типы C. Для передачи указателей используется ctypes.byref(). Важно следить за выравниванием: если структура содержит #pragma pack, нужно задать _pack_.

2. Манипуляция массивами в CFFI с возвратом большого объёма данных

# build.py
from cffi import FFI
ffi = FFI()
ffi.cdef("""
    int* generate_array(int size);
    void free_array(int* arr);
""")
ffi.set_source("_array_example",
    """
    #include <stdlib.h>
    int* generate_array(int size) {
        int* arr = (int*)malloc(size * sizeof(int));
        for(int i=0; i<size; i++) arr[i] = i*i;
        return arr;
    }
    void free_array(int* arr) { free(arr); }
    """)
ffi.compile()

# usage.py
from _array_example import ffi, lib

size = 10
ptr = lib.generate_array(size)
arr = ffi.unpack(ptr, size)  # преобразует в список Python
print(arr[:5])
lib.free_array(ptr)  # обязательно освободить память

[0, 1, 4, 9, 16]

Функция ffi.unpack создаёт временный список. Для работы с огромными массивами удобнее создать ffi.buffer или обертку в numpy с помощью ffi.from_buffer.

3. Использование Cython для вызова C-функции из библиотеки OpenSSL (хеширование)

# hash.pyx
from libc.stdlib cimport malloc, free
from libc.string cimport memcpy

cdef extern from "openssl/md5.h":
    int MD5(const unsigned char *d, unsigned long n, unsigned char *md)

def md5_hash(bytes data):
    cdef unsigned char[16] result
    cdef unsigned char *buf = data
    MD5(buf, len(data), result)
    return bytes(result[:16])

# setup.py
from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("hash.pyx"),
    libraries = ["crypto"]
)

>>> import hash
>>> hash.md5_hash(b"Hello")
b'\x8b\x1a...'

В Cython используется cdef extern для объявления C-функции. Ссылка на библиотеку libcrypto добавляется в setup.py через libraries. Память под результат выделяется на стеке (массив фиксированного размера), что ускоряет выполнение.

4. Передача строк и Callback-функций через PyBind11

# callback_example.cpp
#include <pybind11/pybind11.h>
#include <pybind11/functional.h>
#include <string>

namespace py = pybind11;

void repeat_twice(const std::string &msg, py::function callback) {
    std::string result = msg + " " + msg;
    callback(result);
}

PYBIND11_MODULE(callback_mod, m) {
    m.def("repeat_twice", &repeat_twice, "Calls callback with repeated string");
}

# Python
import callback_mod

def my_print(s):
    print("Из C++:", s)

callback_mod.repeat_twice("Привет", my_print)

Из C++: Привет Привет

PyBind11 автоматически преобразует std::string в Python str и py::function в вызываемый объект. Включение заголовка pybind11/functional.h обязательно для поддержки колбэков. Производительность выше, чем через ctypes, но требует компиляции.

5. Прямая работа с Python C API (ручное расширение) – пример модуля со счётчиком

// counter.c
#include <Python.h>

static PyObject* increment(PyObject *self, PyObject *args) {
    int val;
    if (!PyArg_ParseTuple(args, "i", &val))
        return NULL;
    return PyLong_FromLong(val + 1);
}

static PyMethodDef CounterMethods[] = {
    {"increment", increment, METH_VARARGS, "Increment an integer"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef countermodule = {
    PyModuleDef_HEAD_INIT,
    "counter",
    NULL,
    -1,
    CounterMethods
};

PyMODINIT_FUNC PyInit_counter(void) {
    return PyModule_Create(&countermodule);
}

# setup.py
from setuptools import setup, Extension

module = Extension('counter', sources=['counter.c'])
setup(name='counter', ext_modules=[module])

>>> import counter
>>> counter.increment(5)
6

Это «классический» способ, требующий ручного управления ссылками и подсчётом объектов. Ошибка в коде C может привести к падению интерпретатора. Используется, когда необходима максимальная интеграция с Python (например, создание собственных типов).