Comment créer une nouvelle inconnue ou dynamique/expando objet en Python

En python comment pouvons-nous créer un nouvel objet sans avoir une Classe prédéfinie et, plus tard, ajouter dynamiquement des propriétés ?

exemple:

dynamic_object = Dynamic()
dynamic_object.dynamic_property_a = "abc"
dynamic_object.dynamic_property_b = "abcdefg"

Quelle est la meilleure façon de le faire?

MODIFIER Parce que beaucoup de personnes conseillé dans les commentaires que je ne pourrais pas besoin de cela.

Le truc c'est que j'ai une fonction qui sérialise les propriétés d'un objet. Pour cette raison, je ne veux pas créer un objet de la classe en raison de certaines constructeur de restrictions, mais au lieu de créer un poste similaire, disons comme un se moquer de, ajouter les propriétés de "custom" j'ai besoin, puis le nourrir à la fonction.

Qu'est ce qu'une propriété dynamique"? comme dans setattr(dynamic_object, variable_with_property_name, variable_with_property_value)? vous avez besoin d'un collection pour associer des propriétés à des valeurs, et le "type" de cette chose est utilisé dans un endroit... pourriez-vous peut-être voulez vraiment un dict?
vérifier la mise à jour de question

InformationsquelleAutor Jimmy Kane | 2012-12-23

39

Il suffit de définir votre propre classe pour le faire:
```
class Expando(object):
    pass

ex = Expando()
ex.foo = 17
ex.bar = "Hello"
```
- C'. La définition d'une classe n'est pas cher, pourquoi ne pas utiliser simplement?
- Est-ce ok si je définir la classe Expando à l'intérieur de la seule fonction qui a besoin de l'objet dynamique ?
- qui ressemble étrangement à une autre question, mais oui, son "ok"; d'autre part, il ne fait pas l'acheter vous une chose, la mettre à la portée de module et d'économiser les frais généraux de la création de classes d'utilisation.
- Cela sonne étrangement comme vous voulez utiliser un namedtuple classe à la place.
- Veuillez vérifier les mises à jour question.
- Je sens que je vais revenir à de nombreuses reprises. Je souhaite que je pourrais star de la réponse au lieu de la question. Il va aider énormément avec le débogage interactif.
- Je sais en Python vous pouvez pirater votre code pour faire quelque chose de dérivation et de la bonne utilisation de python, mais ce n'est pas une bonne façon de le faire (du moins pas dans un environnement de production où vous n'code de la diligence raisonnable). ** PyLint rapports cela comme une erreur. ** Comment avez-vous alors de contourner peluchage votre code? -------- E: 5,4: la Classe de Expando' a pas de 'foo' membre (non-membre)
InformationsquelleAutor Ned Batchelder
19

À l'aide d'un objet à conserver des valeurs n'est pas le plus Pythonic style de programmation. Il est commun dans les langages de programmation qui ne sont pas de bonne conteneurs associatifs, mais en Python, vous pouvez utiliser un dictionnaire:
```
my_dict = {} # empty dict instance

my_dict["foo"] = "bar"
my_dict["num"] = 42
```
Vous pouvez également utiliser un "dictionnaire littérale" pour définir le contenu du dictionnaire tout à la fois:
```
my_dict = {"foo":"bar", "num":42}
```
Ou, si vos clés sont tous des identificateurs (et ils le seront, si vous prévoyez d'entre eux étant des noms d'attribut), vous pouvez utiliser le dict constructeur avec mot-clé les arguments comme des paires clé-valeur:
```
my_dict = dict(foo="bar", num=42) # note, no quotation marks needed around keys
```
Remplir un dictionnaire est en fait ce que Python est fait en arrière-plan lorsque vous utilisez un objet, comme dans Ned Batchelder de réponse. Les attributs de son ex objet sont stockés dans un dictionnaire, ex.__dict__, qui doit être égale à l'équivalent dict créé directement.

À moins que la syntaxe d'attribut (par exemple,ex.foo) est absolument nécessaire, vous pouvez ignorer l'objet et utiliser directement un dictionnaire.
- Avez-vous essayé votre code? Vous ne pouvez pas ajouter des attributs à un object().
- Hmm, bizarre, j'aurais juré que j'avais fait avant. Je vais prendre la partie et il suffit de laisser la partie concernant la dicts, ce qui était mon principal suggestion.
- Ou utiliser le collections.namedtuple fabrique de classe..
InformationsquelleAutor Blckknght
8

Si vous prenez metaclassing approche de @Martijn réponse, @Nie la réponse peut être réécrit de la plus courte (même si c'est évidemment moins lisible, mais la même chose).
```
obj = type('Expando', (object,), {})()
obj.foo = 71
obj.bar = 'World'
```
Ou tout simplement, qui fait la même chose que ci-dessus en utilisant dict argument:
```
obj = type('Expando', (object,), {'foo': 71, 'bar': 'World'})()
```
Pour Python 3, passage de l'objet à bases argument n'est pas nécessaire (voir type documentation).

Mais pour les cas simples de l'instanciation de ne pas avoir un avantage, donc c'est normal de le faire:
```
ns = type('Expando', (object,), {'foo': 71, 'bar': 'World'})
```
Dans le même temps, personnellement, je préfère une plaine de classe (c'est à dire sans instanciation) pour ad-hoc test de la configuration des cas comme la plus simple et lisible:
```
class ns:
    foo = 71
    bar = 'World'
```
Mise à jour

En Python 3.3,+, il est exactement ce que l'OP demande, types.SimpleNamespace. C'est juste:

Un simple object sous-classe qui fournit l'attribut de l'accès à son espace de noms, ainsi que une véritable repr.

Contrairement à object, avec SimpleNamespace vous pouvez ajouter et supprimer des attributs. Si un SimpleNamespace objet est initialisé avec le mot-clé arguments, ceux-ci sont directement ajoutés à la sous-jacentes de l'espace de noms.
```
import types
obj = types.SimpleNamespace()
obj.a = 123
print(obj.a) # 123
print(repr(obj)) # namespace(a=123)
```
Cependant, dans stdlib de Python 2 et Python 3 il y a argparse.Espace de noms, qui a le même but:

Simple objet pour le stockage des attributs.

Met en œuvre l'égalité par des noms d'attributs et de valeurs, et fournit une simple représentation de chaîne.
```
import argparse
obj = argparse.Namespace()
obj.a = 123
print(obj.a) # 123 
print(repr(obj)) # Namespace(a=123)
```
Noter que les deux peuvent être initialisés avec le mot-clé arguments:
```
types.SimpleNamespace(a = 'foo',b = 123)
argparse.Namespace(a = 'foo',b = 123)
```
InformationsquelleAutor saaj

Utiliser le collections.namedtuple() de la fabrique de classe pour créer une classe personnalisée pour votre valeur de retour:

from collections import namedtuple
return namedtuple('Expando', ('dynamic_property_a', 'dynamic_property_b'))('abc', 'abcdefg')

La valeur retournée peut être utilisé à la fois comme un n-uplet et par attribut d'accès:

print retval[0]                  # prints 'abc'
print retval.dynamic_property_b  # prints 'abcdefg'

InformationsquelleAutor Martijn Pieters

3

Une façon que j'ai trouvé est également par la création d'un lambda. Il peut avoir des effets secondaires et est livré avec des propriétés qui ne sont pas voulu. Seulement l'affichage de l'intérêt.
```
dynamic_object = lambda:expando
dynamic_object.dynamic_property_a = "abc"
dynamic_object.dynamic_property_b = "abcdefg"
```
- Vous avez créé un lambda. Ce n'est pas la meilleure façon de créer une instance; le fait que vous pouvez ajouter des attributs à il est maintenant utilisé comme un effet secondaire.
- Notez que cela vient avec un couple d'attributs prédéfinis (par exemple, essayez de dynamic_object.__name__)
- Oui, cela pourrait créer un problème. En effet, vous avez raison.
InformationsquelleAutor Jimmy Kane

Vous devez vous connecter pour publier un commentaire.

Mise à jour