Est-il un type de données en Python similaire pour les structures en C++?

Est-il un type de données en Python similaire pour les structures en C++? J'aime la structure de la fonction myStruct.someName. Je sais que les classes ont cela, mais je ne veux pas écrire une classe à chaque fois que j'ai besoin d'un "conteneur" de certaines données.

Depuis en C++ structs et classes sont la même chose (ils ne diffèrent que par la valeur par défaut des membres et de l'héritage spécificateurs d'accès), vous pouvez simplement écrire un class...
Généralement, nous utilisons un dict, où la syntaxe est mydict["someName"]. Mais si vous définissez votre propre classe une fois, vous pouvez ajouter n'importe quel attribut que vous souhaitez instances.
K: Tu veux dire que je peux créer une instance foo d'une classe bar et ajouter des attributs à cette dynamique? Comme première foo il est vide, puis-je ajouter un attribut, puis un autre et ainsi de suite?
Oui. class Struct(object): pass s = Struct() s.a = 5 print(s.a) imprime 5.
Merci à tous pour les conseils!

OriginalL'auteur Aufwind | 2011-05-09

  1. 27

    Pourquoi pas? Les Classes sont très bien pour cela.

    Si vous voulez économiser de la mémoire, vous pouvez également utiliser __slots__ de sorte que les objets n'ont pas une __dict__. Voir http://docs.python.org/reference/datamodel.html#slots pour plus de détails et L'utilisation de __slots__? pour quelques informations utiles.

    Par exemple, une classe possédant seulement deux valeurs (a et b) pourrait ressemble à ceci:

    class AB(object):
    __slots__ = ('a', 'b')

    Si vous voulez vraiment un dict, mais avec obj.item l'accès au lieu de obj['item'], vous pouvez sous-classe dict et de mettre en œuvre __getattr__ et __setattr__ à se comporter comme __getitem__ et __setitem__.

    Merci. Je m'en tiendrai à des classes! 🙂 Vos suggestions de "modification" dict est vraiment cool!
    C'est sérieusement sous-estimé la réponse dans un sujet vague. Un dict avec __getattr__ et __setattr__ fonctions me semble être une très élégante façon de mettre en œuvre struct type de comportement en python.

    OriginalL'auteur ThiefMaster

  2. 13

    En plus de la dict type, il y a un namedtuple type qui se comporte un peu comme un struct.

    MyStruct = namedtuple('MyStruct', ['someName', 'anotherName'])
aStruct = MyStruct('aValue', 'anotherValue')

print aStruct.someName, aStruct.anotherName
    Cela me rappelle de "types définis par l'utilisateur" à partir de Visual Basic 6.0. Ils ont été VB de l'analogique vers le C++'struct. Même la façon dont il est déclaré est similaire. vb6.us/tutoriels/défini par l'utilisateur-types-udt-vb
    Notez qu'un namedtuple est en lecture seule, c'est à dire vous ne pouvez pas modifier les valeurs comme aStruct.someName = "foo" (bien sûr, cela est conforme à la normale tuples).

    OriginalL'auteur sock

  3. 6

    Veuillez réaliser qu'en C++, la seule différence entre une classe et une struct est que les éléments d'une classe sont par défaut privé, comme c'est l'héritage. Les suivantes sont équivalentes:

    class D : public B {
    public:
    ...
}; 

struct D {
    ...
};

    En Python, il serait plus judicieux d'utiliser une classe si vous souhaitez utiliser l'opérateur point d'accéder à des éléments. En fait, il est encore plus facile, car vous ne devez initialiser les membres que vous désirez, et vous pouvez ajouter/supprimer des membres plus tard. Par conséquent, la suivante devrait fonctionner:

    class D(object):
    pass

    Vous pouvez ensuite ajouter autant de membres que vous souhaitez tout simplement en attribuant à eux.

    Merci pour l'explication détaillée. L'idée derrière ma question est la lisibilité de mon code. Ce sera d'une grande aide!
    Qui devrait être class D(object): pass.
    Des Classes sans méthodes (dump classes) sont considérés comme un anti-modèle, dans la mesure où je peux dire.

    OriginalL'auteur Anton Golov

  4. 5

    dataclass est maintenant intégré à Python que de Python 3.7! 

    from dataclasses import dataclass

@dataclass
class EZClass:
    name: str='default'
    qty: int

    Test:

    classy = EZClass('cars', 3)
print(classy)

    De sortie:

    EZClass(name='cars', qty=3)

    D'ailleurs pour l'initialisation automatique et __repr__ méthodes qu'il génère, il crée automatiquement un __eq__ méthode pour faire simple et intuitive pour comparer deux instances de la classe.

    Voir PEP 557.

    Intégré à Python 3.6 à l'aide de la dataclasses paquet.

    OriginalL'auteur ChaimG

  5. 4

    Vous pouvez toujours aller pour l'approche dynamique:

    class foo(object):
    def __init__(self,**kwargs):
        self.__dict__.update(kwargs)

    Ce sera une classe avec les mêmes méthodes que vous transmettez en tant que dict:

    bar = foo(bill="yo",heather="hi",sam="piss off")

    vous laissant avec la suivante parfaitement valide appels sur bar:

    bar.bill
>> "yo"
bar.heater
>> "hi"

    vous voyez l'idée...

    OriginalL'auteur wheaties

  6. 3

    Essayez d'utiliser un dict.

    Voici une démonstration simpliste.

    >>> something = {}
>>> something['x'] = 42
>>> something['y'] = 'cheese'
>>> something
{'y': 'cheese', 'x': 42}
>>> something['x']
42
>>> something['y']
'cheese'

    OriginalL'auteur Johnsyweb

  7. 2

    Je crois que vous êtes à la recherche d'un dict.

    d = dict({
        'name': 'myname',
        'val': 'myval'
        })

print d
print d['name']

    OriginalL'auteur Demian Brecht

  8. 1

    Ce peut-être l'idée un peu trop loin, mais ici, c'est un moyen de créer des "structures" à l'aide d'une syntaxe qui est un peu similaire à C++ structures qui effectue également des opérations de vérification de type. Tout d'abord, voici un exemple d'utilisation:

    >>> MyStruct = Struct({
...     'i': int,
...     's': str,
...     'x': float,
... }, 'MyStruct')
>>> print(MyStruct)
MyStruct {
    i: int,
    s: str,
    x: float,
}

>>> instance = MyStruct(i=1, s='s', x=1.0)
>>> print(instance)
MyStruct(i: 1, s: 's', x: 1.0)

    Et voici la mise en œuvre. C'est une variante de la __slots__ idée de l'endroit où la classe avec des fentes (c'est à dire, le "struct" type) est généré dynamiquement. Cela pourrait bien sûr être interprétée de différentes manières, mais c'est juste une preuve de concept.

    class Struct:
class StructInstance:
__slots__ = ()
def __str__(self):
values = []
for name in self.__slots__:
value = getattr(self, name)
values.append('{name}: {value!r}'.format(name=name, value=value))
type_name = self.__class__.__name__
values = ', '.join(values)
return '{type_name}({values})'.format(type_name=type_name, values=values)
def __init__(self, fields, name=None):
for field_name, field_type in fields.items():
assert isinstance(field_name, str), 'Expected str for field name'
assert isinstance(field_type, type), 'Expected type for field type'
self.fields = fields
self.name = name or 'Struct'
self.type = type(
self.name, (self.StructInstance,), {'__slots__': tuple(fields)})
def __call__(self, **values):
instance = self.type()
for name in instance.__slots__:
value = values[name]
expected_type = self.fields[name]
assert isinstance(value, expected_type), 'Expected %s for %s' % (expected_type, name)
setattr(instance, name, value)
return instance
def __str__(self):
fields = ['    {n}: {t.__name__},'.format(n=n, t=t) for n, t in self.fields.items()]
return '{name} {{\n{fields}\n}}'.format(name=self.name, fields='\n'.join(fields))

    OriginalL'auteur