Como você pode definir atributos de classe a partir de argumentos variáveis ​​(kwargs) em python

Suponha que eu tenha uma classe com um construtor (ou outra função) que recebe um número variável de argumentos e os define como atributos de classe condicionalmente.

Eu poderia defini-los manualmente, mas parece que os parâmetros variáveis ​​são comuns o suficiente em python que deve haver um idioma comum para fazer isso. Mas não tenho certeza de como fazer isso dinamicamente.

Eu tenho um exemplo usando eval, mas dificilmente é seguro. Quero saber a maneira correta de fazer isso - talvez com 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])

Você pode atualizar o __dict__atributo (que representa os atributos da classe na forma de um dicionário) com os argumentos de palavra-chave:

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

então você pode:

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

e com algo como:

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

você pode filtrar as chaves de antemão (use em iteritemsvez de itemsse ainda estiver usando o Python 2.x).

Você pode usar o setattr()método:

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

Existe um getattr()método análogo para recuperar atributos.

A maioria das respostas aqui não cobre uma boa maneira de inicializar todos os atributos permitidos com apenas um valor padrão. Então, para adicionar às respostas dadas por @fqxp e @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)

Proponho uma variação da resposta de fqxp , que, além dos atributos permitidos , permite definir valores padrão para os atributos:

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)

Este é o código Python 3.x, para Python 2.x você precisa de pelo menos um ajuste, iteritems()no lugar de items().

Mais uma variante baseada nas excelentes respostas de mmj e fqxp . E se quisermos

1. Evite codificar uma lista de atributos permitidos
2. Defina direta e explicitamente os valores padrão para cada atributo no construtor
3. Restringir kwargs a atributos predefinidos por qualquer um
   • rejeitando silenciosamente argumentos inválidos ou , alternativamente,
   • levantando um erro.

Por "diretamente", quero dizer evitar um default_attributesdicionário estranho .

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

Não é um grande avanço, mas talvez útil para alguém ...

EDITAR: Se nossa classe usa @propertydecoradores para encapsular atributos "protegidos" com getters e setters, e se queremos ser capazes de definir essas propriedades com nosso construtor, podemos expandir a allowed_keyslista com valores de dir(self), como segue:

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

O código acima exclui

• qualquer variável oculta de dir() (exclusão com base na presença de "__"), e
• qualquer método dir()cujo nome não seja encontrado no final de um nome de atributo (protegido ou não) de __dict__.keys(), provavelmente mantendo apenas os métodos decorados com @property.

Esta edição provavelmente só é válida para Python 3 e superior.

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

Chamei a classe SymbolDictporque é essencialmente um dicionário que opera usando símbolos em vez de strings. Em outras palavras, você faz em x.foovez de, x['foo']mas por trás das cobertas, é realmente a mesma coisa acontecendo.

As seguintes soluções vars(self).update(kwargs)ouself.__dict__.update(**kwargs) não são robustas, pois o usuário pode entrar em qualquer dicionário sem mensagens de erro. Se eu precisar verificar se o usuário insere a seguinte assinatura ('a1', 'a2', 'a3', 'a4', 'a5') a solução não funciona. Além disso, o usuário deve ser capaz de usar o objeto passando os "parâmetros posicionais" ou os "parâmetros dos pares de valor kay".

Portanto, sugiro a seguinte solução usando uma metaclasse.

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

Pode ser uma solução melhor, mas o que me vem à mente é:

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}

este é o mais fácil via larsks

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

meu exemplo:

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

Suspeito que seja melhor na maioria dos casos usar args nomeados (para um melhor código de autodocumentação), então pode ser algo assim:

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