Existe uma maneira de definir convenientemente uma estrutura semelhante a C em Python? Estou cansado de escrever coisas como:

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

Use uma tupla nomeada , que foi adicionada ao módulo de coleções na biblioteca padrão no Python 2.6. Também é possível usar a receita de tupla nomeada de Raymond Hettinger se você precisar oferecer suporte ao Python 2.4.

É bom para o seu exemplo básico, mas também abrange vários casos extremos que você pode encontrar mais tarde também. Seu fragmento acima seria escrito como:

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

O tipo recém-criado pode ser usado assim:

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

Você também pode usar argumentos nomeados:

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

Atualização : Classes de Dados

Com a introdução das classes de dados no Python 3.7 , chegamos muito perto.

O exemplo a seguir é semelhante ao exemplo NamedTuple abaixo, mas o objeto resultante é mutável e permite valores padrão.

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)

Isso funciona bem com o novo módulo de digitação , caso você queira usar anotações de tipo mais específicas.

Eu tenho esperado desesperadamente por isso! Se você me perguntar, Data Classes e a nova declaração NamedTuple , combinadas com o módulo de digitação , são uma dádiva de Deus!

Declaração NamedTuple aprimorada

Desde o Python 3.6 , tornou-se bastante simples e bonito (IMHO), desde que você possa viver com imutabilidade .

Foi introduzida uma nova maneira de declarar NamedTuples , que também permite anotações 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'))

Você pode usar uma tupla para muitas coisas em que você usaria uma estrutura em C (algo como coordenadas x, y ou cores RGB, por exemplo).

Para todo o resto, você pode usar o dicionário ou uma classe de utilitário como esta :

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

Acho que a discussão "definitiva" está aqui , na versão publicada do Python Cookbook.

Talvez você esteja procurando Structs sem construtores:

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

Que tal um dicionário?

Algo assim:

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

Então você pode usar isso para manipular valores:

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

E os valores não precisam ser seqüências de caracteres. Eles podem ser praticamente qualquer outro objeto.

dF: isso é muito legal ... eu não sabia que poderia acessar os campos em uma classe usando dict.

Mark: as situações que eu gostaria de ter são exatamente quando eu quero uma tupla, mas nada tão "pesado" quanto um dicionário.

Você pode acessar os campos de uma classe usando um dicionário, porque os campos de uma classe, seus métodos e todas as suas propriedades são armazenados internamente usando dictos (pelo menos no CPython).

... O que nos leva ao seu segundo comentário. Acreditar que os dicionários de Python são "pesados" é um conceito extremamente não-pythonístico. E ler esses comentários mata meu Python Zen. Isso não é bom.

Veja bem, quando você declara uma classe, na verdade está criando um wrapper bastante complexo em torno de um dicionário - portanto, se houver, você está adicionando mais sobrecarga do que usando um dicionário simples. Uma sobrecarga que, a propósito, não tem sentido em nenhum caso. Se você estiver trabalhando em aplicativos críticos para o desempenho, use C ou algo assim.

Você pode subclassificar a estrutura C que está disponível na biblioteca padrão. O módulo ctypes fornece uma classe Structure . O exemplo dos 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
>>>

Eu também gostaria de adicionar uma solução que usa slots :

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

Definitivamente, verifique a documentação quanto a slots, mas uma explicação rápida dos slots é que é a maneira de o python dizer: "Se você pode bloquear esses atributos e somente esses atributos na classe, de forma que você confirme que não adicionará novos atributos uma vez que a classe é instanciado (sim, você pode adicionar novos atributos a uma instância de classe, veja o exemplo abaixo), então eliminarei a grande alocação de memória que permite adicionar novos atributos a uma instância de classe e usarei exatamente o que preciso para esses atributos com fenda ".

Exemplo de adição de atributos à instância da classe (portanto, não usando slots):

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

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

Saída: 8

Exemplo de tentativa de adicionar atributos à instância da classe em que os slots foram usados:

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

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

Saída: AttributeError: o objeto 'Point' não tem atributo 'z'

Isso pode funcionar efetivamente como uma estrutura e usa menos memória que uma classe (como uma estrutura faria, embora eu não tenha pesquisado exatamente quanto). É recomendável usar slots se você estiver criando uma grande quantidade de instâncias do objeto e não precisar adicionar atributos. Um objeto de ponto é um bom exemplo disso, pois é possível que seja possível instanciar muitos pontos para descrever um conjunto de dados.

Você também pode passar os parâmetros init para as variáveis ​​da instância pela posição

# 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

Sempre que preciso de um "objeto de dados instantâneos que também se comporte como um dicionário" ( não penso em estruturas em C!), Penso neste truque fofo:

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

Agora você pode apenas dizer:

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

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

Perfeitamente útil para aqueles momentos em que você precisa de um "saco de dados que NÃO é uma classe" e para quando os nomeados são incompreensíveis ...

Você acessa a estrutura C-Style em python da seguinte maneira.

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

se você quiser apenas usar o objeto 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)

se você deseja criar uma 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: em vez do nome 'cstruct', use o nome da sua estrutura em vez de var_i, var_f, var_str, defina a variável de membro da sua estrutura.

Algumas respostas aqui são massivamente elaboradas. A opção mais simples que encontrei é (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

adicionando mais:

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

edit: Desculpe, ainda não vi esse exemplo mais abaixo.

Isso pode ser um pouco tarde, mas eu fiz uma solução usando Python Meta-Classes (versão decoradora abaixo também).

Quando __init__é chamado durante o tempo de execução, ele pega cada um dos argumentos e seus valores e os atribui como variáveis ​​de instância à sua classe. Dessa forma, você pode criar uma classe do tipo struct sem precisar atribuir todos os valores manualmente.

Meu exemplo não possui verificação de erro, portanto é mais fácil segui-lo.

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 

Aqui está em ação.

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


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

Eu postou no reddit e / u / Matchu postou uma versão decorador que é mais limpo. Aconselho você a usá-lo, a menos que queira expandir a versão da metaclasse.

>>> 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
>>> 

Eu escrevi um decorador que você pode usar em qualquer método para torná-lo de modo que todos os argumentos passados ​​ou quaisquer padrões sejam atribuídos à instância.

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

Uma demonstração rápida. Observe que eu uso um argumento posicional a, use o valor padrão para be um argumento nomeado c. Em seguida, imprimo todas as 3 referências self, para mostrar que elas foram atribuídas corretamente antes da inserção do 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')

Observe que meu decorador deve funcionar com qualquer método, não apenas __init__.

Não vejo essa resposta aqui, então acho que vou adicioná-la, já que estou inclinando o Python agora e a descobri. O tutorial do Python (neste caso, o Python 2) fornece o seguinte exemplo simples e eficaz:

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

Ou seja, um objeto de classe vazio é criado, instanciado e os campos são adicionados dinamicamente.

O lado positivo disso é realmente simples. A desvantagem é que não é particularmente auto-documentada (os membros pretendidos não estão listados em nenhum lugar da classe "definição"), e os campos não definidos podem causar problemas quando acessados. Esses dois problemas podem ser resolvidos por:

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

Agora, de relance, você pode pelo menos ver quais campos o programa estará esperando.

Ambos são propensos a erros de digitação, john.slarly = 1000terão sucesso. Ainda assim, funciona.

Aqui está uma solução que usa uma classe (nunca instanciada) para armazenar dados. Gosto que dessa maneira envolva muito pouca digitação e não exija nenhum pacote adicional, etc.

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

Você pode adicionar mais campos posteriormente, conforme necessário:

myStruct.field3 = 3

Para obter os valores, os campos são acessados ​​como de costume:

>>> myStruct.field1
'one'

Pessoalmente, eu também gosto dessa variante. Estende a resposta do @ 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__)

Ele suporta dois modos de inicialização (que podem ser combinados):

# 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)

Além disso, ele imprime melhor:

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

A solução a seguir para uma estrutura é inspirada na implementação do nomeado duplo e em algumas das respostas anteriores. No entanto, ao contrário do duplo nomeado, ele é mutável, em seus valores, mas como a estrutura do estilo c imutável nos nomes / atributos, que não são uma classe ou ditado 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'

Existe um pacote python exatamente para esse fim. veja cstruct2py

cstruct2pyé uma biblioteca python pura para gerar classes python a partir do código C e usá-las para compactar e descompactar dados. A biblioteca pode analisar os cabeçalhos C (declarações de estruturas, uniões, enumerações e matrizes) e emulá-los em python. As classes pitônicas geradas podem analisar e compactar os dados.

Por exemplo:

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"

Como usar

Primeiro, precisamos gerar as estruturas pitônicas:

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

Agora podemos importar todos os nomes do código C:

parser.update_globals(globals())

Também podemos fazer isso diretamente:

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

Usando tipos e definições do 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)

A saída será:

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

Clone

Para cstruct2pyexecução de clone :

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

Eu acho que o dicionário de estrutura Python é adequado para esse requisito.

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

https://stackoverflow.com/a/32448434/159695 não funciona no Python3.

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

E eu o estendo para adicionar valores padrão.

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')

Se você não possui um 3.7 para @dataclass e precisa de mutabilidade, o código a seguir pode funcionar para você. É bastante auto-documentado e amigável ao IDE (preenchimento automático), evita escrever as coisas duas vezes, é facilmente extensível e é muito simples testar se todas as variáveis ​​de instância são 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)

Aqui está um truque rápido e sujo:

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

Como isso funciona? Apenas reutiliza a classe builtin Warning(derivada deException ) e use-a como se fosse sua própria classe definida.

Os pontos positivos são que você não precisa importar ou definir nada primeiro, que "Aviso" é um nome abreviado e também deixa claro que você está fazendo algo sujo que não deve ser usado em outro lugar que não seja um pequeno script seu.

A propósito, tentei encontrar algo ainda mais simples, ms = object()mas não consegui (este último exemplo não está funcionando). Se você tiver um, estou interessado.

A melhor maneira de fazer isso foi usar uma classe de dicionário personalizada, conforme explicado neste post: https://stackoverflow.com/a/14620633/8484485

Se o suporte ao preenchimento automático do iPython for necessário, basta definir a função dir () assim:

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

Você define sua pseudo estrutura da seguinte forma: (esta é aninhada)

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

Você pode acessar os valores dentro de my_struct assim:

print(my_struct.com1.inst)

=>[5]

NamedTuple é confortável. mas ninguém compartilha o desempenho e o armazenamento.

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)

Se você __dict__não estiver usando, escolha entre __slots__(maior desempenho e armazenamento) e NamedTuple(limpe para leitura e uso)

Você pode revisar este link ( Uso de slots ) para obter mais __slots__informações.