Comment puis-je créer un objet et y ajouter des attributs?

Je veux créer un objet dynamique (à l'intérieur d'un autre objet) en Python, puis y ajouter des attributs.

J'ai essayé:

obj = someobject
obj.a = object()
setattr(obj.a, 'somefield', 'somevalue')

mais cela n'a pas fonctionné.

Des idées?

Éditer:

Je mets les attributs d'une forboucle qui boucle à travers une liste de valeurs, par exemple

params = ['attr1', 'attr2', 'attr3']
obj = someobject
obj.a = object()

for p in params:
   obj.a.p # where p comes from for loop variable

Dans l'exemple ci - dessus , je recevrais obj.a.attr1, obj.a.attr2, obj.a.attr3.

J'ai utilisé la setattrfonction parce que je ne savais pas comment faire à obj.a.NAMEpartir d'une forboucle.

Comment définirais-je l'attribut en fonction de la valeur de pdans l'exemple ci-dessus?

Vous pouvez utiliser mon ancienne recette de Bunch , mais si vous ne voulez pas créer une "classe de bunch", une très simple existe déjà en Python - toutes les fonctions peuvent avoir des attributs arbitraires (y compris les fonctions lambda). Ainsi, les travaux suivants:

obj = someobject
obj.a = lambda: None
setattr(obj.a, 'somefield', 'somevalue')

Que la perte de clarté par rapport à la vénérable Bunchrecette soit correcte, c'est une décision de style que je vous laisse bien sûr.

L'intégré objectpeut être instancié mais aucun attribut ne peut y être défini. (Je souhaite que ce soit possible, dans ce but précis.) Il n'a pas __dict__de support pour les attributs.

Je fais généralement juste ceci:

class Object(object):
    pass

a = Object()
a.somefield = somevalue

Quand je le peux, je donne à la Objectclasse un nom plus significatif, selon le type de données que j'y mets.

Certaines personnes font une chose différente, où elles utilisent une sous-classe dictqui permet l'accès aux attributs pour obtenir les clés. ( d.keyau lieu de d['key'])

Edit : Pour l'ajout à votre question, l'utilisation setattrest très bien. Vous ne pouvez tout simplement pas utiliser setattrsur les object()instances.

params = ['attr1', 'attr2', 'attr3']
for p in params:
    setattr(obj.a, p, value)

Il y a de la types.SimpleNamespaceclasse dans Python 3.3+ :

obj = someobject
obj.a = SimpleNamespace()
for p in params:
    setattr(obj.a, p, value)
# obj.a.attr1

collections.namedtuple, typing.NamedTuplepourrait être utilisé pour des objets immuables. PEP 557 - Les classes de données suggèrent une alternative mutable.

Pour une fonctionnalité plus riche, vous pouvez essayer le attrspackage . Voir un exemple d'utilisation .

Il existe plusieurs façons d'atteindre cet objectif. Fondamentalement, vous avez besoin d'un objet extensible.

obj.a = type('Test', (object,), {})  
obj.a.b = 'fun'  

obj.b = lambda:None

class Test:
  pass
obj.c = Test()

Le mockmodule est essentiellement conçu pour cela.

import mock
obj = mock.Mock()
obj.a = 5

Maintenant, vous pouvez le faire (je ne sais pas si c'est la même réponse que evilpie):

MyObject = type('MyObject', (object,), {})
obj = MyObject()
obj.value = 42

Essayez le code ci-dessous:

$ python
>>> class Container(object):
...     pass 
...
>>> x = Container()
>>> x.a = 10
>>> x.b = 20
>>> x.banana = 100
>>> x.a, x.b, x.banana
(10, 20, 100)
>>> dir(x)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', 
'__getattribute__', '__hash__', '__init__', '__module__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__',     '__sizeof__', 
'__str__', '__subclasshook__', '__weakref__', 'a', 'b', 'banana']

Vous pouvez également utiliser directement un objet de classe; il crée un espace de noms:

class a: pass
a.somefield1 = 'somevalue1'
setattr(a, 'somefield2', 'somevalue2')

comme le disent les docs :

Note : objectne pas avoir un __dict__, donc vous ne pouvez pas affecter des attributs arbitraires à une instance de la objectclasse.

Vous pouvez simplement utiliser une instance de classe factice.

Ces solutions sont très utiles lors des tests. En s'appuyant sur les réponses de tous les autres, je le fais en Python 2.7.9 (sans méthode statique, j'obtiens une TypeError (méthode non liée ...):

In [11]: auth = type('', (), {})
In [12]: auth.func = staticmethod(lambda i: i * 2)
In [13]: auth.func(2)
Out[13]: 4

Quels objets utilisez-vous? Je viens d'essayer cela avec un exemple de classe et cela a bien fonctionné:

class MyClass:
  i = 123456
  def f(self):
    return "hello world"

b = MyClass()
b.c = MyClass()
setattr(b.c, 'test', 123)
b.c.test

Et j'ai eu 123comme réponse.

La seule situation où je vois cet échec est si vous essayez un setattrsur un objet intégré.

Mise à jour: Du commentaire, il s'agit d'une répétition de: Pourquoi ne pouvez-vous pas ajouter d'attributs à un objet en python?

J'y arrive tard dans la journée, mais voici mon pennyworth avec un objet qui se trouve justement contenir des chemins utiles dans une application, mais vous pouvez l'adapter à tout ce que vous voulez un sorta dict d'informations que vous pouvez accéder avec getattr et notation par points (c'est à quoi je pense que cette question concerne vraiment):

import os

def x_path(path_name):
    return getattr(x_path, path_name)

x_path.root = '/home/x'
for name in ['repository', 'caches', 'projects']:
    setattr(x_path, name, os.path.join(x_path.root, name))

C'est cool parce que maintenant:

In [1]: x_path.projects
Out[1]: '/home/x/projects'

In [2]: x_path('caches')
Out[2]: '/home/x/caches'

Donc, cela utilise l'objet fonction comme les réponses ci-dessus mais utilise la fonction pour obtenir les valeurs (vous pouvez toujours utiliser (getattr, x_path, 'repository')plutôt que x_path('repository')si vous préférez).

Si nous pouvons déterminer et agréger tous les attributs et valeurs ensemble avant de créer l'objet imbriqué, alors nous pourrions créer une nouvelle classe qui prend un argument de dictionnaire lors de la création.

# python 2.7

class NestedObject():
    def __init__(self, initial_attrs):
        for key in initial_attrs:
            setattr(self, key, initial_attrs[key])

obj = someobject
attributes = { 'attr1': 'val1', 'attr2': 'val2', 'attr3': 'val3' }
obj.a = NestedObject(attributes)
>>> obj.a.attr1
'val1'
>>> obj.a.attr2
'val2'
>>> obj.a.attr3
'val3'

Nous pouvons également autoriser les arguments de mots clés. Voir cet article .

class NestedObject(object):
    def __init__(self, *initial_attrs, **kwargs):
        for dictionary in initial_attrs:
            for key in dictionary:
                setattr(self, key, dictionary[key])
        for key in kwargs:
            setattr(self, key, kwargs[key])


obj.a = NestedObject(attr1='val1', attr2='val2', attr3= 'val3')

di = {}
for x in range(20):
    name = '_id%s' % x
    di[name] = type(name, (object), {})
    setattr(di[name], "attr", "value")

Autre façon je vois, de cette façon:

import maya.cmds

def getData(objets=None, attrs=None):
    di = {}
    for obj in objets:
        name = str(obj)
        di[name]=[]
        for at in attrs:
            di[name].append(cmds.getAttr(name+'.'+at)[0])
    return di

acns=cmds.ls('L_vest_*_',type='aimConstraint')
attrs=['offset','aimVector','upVector','worldUpVector']

getData(acns,attrs)