Comment définir des attributs de classe à partir d'arguments variables (kwargs) en python

Supposons que j'ai une classe avec un constructeur (ou une autre fonction) qui prend un nombre variable d'arguments, puis les définit comme attributs de classe de manière conditionnelle.

Je pourrais les définir manuellement, mais il semble que les paramètres variables sont suffisamment courants en python pour qu'il devrait y avoir un idiome commun pour le faire. Mais je ne sais pas comment procéder de manière dynamique.

J'ai un exemple utilisant eval, mais ce n'est guère sûr. Je veux savoir la bonne façon de faire cela - peut-être avec lambda?

class Foo:
    def setAllManually(self, a=None, b=None, c=None):
        if a!=None: 
            self.a = a
        if b!=None:
            self.b = b
        if c!=None:
            self.c = c
    def setAllWithEval(self, **kwargs):
        for key in **kwargs:
            if kwargs[param] != None
                eval("self." + key + "=" + kwargs[param])

Vous pouvez mettre à jour l' __dict__attribut (qui représente les attributs de classe sous la forme d'un dictionnaire) avec les arguments de mot-clé:

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

Ensuite vous pouvez:

>>> bar = Bar(a=1, b=2)
>>> bar.a
1

et avec quelque chose comme:

allowed_keys = {'a', 'b', 'c'}
self.__dict__.update((k, v) for k, v in kwargs.items() if k in allowed_keys)

vous pouvez filtrer les clés au préalable (utilisez iteritemsplutôt que itemssi vous utilisez toujours Python 2.x).

Vous pouvez utiliser la setattr()méthode:

class Foo:
  def setAllWithKwArgs(self, **kwargs):
    for key, value in kwargs.items():
      setattr(self, key, value)

Il existe une getattr()méthode analogue pour récupérer les attributs.

La plupart des réponses ici ne couvrent pas un bon moyen d'initialiser tous les attributs autorisés à une seule valeur par défaut. Donc, pour ajouter aux réponses données par @fqxp et @mmj :

class Myclass:

    def __init__(self, **kwargs):
        # all those keys will be initialized as class attributes
        allowed_keys = set(['attr1','attr2','attr3'])
        # initialize all allowed keys to false
        self.__dict__.update((key, False) for key in allowed_keys)
        # and update the given keys by their given values
        self.__dict__.update((key, value) for key, value in kwargs.items() if key in allowed_keys)

Je propose une variante de la réponse de fqxp , qui, en plus des attributs autorisés , vous permet de définir des valeurs par défaut pour les attributs:

class Foo():
    def __init__(self, **kwargs):
        # define default attributes
        default_attr = dict(a=0, b=None, c=True)
        # define (additional) allowed attributes with no default value
        more_allowed_attr = ['d','e','f']
        allowed_attr = list(default_attr.keys()) + more_allowed_attr
        default_attr.update(kwargs)
        self.__dict__.update((k,v) for k,v in default_attr.items() if k in allowed_attr)

Il s'agit du code Python 3.x, pour Python 2.x vous avez besoin d'au moins un ajustement, iteritems()à la place de items().

Encore une autre variante basée sur les excellentes réponses de mmj et fqxp . Et si on veut

1. Évitez de coder en dur une liste d'attributs autorisés
2. Définir directement et explicitement les valeurs par défaut pour chaque attribut dans le constructeur
3. Restreignez les kwargs aux attributs prédéfinis soit
   • rejetant silencieusement les arguments invalides ou , alternativement,
   • soulevant une erreur.

Par «directement», je veux dire éviter un default_attributesdictionnaire superflu .

class Bar(object):
    def __init__(self, **kwargs):

        # Predefine attributes with default values
        self.a = 0
        self.b = 0
        self.A = True
        self.B = True

        # get a list of all predefined values directly from __dict__
        allowed_keys = list(self.__dict__.keys())

        # Update __dict__ but only for keys that have been predefined 
        # (silently ignore others)
        self.__dict__.update((key, value) for key, value in kwargs.items() 
                             if key in allowed_keys)

        # To NOT silently ignore rejected keys
        rejected_keys = set(kwargs.keys()) - set(allowed_keys)
        if rejected_keys:
            raise ValueError("Invalid arguments in constructor:{}".format(rejected_keys))

Pas une avancée majeure, mais peut-être utile à quelqu'un ...

EDIT: Si notre classe utilise des @propertydécorateurs pour encapsuler des attributs "protégés" avec des getters et des setters, et si nous voulons pouvoir définir ces propriétés avec notre constructeur, nous pouvons vouloir étendre la allowed_keysliste avec les valeurs de dir(self), comme suit:

allowed_keys = [i for i in dir(self) if "__" not in i and any([j.endswith(i) for j in self.__dict__.keys()])]

Le code ci-dessus exclut

• toute variable masquée de dir()(exclusion basée sur la présence de "__"), et
• toute méthode dir()dont le nom n'est pas trouvé à la fin d'un nom d'attribut (protégé ou non) de __dict__.keys(), conservant ainsi probablement uniquement les méthodes décorées @property.

Cette modification n'est probablement valable que pour Python 3 et supérieur.

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

x = SymbolDict(foo=1, bar='3')
assert x.foo == 1

J'ai appelé la classe SymbolDictparce qu'il s'agit essentiellement d'un dictionnaire qui fonctionne en utilisant des symboles au lieu de chaînes. En d'autres termes, vous faites x.fooau lieu de x['foo']mais sous les couvertures, c'est vraiment la même chose qui se passe.

Les solutions suivantes vars(self).update(kwargs)ou self.__dict__.update(**kwargs)ne sont pas robustes, car l'utilisateur peut saisir n'importe quel dictionnaire sans message d'erreur. Si je dois vérifier que l'utilisateur insère la signature suivante («a1», «a2», «a3», «a4», «a5»), la solution ne fonctionne pas. De plus, l'utilisateur doit pouvoir utiliser l'objet en passant les "paramètres positionnels" ou les "paramètres de paires valeur kay".

Je suggère donc la solution suivante en utilisant une métaclasse.

from inspect import Parameter, Signature

class StructMeta(type):
    def __new__(cls, name, bases, dict):
        clsobj = super().__new__(cls, name, bases, dict)
        sig = cls.make_signature(clsobj._fields)
        setattr(clsobj, '__signature__', sig)
        return clsobj

def make_signature(names):
    return Signature(
        Parameter(v, Parameter.POSITIONAL_OR_KEYWORD) for v in names
    )

class Structure(metaclass = StructMeta):
    _fields = []
    def __init__(self, *args, **kwargs):
        bond = self.__signature__.bind(*args, **kwargs)
        for name, val in bond.arguments.items():
            setattr(self, name, val)

if __name__ == 'main':

   class A(Structure):
      _fields = ['a1', 'a2']

   if __name__ == '__main__':
      a = A(a1 = 1, a2 = 2)
      print(vars(a))

      a = A(**{a1: 1, a2: 2})
      print(vars(a))

Leur solution est peut-être meilleure, mais ce qui me vient à l'esprit est:

class Test:
    def __init__(self, *args, **kwargs):
        self.args=dict(**kwargs)

    def getkwargs(self):
        print(self.args)

t=Test(a=1, b=2, c="cats")
t.getkwargs()


python Test.py 
{'a': 1, 'c': 'cats', 'b': 2}

celui-ci est le plus simple via larsks

class Foo:
    def setAllWithKwArgs(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

mon exemple:

class Foo:
    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

door = Foo(size='180x70', color='red chestnut', material='oak')
print(door.size) #180x70

Je soupçonne qu'il pourrait être préférable dans la plupart des cas d'utiliser des arguments nommés (pour un meilleur code d'auto-documentation) afin que cela puisse ressembler à ceci:

class Foo:
    def setAll(a=None, b=None, c=None):
        for key, value in (a, b, c):
            if (value != None):
                settattr(self, key, value)