El módulo ctypes es una herramienta esencial en la biblioteca estándar de Python que permite la integración con código escrito en C. A diferencia de las extensiones tradicionales de C para Python, ctypes no requiere compilación para conectar ambos lenguajes, ya que permite llamar directamente a funciones dentro de bibliotecas compartidas como archivos .so en Linux o .dll en Windows.

1. Carga de bibliotecas compartidas

Para interactuar con funciones externas, el primer paso es cargar la biblioteca en el espacio de memoria de Python. La clase utilizada depende de la convención de llamada de la plataforma.

Entornos Unix (Linux y macOS)

En sistemas basados en POSIX, se utiliza habitualmente CDLL para cargar bibliotecas que siguen la convención de llamada estándar de C.

import ctypes
from ctypes.util import find_library

# Localizar y cargar la biblioteca estándar de C
ruta_libc = find_library('c')
libreria_c = ctypes.CDLL(ruta_libc)

# Ejemplo: Llamada a la función 'abs' de C
resultado = libreria_c.abs(-50)
print(f"Resultado desde C: {resultado}")

Entornos Windows

Windows ofrece windll para bibliotecas que utilizan stdcall y cdll para aquellas con cdecl.

import ctypes

# Carga de una biblioteca del sistema
user_lib = ctypes.windll.user32
# Ejecución de una ventana de alerta simple
user_lib.MessageBoxW(0, "Integración exitosa", "Python y C", 1)

2. Mapeo de tipos de datos

Para que la comunicación sea efectiva, Python debe representar los datos de una forma que el código C pueda interpretar. ctypes proporciona tipos envoltorios específicos:

3. Definición de Estructuras y Uniones

Cuando el código C requiere tipos complejos, podemos definirlos en Python heredando de ctypes.Structure o ctypes.Union. Es obligatorio definir el atributo _fields_.

import ctypes

# Definición de una estructura para representar un vector 3D
class Vector3D(ctypes.Structure):
    _fields_ = [
        ("posX", ctypes.c_double),
        ("posY", ctypes.c_double),
        ("posZ", ctypes.c_double)
    ]

# Inicialización de la estructura
posicion = Vector3D(1.5, 3.0, 4.5)
print(f"Coordenadas: {posicion.posX}, {posicion.posY}, {posicion.posZ}")

4. Configuración de funciones: argtypes y restype

Por defecto, ctypes asume que las funciones devuelven un entero (int) y no verifica los tipos de entrada. Para evitar errores de memoria o segmentación, es una buena práctica definir explícitamente la firma de la función.

import ctypes

lib_matematica = ctypes.CDLL("./mi_biblioteca.so")

# Configurar tipos para una función hipotética 'calcular_area'
# float calcular_area(int radio, float pi_valor)
lib_matematica.calcular_area.argtypes = [ctypes.c_int, ctypes.c_float]
lib_matematica.calcular_area.restype = ctypes.c_float

area = lib_matematica.calcular_area(10, 3.14159)

5. Implementación de Callbacks

Es posible pasar funciones de Python a C como punteros de función (callbacks). Esto es útil para algoritmos de ordenamiento o gestión de eventos.

import ctypes

# Definir el prototipo del callback: devuelve int, recibe dos punteros a int
PROTO_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int))

def comparador_python(ptr_a, ptr_b):
    a, b = ptr_a.contents.value, ptr_b.contents.value
    return (a > b) - (a < b)

# Convertir la función Python al formato C
callback_c = PROTO_CALLBACK(comparador_python)

6. Gestión de Memoria y Punteros

El manejo de punteros es fundamental cuando se trabaja con C. ctypes permite obtener la dirección de un objeto o crear búferes mutables.

Paso por referencia

Si una función de C modifica un argumento, debemos usar byref() o pointer().

import ctypes

valor = ctypes.c_int(100)
# Supongamos una función C: void incrementar(int *n)
# libreria.incrementar(ctypes.byref(valor))

Búferes de memoria

Para cadenas de caracteres que serán modificadas en C, se utiliza create_string_buffer.

import ctypes

# Crear un búfer de 20 bytes inicializado con texto
bufer_datos = ctypes.create_string_buffer(b"Datos iniciales", 20)
print(f"Contenido: {bufer_datos.raw}")

El uso correcto de ctypes exige una comprensión clara de cómo se organizan los datos en memoria en C. Aunque es más flexible que escribir anvoltorios manuales en C API, requiere rigor en la definición de tipos para evitar cierres inesperados del intérprete de Python.