¿Hay alguna manera de definir convenientemente una estructura tipo C en Python? Estoy cansado de escribir cosas como:

class MyStruct():
    def __init__(self, field1, field2, field3):
        self.field1 = field1
        self.field2 = field2
        self.field3 = field3

Utilice una tupla con nombre , que se agregó a módulo de colecciones en la biblioteca estándar en Python 2.6. También es posible usar la tupla llamada Raymond Hettinger receta de si necesita admitir Python 2.4.

Es bueno para su ejemplo básico, pero también cubre un montón de casos extremos que podría encontrar más tarde también. Su fragmento anterior se escribiría como:

from collections import namedtuple
MyStruct = namedtuple("MyStruct", "field1 field2 field3")

El tipo recién creado se puede usar así:

m = MyStruct("foo", "bar", "baz")

También puede usar argumentos con nombre:

m = MyStruct(field1="foo", field2="bar", field3="baz")

Actualización : clases de datos

Con la introducción de las clases de datos en Python 3.7 nos acercamos mucho.

El siguiente ejemplo es similar al ejemplo de NamedTuple a continuación, pero el objeto resultante es mutable y permite valores predeterminados.

from dataclasses import dataclass


@dataclass
class Point:
    x: float
    y: float
    z: float = 0.0


p = Point(1.5, 2.5)

print(p)  # Point(x=1.5, y=2.5, z=0.0)

Esto funciona muy bien con el nuevo módulo de escritura en caso de que desee utilizar anotaciones de tipo más específicas.

¡He estado esperando desesperadamente esto! Si me preguntas, ¡las clases de datos y la nueva declaración NamedTuple , combinadas con el módulo de escritura , son una bendición!

Declaración mejorada de NamedTuple

Desde Python 3.6 se volvió bastante simple y hermoso (en mi humilde opinión), siempre que puedas vivir con inmutabilidad .

Se introdujo una nueva forma de declarar NamedTuples , que también permite anotaciones de tipo :

from typing import NamedTuple


class User(NamedTuple):
    name: str


class MyStruct(NamedTuple):
    foo: str
    bar: int
    baz: list
    qux: User


my_item = MyStruct('foo', 0, ['baz'], User('peter'))

print(my_item) # MyStruct(foo='foo', bar=0, baz=['baz'], qux=User(name='peter'))

Puede usar una tupla para muchas cosas en las que usaría una estructura en C (algo así como coordenadas x, y o colores RGB, por ejemplo).

Para todo lo demás, puede usar el diccionario o una clase de utilidad como esta :

>>> class Bunch:
...     def __init__(self, **kwds):
...         self.__dict__.update(kwds)
...
>>> mystruct = Bunch(field1=value1, field2=value2)

Creo que la discusión "definitiva" está aquí , en la versión publicada del Python Cookbook.

Quizás esté buscando estructuras sin constructores:

class Sample:
  name = ''
  average = 0.0
  values = None # list cannot be initialized here!


s1 = Sample()
s1.name = "sample 1"
s1.values = []
s1.values.append(1)
s1.values.append(2)
s1.values.append(3)

s2 = Sample()
s2.name = "sample 2"
s2.values = []
s2.values.append(4)

for v in s1.values:   # prints 1,2,3 --> OK.
  print v
print "***"
for v in s2.values:   # prints 4 --> OK.
  print v

¿Qué tal un diccionario?

Algo como esto:

myStruct = {'field1': 'some val', 'field2': 'some val'}

Entonces puede usar esto para manipular valores:

print myStruct['field1']
myStruct['field2'] = 'some other values'

Y los valores no tienen que ser cadenas. Pueden ser prácticamente cualquier otro objeto.

dF: eso es genial ... No sabía que podía acceder a los campos en una clase usando dict.

Mark: las situaciones en las que desearía tener esto son precisamente cuando quiero una tupla pero nada tan "pesado" como un diccionario.

Puede acceder a los campos de una clase usando un diccionario porque los campos de una clase, sus métodos y todas sus propiedades se almacenan internamente usando dicts (al menos en CPython).

... Lo que nos lleva a su segundo comentario. Creer que los dictados de Python son "pesados" es un concepto extremadamente no pitonista. Y leer esos comentarios mata a mi Python Zen. Eso no es bueno.

Verá, cuando declara una clase, en realidad está creando una envoltura bastante compleja alrededor de un diccionario, por lo que, en todo caso, está agregando más sobrecarga que utilizando un diccionario simple. Una sobrecarga que, por cierto, no tiene sentido en ningún caso. Si está trabajando en aplicaciones críticas de rendimiento, use C o algo así.

Puede subclasificar la estructura C que está disponible en la biblioteca estándar. El módulo ctypes proporciona una clase de estructura . El ejemplo de los documentos:

>>> from ctypes import *
>>> class POINT(Structure):
...     _fields_ = [("x", c_int),
...                 ("y", c_int)]
...
>>> point = POINT(10, 20)
>>> print point.x, point.y
10 20
>>> point = POINT(y=5)
>>> print point.x, point.y
0 5
>>> POINT(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: too many initializers
>>>
>>> class RECT(Structure):
...     _fields_ = [("upperleft", POINT),
...                 ("lowerright", POINT)]
...
>>> rc = RECT(point)
>>> print rc.upperleft.x, rc.upperleft.y
0 5
>>> print rc.lowerright.x, rc.lowerright.y
0 0
>>>

También me gustaría agregar una solución que use ranuras :

class Point:
    __slots__ = ["x", "y"]
    def __init__(self, x, y):
        self.x = x
        self.y = y

Definitivamente revise la documentación de las ranuras, pero una explicación rápida de las ranuras es que es la forma en que Python dice: "Si puede bloquear estos atributos y solo estos atributos en la clase de modo que se comprometa a no agregar ningún atributo nuevo una vez que la clase se crea una instancia (sí, puede agregar nuevos atributos a una instancia de clase, consulte el ejemplo a continuación), luego eliminaré la gran asignación de memoria que permite agregar nuevos atributos a una instancia de clase y usaré justo lo que necesito para estos atributos ranurados ".

Ejemplo de agregar atributos a la instancia de clase (por lo tanto, no usar ranuras):

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p1 = Point(3,5)
p1.z = 8
print(p1.z)

Salida: 8

Ejemplo de intentar agregar atributos a la instancia de clase donde se usaron las ranuras:

class Point:
    __slots__ = ["x", "y"]
    def __init__(self, x, y):
        self.x = x
        self.y = y

p1 = Point(3,5)
p1.z = 8

Salida: AttributeError: el objeto 'Punto' no tiene atributo 'z'

Esto puede funcionar efectivamente como una estructura y usa menos memoria que una clase (como lo haría una estructura, aunque no he investigado exactamente cuánto). Se recomienda usar ranuras si va a crear una gran cantidad de instancias del objeto y no necesita agregar atributos. Un objeto de punto es un buen ejemplo de esto, ya que es probable que uno pueda instanciar muchos puntos para describir un conjunto de datos.

También puede pasar los parámetros de inicio a las variables de instancia por posición

# Abstract struct class       
class Struct:
    def __init__ (self, *argv, **argd):
        if len(argd):
            # Update by dictionary
            self.__dict__.update (argd)
        else:
            # Update by position
            attrs = filter (lambda x: x[0:2] != "__", dir(self))
            for n in range(len(argv)):
                setattr(self, attrs[n], argv[n])

# Specific class
class Point3dStruct (Struct):
    x = 0
    y = 0
    z = 0

pt1 = Point3dStruct()
pt1.x = 10

print pt1.x
print "-"*10

pt2 = Point3dStruct(5, 6)

print pt2.x, pt2.y
print "-"*10

pt3 = Point3dStruct (x=1, y=2, z=3)
print pt3.x, pt3.y, pt3.z
print "-"*10

Siempre que necesito un "objeto de datos instantáneos que también se comporta como un diccionario" (¡ no pienso en estructuras de C!), Pienso en este lindo truco:

class Map(dict):
    def __init__(self, **kwargs):
        super(Map, self).__init__(**kwargs)
        self.__dict__ = self

Ahora solo puedes decir:

struct = Map(field1='foo', field2='bar', field3=42)

self.assertEquals('bar', struct.field2)
self.assertEquals(42, struct['field3'])

Perfectamente útil para aquellos momentos en que necesita una "bolsa de datos que NO es una clase", y para cuando las tuplas nombradas son incomprensibles ...

Accede a la estructura C-Style en python de la siguiente manera.

class cstruct:
    var_i = 0
    var_f = 0.0
    var_str = ""

si solo quieres usar objeto de cstruct

obj = cstruct()
obj.var_i = 50
obj.var_f = 50.00
obj.var_str = "fifty"
print "cstruct: obj i=%d f=%f s=%s" %(obj.var_i, obj.var_f, obj.var_str)

si quieres crear una matriz de objetos de cstruct

obj_array = [cstruct() for i in range(10)]
obj_array[0].var_i = 10
obj_array[0].var_f = 10.00
obj_array[0].var_str = "ten"

#go ahead and fill rest of array instaces of struct

#print all the value
for i in range(10):
    print "cstruct: obj_array i=%d f=%f s=%s" %(obj_array[i].var_i, obj_array[i].var_f, obj_array[i].var_str)

Nota: en lugar del nombre 'cstruct', utilice su nombre de estructura en lugar de var_i, var_f, var_str, defina la variable miembro de su estructura.

Algunas de las respuestas aquí son masivamente elaboradas. La opción más simple que he encontrado es (de: http://norvig.com/python-iaq.html ):

class Struct:
    "A structure that can have any fields defined."
    def __init__(self, **entries): self.__dict__.update(entries)

Inicializando:

>>> options = Struct(answer=42, linelen=80, font='courier')
>>> options.answer
42

agregando más:

>>> options.cat = "dog"
>>> options.cat
dog

editar: Lo siento, no vi este ejemplo ya más abajo.

Esto puede ser un poco tarde, pero hice una solución usando Python Meta-Classes (versión de decorador a continuación también)

Cuando __init__se llama durante el tiempo de ejecución, toma cada uno de los argumentos y su valor y los asigna como variables de instancia a su clase. De esta manera, puede crear una clase de estructura sin tener que asignar cada valor manualmente.

Mi ejemplo no tiene verificación de errores, por lo que es más fácil de seguir.

class MyStruct(type):
    def __call__(cls, *args, **kwargs):
        names = cls.__init__.func_code.co_varnames[1:]

        self = type.__call__(cls, *args, **kwargs)

        for name, value in zip(names, args):
            setattr(self , name, value)

        for name, value in kwargs.iteritems():
            setattr(self , name, value)
        return self 

Aquí está en acción.

>>> class MyClass(object):
    __metaclass__ = MyStruct
    def __init__(self, a, b, c):
        pass


>>> my_instance = MyClass(1, 2, 3)
>>> my_instance.a
1
>>> 

Lo publiqué en reddit y / u / matchu publicó una versión de decorador que es más limpia. Te animo a que lo uses a menos que quieras expandir la versión de la metaclase.

>>> def init_all_args(fn):
    @wraps(fn)
    def wrapped_init(self, *args, **kwargs):
        names = fn.func_code.co_varnames[1:]

        for name, value in zip(names, args):
            setattr(self, name, value)

        for name, value in kwargs.iteritems():
            setattr(self, name, value)

    return wrapped_init

>>> class Test(object):
    @init_all_args
    def __init__(self, a, b):
        pass


>>> a = Test(1, 2)
>>> a.a
1
>>> 

Escribí un decorador que puede usar en cualquier método para que todos los argumentos pasados ​​o los valores predeterminados se asignen a la instancia.

def argumentsToAttributes(method):
    argumentNames = method.func_code.co_varnames[1:]

    # Generate a dictionary of default values:
    defaultsDict = {}
    defaults = method.func_defaults if method.func_defaults else ()
    for i, default in enumerate(defaults, start = len(argumentNames) - len(defaults)):
        defaultsDict[argumentNames[i]] = default

    def newMethod(self, *args, **kwargs):
        # Use the positional arguments.
        for name, value in zip(argumentNames, args):
            setattr(self, name, value)

        # Add the key word arguments. If anything is missing, use the default.
        for name in argumentNames[len(args):]:
            setattr(self, name, kwargs.get(name, defaultsDict[name]))

        # Run whatever else the method needs to do.
        method(self, *args, **kwargs)

    return newMethod

Una rápida demostración. Tenga en cuenta que uso un argumento posicional a, uso el valor predeterminado para by un argumento con nombre c. Luego imprimo las 3 referencias self, para mostrar que se han asignado correctamente antes de ingresar el método.

class A(object):
    @argumentsToAttributes
    def __init__(self, a, b = 'Invisible', c = 'Hello'):
        print(self.a)
        print(self.b)
        print(self.c)

A('Why', c = 'Nothing')

Tenga en cuenta que mi decorador debería funcionar con cualquier método, no solo __init__.

No veo esta respuesta aquí, así que creo que la agregaré ya que estoy inclinado Python en este momento y acabo de descubrirlo. El tutorial de Python (Python 2 en este caso) da el siguiente ejemplo simple y efectivo:

class Employee:
    pass

john = Employee()  # Create an empty employee record

# Fill the fields of the record
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000

Es decir, se crea un objeto de clase vacío, luego se instancia y los campos se agregan dinámicamente.

La ventaja de esto es realmente simple. La desventaja es que no es particularmente autodocumentado (los miembros previstos no están listados en ninguna parte de la "definición" de clase), y los campos no definidos pueden causar problemas cuando se accede a ellos. Esos dos problemas pueden resolverse mediante:

class Employee:
    def __init__ (self):
        self.name = None # or whatever
        self.dept = None
        self.salary = None

Ahora, de un vistazo, al menos puede ver qué campos esperará el programa.

Ambos son propensos a errores tipográficos, john.slarly = 1000tendrán éxito. Aún así, funciona.

Aquí hay una solución que usa una clase (nunca instanciada) para almacenar datos. Me gusta que de esta manera se trate de escribir muy poco y no requiera ningún paquete adicional, etc.

class myStruct:
    field1 = "one"
    field2 = "2"

Puede agregar más campos más tarde, según sea necesario:

myStruct.field3 = 3

Para obtener los valores, se accede a los campos como de costumbre:

>>> myStruct.field1
'one'

Personalmente, también me gusta esta variante. Extiende la respuesta de @ dF .

class struct:
    def __init__(self, *sequential, **named):
        fields = dict(zip(sequential, [None]*len(sequential)), **named)
        self.__dict__.update(fields)
    def __repr__(self):
        return str(self.__dict__)

Admite dos modos de inicialización (que se pueden combinar):

# Struct with field1, field2, field3 that are initialized to None.
mystruct1 = struct("field1", "field2", "field3") 
# Struct with field1, field2, field3 that are initialized according to arguments.
mystruct2 = struct(field1=1, field2=2, field3=3)

Además, se imprime mejor:

print(mystruct2)
# Prints: {'field3': 3, 'field1': 1, 'field2': 2}

La siguiente solución a una estructura está inspirada en la implementación de namedtuple y algunas de las respuestas anteriores. Sin embargo, a diferencia del namedtuple, es mutable, en sus valores, pero al igual que la estructura de estilo c inmutable en los nombres / atributos, que no es una clase o dict normal.

_class_template = """\
class {typename}:
def __init__(self, *args, **kwargs):
    fields = {field_names!r}

    for x in fields:
        setattr(self, x, None)            

    for name, value in zip(fields, args):
        setattr(self, name, value)

    for name, value in kwargs.items():
        setattr(self, name, value)            

def __repr__(self):
    return str(vars(self))

def __setattr__(self, name, value):
    if name not in {field_names!r}:
        raise KeyError("invalid name: %s" % name)
    object.__setattr__(self, name, value)            
"""

def struct(typename, field_names):

    class_definition = _class_template.format(
        typename = typename,
        field_names = field_names)

    namespace = dict(__name__='struct_%s' % typename)
    exec(class_definition, namespace)
    result = namespace[typename]
    result._source = class_definition

    return result

Uso:

Person = struct('Person', ['firstname','lastname'])
generic = Person()
michael = Person('Michael')
jones = Person(lastname = 'Jones')


In [168]: michael.middlename = 'ben'
Traceback (most recent call last):

  File "<ipython-input-168-b31c393c0d67>", line 1, in <module>
michael.middlename = 'ben'

  File "<string>", line 19, in __setattr__

KeyError: 'invalid name: middlename'

Hay un paquete de Python exactamente para este propósito. ver cstruct2py

cstruct2pyes una biblioteca de python pura para generar clases de python a partir de código C y usarlas para empacar y desempaquetar datos. La biblioteca puede analizar los encabezados C (estructuras, uniones, enumeraciones y declaraciones de matrices) y emularlos en Python. Las clases pitónicas generadas pueden analizar y empaquetar los datos.

Por ejemplo:

typedef struct {
  int x;
  int y;
} Point;

after generating pythonic class...
p = Point(x=0x1234, y=0x5678)
p.packed == "\x34\x12\x00\x00\x78\x56\x00\x00"

Cómo utilizar

Primero necesitamos generar las estructuras pitónicas:

import cstruct2py
parser = cstruct2py.c2py.Parser()
parser.parse_file('examples/example.h')

Ahora podemos importar todos los nombres del código C:

parser.update_globals(globals())

También podemos hacer eso directamente:

A = parser.parse_string('struct A { int x; int y;};')

Usando tipos y definiciones del código C

a = A()
a.x = 45
print a
buf = a.packed
b = A(buf)
print b
c = A('aaaa11112222', 2)
print c
print repr(c)

El resultado será:

{'x':0x2d, 'y':0x0}
{'x':0x2d, 'y':0x0}
{'x':0x31316161, 'y':0x32323131}
A('aa111122', x=0x31316161, y=0x32323131)

Clon

Para cstruct2pyejecutar clon :

git clone https://github.com/st0ky/cstruct2py.git --recursive

Creo que el diccionario de estructura Python es adecuado para este requisito.

d = dict{}
d[field1] = field1
d[field2] = field2
d[field2] = field3

https://stackoverflow.com/a/32448434/159695 no funciona en Python3.

https://stackoverflow.com/a/35993/159695 funciona en Python3.

Y lo extiendo para agregar valores predeterminados.

class myStruct:
    def __init__(self, **kwds):
        self.x=0
        self.__dict__.update(kwds) # Must be last to accept assigned member variable.
    def __repr__(self):
        args = ['%s=%s' % (k, repr(v)) for (k,v) in vars(self).items()]
        return '%s(%s)' % ( self.__class__.__qualname__, ', '.join(args) )

a=myStruct()
b=myStruct(x=3,y='test')
c=myStruct(x='str')

>>> a
myStruct(x=0)
>>> b
myStruct(x=3, y='test')
>>> c
myStruct(x='str')

Si no tiene un 3.7 para @dataclass y necesita mutabilidad, el siguiente código podría funcionar para usted. Es bastante autodocumentado y compatible con IDE (autocompletado), evita escribir dos veces, es fácilmente extensible y es muy simple probar que todas las variables de instancia están completamente inicializadas:

class Params():
    def __init__(self):
        self.var1 : int = None
        self.var2 : str = None

    def are_all_defined(self):
        for key, value in self.__dict__.items():
            assert (value is not None), "instance variable {} is still None".format(key)
        return True


params = Params()
params.var1 = 2
params.var2 = 'hello'
assert(params.are_all_defined)

Aquí hay un truco rápido y sucio:

>>> ms = Warning()
>>> ms.foo = 123
>>> ms.bar = 'akafrit'

¿Cómo funciona? Simplemente reutilice la clase incorporada Warning(derivada de Exception) y úsela como si fuera su propia clase definida.

Lo bueno es que no necesita importar o definir nada primero, que "Advertencia" es un nombre corto, y que también deja en claro que está haciendo algo sucio que no debe usarse en otro lugar que no sea un pequeño script suyo.

Por cierto, intenté encontrar algo aún más simple, ms = object()pero no pude (este último ejemplo no funciona). Si tienes uno, estoy interesado.

La mejor manera de hacer esto fue utilizar una clase de diccionario personalizada como se explica en esta publicación: https://stackoverflow.com/a/14620633/8484485

Si se necesita el soporte de autocompletado de iPython, simplemente defina la función dir () de esta manera:

class AttrDict(dict):
    def __init__(self, *args, **kwargs):
        super(AttrDict, self).__init__(*args, **kwargs)
        self.__dict__ = self
    def __dir__(self):
        return self.keys()

Luego define su pseudoestructura de la siguiente manera: (esta está anidada)

my_struct=AttrDict ({
    'com1':AttrDict ({
        'inst':[0x05],
        'numbytes':2,
        'canpayload':False,
        'payload':None
    })
})

Luego puede acceder a los valores dentro de my_struct de esta manera:

print(my_struct.com1.inst)

=>[5]

NamedTuple es cómodo. pero allí nadie comparte el rendimiento y el almacenamiento.

from typing import NamedTuple
import guppy  # pip install guppy
import timeit


class User:
    def __init__(self, name: str, uid: int):
        self.name = name
        self.uid = uid


class UserSlot:
    __slots__ = ('name', 'uid')

    def __init__(self, name: str, uid: int):
        self.name = name
        self.uid = uid


class UserTuple(NamedTuple):
    # __slots__ = ()  # AttributeError: Cannot overwrite NamedTuple attribute __slots__
    name: str
    uid: int


def get_fn(obj, attr_name: str):
    def get():
        getattr(obj, attr_name)
    return get

if 'memory test':
    obj = [User('Carson', 1) for _ in range(1000000)]      # Cumulative: 189138883
    obj_slot = [UserSlot('Carson', 1) for _ in range(1000000)]          # 77718299  <-- winner
    obj_namedtuple = [UserTuple('Carson', 1) for _ in range(1000000)]   # 85718297
    print(guppy.hpy().heap())  # Run this function individually. 
    """
    Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0 1000000    24 112000000 34 112000000  34 dict of __main__.User
     1 1000000    24 64000000  19 176000000  53 __main__.UserTuple
     2 1000000    24 56000000  17 232000000  70 __main__.User
     3 1000000    24 56000000  17 288000000  87 __main__.UserSlot
     ...
    """

if 'performance test':
    obj = User('Carson', 1)
    obj_slot = UserSlot('Carson', 1)
    obj_tuple = UserTuple('Carson', 1)

    time_normal = min(timeit.repeat(get_fn(obj, 'name'), repeat=20))
    print(time_normal)  # 0.12550550000000005

    time_slot = min(timeit.repeat(get_fn(obj_slot, 'name'), repeat=20))
    print(time_slot)  # 0.1368690000000008

    time_tuple = min(timeit.repeat(get_fn(obj_tuple, 'name'), repeat=20))
    print(time_tuple)  # 0.16006120000000124

    print(time_tuple/time_slot)  # 1.1694481584580898  # The slot is almost 17% faster than NamedTuple on Windows. (Python 3.7.7)

Si __dict__no está usando, elija entre __slots__(mayor rendimiento y almacenamiento) y NamedTuple(claro para leer y usar)

Puede revisar este enlace ( Uso de ranuras ) para obtener más __slots__información.