Библиотека ctypes: Python и C вместе

Расширенные примеры и нестандартные случаи использования ctypes

Создание и использование битовых полей через ручное маскирование

C структуры с битовыми полями не поддерживаются ctypes напрямую. Однако можно эмулировать их с помощью обычных целых и масок. Пример для структуры с полями a (3 бита), b (5 бит).

import ctypes

class BitField(ctypes.Structure):
    _fields_ = [("data", ctypes.c_uint32)]

    @property
    def a(self):
        return (self.data >> 0) & 0x7  # 3 бита
    @a.setter
    def a(self, val):
        self.data = (self.data & ~0x7) | (val & 0x7)

    @property
    def b(self):
        return (self.data >> 3) & 0x1F  # 5 бит
    @b.setter
    def b(self, val):
        self.data = (self.data & ~(0x1F << 3)) | ((val & 0x1F) << 3)

b = BitField()
b.a = 5
b.b = 17
print(f"data = {b.data:#010x}")  # двоичный вид
print(f"a={b.a}, b={b.b}")

data = 0x0000008d
a=5, b=17

Работа с макросами offsetof и sizeof

ctypes предоставляет ctypes.sizeof() для получения размера типа, но offsetof нет. Реализуем его через вычисление смещения.

import ctypes

class Test(ctypes.Structure):
    _fields_ = [
        ("c", ctypes.c_char),
        ("i", ctypes.c_int),
        ("d", ctypes.c_double)
    ]

def offsetof(cls, field_name):
    # Создаём временный экземпляр и определяем адрес поля
    temp = cls()
    addr_struct = ctypes.addressof(temp)
    addr_field = ctypes.addressof(getattr(temp, field_name))
    return addr_field - addr_struct

print("Размер Test:", ctypes.sizeof(Test))
print("Смещение 'c':", offsetof(Test, 'c'))
print("Смещение 'i':", offsetof(Test, 'i'))
print("Смещение 'd':", offsetof(Test, 'd'))

Размер Test: 16
Смещение 'c': 0
Смещение 'i': 4
Смещение 'd': 8

Использование ctypes с расширенными числовыми типами (long long, size_t)

Для 64‑битных целых и указателей есть c_longlong, c_uint64, c_size_t. Пример вызова strtol с указателем на long.

import ctypes

libc = ctypes.CDLL("libc.so.6")
libc.strtol.argtypes = [ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_int]
libc.strtol.restype = ctypes.c_long

endptr = ctypes.c_char_p()
result = libc.strtol(b"12345abc", ctypes.byref(endptr), 10)
print("Число:", result)
print("Оставшаяся строка:", endptr.value.decode())

Число: 12345
Оставшаяся строка: abc

Создание собственных указателей и работа с c_void_p

Иногда нужно передать в C функцию произвольный указатель. c_void_p подходит для любого адреса. Пример с функцией memset.

import ctypes

libc = ctypes.CDLL("libc.so.6")
libc.memset.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_size_t]
libc.memset.restype = ctypes.c_void_p

# Буфер из 10 байт
buf = (ctypes.c_byte * 10)()
libc.memset(buf, 0xFF, len(buf))
print(list(buf))  # [255, 255, 255, 255, 255, 255, 255, 255, 255, 255]

[255, 255, 255, 255, 255, 255, 255, 255, 255, 255]

Динамическое создание структур с неизвестным размером (гибкие массивы)

C позволяет структуры с последним полем‑массивом без указания размера. ctypes может эмулировать это, используя _length_ или динамическое создание класса.

import ctypes

class Flexible(ctypes.Structure):
    _fields_ = [("len", ctypes.c_int), ("data", ctypes.c_char * 0)]  # нулевой массив

# Создаём экземпляр с дополнительной памятью
# Используем ctypes.create_string_buffer с подходящим размером
buf_size = ctypes.sizeof(Flexible) + 10  # 10 дополнительных байт
buf = ctypes.create_string_buffer(buf_size)
flex = ctypes.cast(buf, ctypes.POINTER(Flexible))[0]
flex.len = 10
# Заполняем data через ctypes.memmove
ctypes.memmove(flex.data, b"HelloWorld", 10)
print(ctypes.string_at(flex.data, 10))  # b'HelloWorld'

b'HelloWorld'

Работа с функциями переменного числа аргументов (vararg)

ctypes не поддерживает vararg напрямую, но можно использовать низкоуровневые механизмы, например, ctypes.CFUNCTYPE с ... (только в Python 3.12+). Ниже показан обходной путь через явную передачу аргументов упакованными в массив.

import ctypes

libc = ctypes.CDLL("libc.so.6")
# printf с одним известным аргументом
libc.printf.argtypes = [ctypes.c_char_p]
libc.printf.restype = ctypes.c_int

# Нормальный вызов с одним аргументом
libc.printf(b"Hello\n")
# Для нескольких аргументов придётся использовать ctypes.cast и ручное управление стеком (сложно – не рекомендуется).
# Более простой способ – использовать модуль syscall или написать C обёртку.

Использование ctypes с потоками и глобальной блокировкой интерпретатора (GIL)

При вызове C функций, которые могут блокироваться (например, сокетные операции), интерпретатор отпускает GIL. ctypes делает это автоматически. Однако при ручном создании потоков с C функциями может потребоваться явное освобождение GIL с помощью ctypes.pythonapi.PyGILState_Ensure и аналогичных – это продвинутая техника.

import ctypes
import threading

libc = ctypes.CDLL("libc.so.6")
libc.usleep.argtypes = [ctypes.c_uint32]
libc.usleep.restype = ctypes.c_int

def sleep_work(seconds):
    libc.usleep(int(seconds * 1_000_000))
    print(f"Вызов завершён через {seconds} сек")

t = threading.Thread(target=sleep_work, args=(1.5,))
t.start()
print("Главный поток продолжает работу")
t.join()

Главный поток продолжает работу
Вызов завершён через 1.5 сек

Динамическая загрузка библиотек по имени без указания пути

Иногда нужно загрузить библиотеку из стандартного пути. ctypes ищет библиотеку по стандартным правилам ОС. На Linux можно использовать ctypes.util.find_library.

import ctypes
import ctypes.util

lib_path = ctypes.util.find_library("c")
if lib_path:
    libc = ctypes.CDLL(lib_path)
    print(f"Загружена: {lib_path}")
else:
    print("Библиотека не найдена")

Загружена: libc.so.6