Работа с динамическими библиотеками DLL/so в языке Python для взаимодействия с кодом на C и C++

Расширенные примеры работы с динамическими библиотеками

Пример 1: Передача массивов в функцию C через ctypes (с обработкой numpy)

Часто требуется передать большой массив чисел в C-функцию. Используем numpy.ctypes для получения указателя на данные.

import numpy as np
from ctypes import CDLL, c_double, c_int

lib = CDLL('./mystuff.so')
lib.process_array.argtypes = [POINTER(c_double), c_int]
lib.process_array.restype = None

data = np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float64)
ptr = data.ctypes.data_as(POINTER(c_double))
lib.process_array(ptr, len(data))
print(data)  # массив будет изменён in-place

Результат (вывод изменённого массива):

[2.0, 4.0, 6.0, 8.0]

Пояснение: C-функция process_array удваивает каждый элемент. Использование POINTER(c_double) позволяет передать указатель на буфер numpy без копирования.

Пример 2: Регистрация callback-функции Python в C-библиотеке (ctypes + ctypes.CFUNCTYPE)

Допустим, C-библиотека ожидает указатель на функцию-обработчик. Python может передать свою функцию с помощью CFUNCTYPE.

from ctypes import CDLL, CFUNCTYPE, c_int

# Предположим, в библиотеке определена функция:
# void register_callback(void (*f)(int));

CALLBACK = CFUNCTYPE(None, c_int)
lib = CDLL('./callbacks.dll')
lib.register_callback.argtypes = [CALLBACK]
lib.register_callback.restype = None

def my_callback(value):
    print(f"Callback called with {value}")

callback_func = CALLBACK(my_callback)
lib.register_callback(callback_func)
# Далее C-код может вызывать my_callback

Результат (при вызове из C):

Callback called with 42

Важно: объект callback_func должен существовать, пока библиотека может его использовать. Иначе Python garbage collector удалит его, что приведёт к краху.

Пример 3: Создание класса C++ с методами и свойствами через pybind11

Покажем, как обернуть простой класс Counter с конструктором, методом и свойством.

#include <pybind11/pybind11.h>

class Counter {
public:
    Counter(int start) : count(start) {}
    void increment(int step = 1) { count += step; }
    int get_count() const { return count; }
private:
    int count;
};

namespace py = pybind11;
PYBIND11_MODULE(counter, m) {
    py::class_<Counter>(m, "Counter")
        .def(py::init<int>())
        .def("increment", &Counter::increment, py::arg("step") = 1)
        .def("get_count", &Counter::get_count)
        .def_property_readonly("count", &Counter::get_count);
}

Сборка аналогично примеру выше. Использование в Python:

import counter
c = counter.Counter(10)
c.increment(5)
print(c.count)  # 15

Результат:

15

Обратите внимание: def_property_readonly создаёт атрибут только для чтения. Для изменяемых свойств используется def_property.

Пример 4: Оптимизация цикла с помощью Cython и внешней математической библиотеки

Допустим, нужно быстро вычислить сумму синусов большого массива. Используем Cython с вызовом sin из libm.

# fast_sum.pyx
cdef extern from "math.h" nogil:
    double sin(double x)

def fast_sin_sum(double[:] arr):
    cdef Py_ssize_t i
    cdef double s = 0.0
    for i in range(arr.shape[0]):
        s += sin(arr[i])
    return s

Для компиляции потребуется указать библиотеку math при линковке (в setup.py):

from setuptools import setup
from Cython.Build import cythonize

setup(ext_modules=cythonize(
    'fast_sum.pyx',
    libraries=['m']  # линковка с libm
))

Тест:

import numpy as np
import fast_sum
data = np.linspace(0, np.pi, 1000000, dtype=np.float64)
print(fast_sum.fast_sin_sum(data))

Результат (приблизительное значение):

1999999.9999999998

Cython автоматически использует быстрый доступ к памяти double[:] и освобождает GIL (nogil), что даёт почти скорость C.