python - c_int - Cómo empacar y desempaquetar usando ctypes(Estructura<-> str)

ctypes python 3

Question

Esta podría ser una pregunta tonta, pero no pude encontrar una buena respuesta en los documentos ni en ninguna parte.

Si uso struct para definir una estructura binaria, la estructura tiene 2 métodos simétricos para la serialización y la deserialización (empacar y descomprimir), pero parece que ctypes no tiene una forma directa de hacerlo. Aquí está mi solución, que se siente mal:

from ctypes import *

class Example(Structure):
    _fields_ = [
        ("index", c_int),
        ("counter", c_int),
        ]

def Pack(ctype_instance):
    buf = string_at(byref(ctype_instance), sizeof(ctype_instance))
    return buf

def Unpack(ctype, buf):
    cstring = create_string_buffer(buf)
    ctype_instance = cast(pointer(cstring), POINTER(ctype)).contents
    return ctype_instance

if __name__ == "__main__":
    e = Example(12, 13)
    buf = Pack(e)
    e2 = Unpack(Example, buf)
    assert(e.index == e2.index)
    assert(e.counter == e2.counter)
    # note: for some reason e == e2 is False...

Answer 1

Eche un vistazo a este enlace en i / o binario en python:

http://www.dabeaz.com/blog/2009/08/python-binary-io-handling.html

En base a esto, puede simplemente escribir lo siguiente para leer desde un búfer (no solo archivos):

g = open("foo","rb")
q = Example()
g.readinto(q)

Escribir es simplemente:

g.write(q)

Lo mismo para usar enchufes:

s.send(q)

y

s.recv_info(q)

Hice algunas pruebas con pack / unpack y ctypes y este enfoque es el más rápido excepto para escribir directamente en C

Answer 2

Probado en Python3

e = Example(12, 13)
serialized = bytes(e)
deserialized = Example.from_buffer_copy(serialized)

Answer 3

El wiki de PythonInfo tiene una solución para esto.

FAQ: ¿Cómo copio bytes a Python desde un ctypes.Structure?

def send(self):
    return buffer(self)[:]

FAQ: ¿Cómo copio bytes a ctypes.Structure de Python?

def receiveSome(self, bytes):
    fit = min(len(bytes), ctypes.sizeof(self))
    ctypes.memmove(ctypes.addressof(self), bytes, fit)

Su send es el equivalente (más o menos) del pack , y receiveSome es una especie de pack_into . Si tiene una situación "segura" en la que está desempacando en una estructura del mismo tipo que el original, puede memmove(addressof(y), buffer(x)[:], sizeof(y)) como memmove(addressof(y), buffer(x)[:], sizeof(y)) para copiar x en y . Por supuesto, es probable que tenga una variable como segundo argumento, en lugar de un embalaje literal de x .