C-comme des structures en Python

Utiliser un nommé tuple, qui a été ajouté à la les collections de module dans la bibliothèque standard de Python 2.6. Il est également possible d'utiliser Raymond Hettinger de nommé tuple recette si vous avez besoin de soutien Python 2.4.

C'est gentil pour votre exemple de base, mais couvre également un tas de bord des cas, vous aurez peut-être plus tard. Votre fragment ci-dessus devrait être écrite comme:

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

Le nouveau type peut être utilisée comme ceci:

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

Vous pouvez également utiliser les arguments nommés:

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

Vous pouvez utiliser un tuple pour beaucoup de choses lorsque vous utilisez une struct en C (quelque chose comme coordonnées x,y ou RVB en couleurs par exemple).

Pour tout le reste, vous pouvez utiliser le dictionnaire, ou une classe utilitaire comme cette une:

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

Je pense que la version "définitive" de la discussion est ici, dans la version publiée de l'Python Cookbook.

Comment propos d'un dictionnaire?

Quelque chose comme ceci:

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

Ensuite, vous pouvez l'utiliser pour manipuler des valeurs:

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

Et les valeurs n'ont pas à être des chaînes de caractères. Ils peuvent être à peu près n'importe quel autre objet.

Vous pouvez également passer l'initialisation des paramètres pour les variables d'instance par la position

# 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

Vous pouvez sous-classe de la structure C qui est disponible dans la bibliothèque standard. Le ctypes module fournit une La Structure de la classe. L'exemple de la doc:

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

Vous accédez à C-Style struct en python manière suivante.

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

si vous voulez juste utiliser l'objet 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 vous souhaitez créer un tableau d'objets 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)

Note:
au lieu de " cstruct nom, veuillez utiliser votre struct nom
au lieu de var_i, var_f, var_str, veuillez définir votre structure est variable membre.

J'ai écrit un décorateur, vous pouvez l'utiliser sur n'importe quelle méthode pour faire en sorte que tous les arguments passés en, ou de toute défaillance, sont attribuées à l'instance.

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

Une démonstration rapide. Notez que j'utilise un de position argument a, utilisez la valeur par défaut pour b, et un argument nommé c. Je puis tout imprimer 3 de référencement self, pour montrer qu'ils ont été correctement attribués avant la méthode est entré.

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

Remarque que mon décorateur devrait fonctionner avec n'importe quelle méthode, et pas seulement __init__.

Je ne vois pas de réponse ici, donc je me dis je vais l'ajouter depuis que je suis penchée Python dès maintenant et viens de découvrir il. Le Tutoriel Python (Python 2 dans ce cas) donne la suivante, simple et efficace exemple:

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

Qui est, une classe vide objet est créé, puis instancié, et les champs sont ajoutés dynamiquement.

Le côté, c'est vraiment simple. L'inconvénient est qu'il n'est pas particulièrement l'auto-documentation (à l'intention des membres ne sont pas répertoriés partout dans la classe "définition"), et désactiver des champs peuvent causer des problèmes lors de l'accès. Ces deux problèmes peuvent être résolus par:

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

Maintenant un coup d'œil, vous pouvez au moins voir ce que les champs le programme prévu.

Les deux sont sujettes à des fautes de frappe, john.slarly = 1000 va réussir. Encore, il fonctionne.

La solution suivante pour une struct est inspiré par le namedtuple la mise en œuvre et certains de la réponse à la question précédente. Cependant, contrairement à la namedtuple il est mutable, dans ses valeurs, mais comme le style c struct immuable dans les noms et attributs d'une classe normale ou dict ne l'est pas.

_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

Utilisation:

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'

Il y a un paquet python exactement à cette fin. voir cstruct2py

cstruct2py est un pur bibliothèque python pour générer les classes python à partir de code C et de les utiliser pour emballer et déballer des données. La bibliothèque peut analyser C headres (les structures, les syndicats, les énumérations et les tableaux des déclarations) et à les imiter en python. L'généré pythonic classes peut analyser et pack les données.

Par exemple:

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"

Comment utiliser

Nous avons d'abord besoin de générer le pythonic structures:

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

Maintenant, nous pouvons importer tous les noms à partir du code C:

parser.update_globals(globals())

Nous pouvons également le faire directement:

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

À l'aide de types et définit à partir du code 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)

La sortie sera:

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

Clone

Clone cstruct2py exécuter:

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

https://stackoverflow.com/a/32448434/159695 ne fonctionne pas dans Python3.

https://stackoverflow.com/a/35993/159695 travaille dans Python3.

Et je l'étend à ajouter des valeurs par défaut.

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