Maneira correta de usar ** kwargs em Python

Qual é a maneira correta de usar **kwargsno Python quando se trata de valores padrão?

kwargsretorna um dicionário, mas qual é a melhor maneira de definir valores padrão ou existe um? Devo acessá-lo como um dicionário? Use a função get?

class ExampleClass:
    def __init__(self, **kwargs):
        self.val = kwargs['val']
        self.val2 = kwargs.get('val2')

Uma pergunta simples, mas na qual não consigo encontrar bons recursos. As pessoas fazem isso de maneiras diferentes no código que eu já vi e é difícil saber o que usar.

Você pode passar um valor padrão get()para chaves que não estão no dicionário:

self.val2 = kwargs.get('val2',"default value")

No entanto, se você planeja usar um argumento específico com um valor padrão específico, por que não usar argumentos nomeados em primeiro lugar?

def __init__(self, val2="default value", **kwargs):

Embora a maioria das respostas esteja dizendo que, por exemplo,

def f(**kwargs):
    foo = kwargs.pop('foo')
    bar = kwargs.pop('bar')
    ...etc...

é o mesmo que"

def f(foo=None, bar=None, **kwargs):
    ...etc...

isso não é verdade. No último caso, fpode ser chamado como f(23, 42), enquanto o primeiro caso aceita apenas argumentos nomeados - sem chamadas posicionais. Freqüentemente, você deseja permitir ao chamador a máxima flexibilidade e, portanto, a segunda forma, como a maioria das respostas afirma, é preferível: mas esse nem sempre é o caso. Quando você aceita muitos parâmetros opcionais dos quais normalmente apenas alguns são passados, pode ser uma excelente idéia (evitar acidentes e códigos ilegíveis nos sites de chamadas!) Forçar o uso de argumentos nomeados - threading.Threadé um exemplo. A primeira forma é como você implementa isso no Python 2.

O idioma é tão importante que, no Python 3, agora ele possui uma sintaxe de suporte especial: todos os argumentos após um único *na defassinatura são apenas de palavras-chave, ou seja, não podem ser passados ​​como argumentos posicionais, mas apenas como nomeados. Portanto, no Python 3, você pode codificar o código acima como:

def f(*, foo=None, bar=None, **kwargs):
    ...etc...

De fato, no Python 3 você pode até ter argumentos apenas de palavras-chave que não são opcionais (sem valor padrão).

No entanto, o Python 2 ainda tem longos anos de vida produtiva pela frente, por isso é melhor não esquecer as técnicas e expressões que permitem implementar no Python 2 importantes idéias de design que são diretamente suportadas na linguagem do Python 3!

Sugiro algo parecido com isto

def testFunc( **kwargs ):
    options = {
            'option1' : 'default_value1',
            'option2' : 'default_value2',
            'option3' : 'default_value3', }

    options.update(kwargs)
    print options

testFunc( option1='new_value1', option3='new_value3' )
# {'option2': 'default_value2', 'option3': 'new_value3', 'option1': 'new_value1'}

testFunc( option2='new_value2' )
# {'option1': 'default_value1', 'option3': 'default_value3', 'option2': 'new_value2'}

E então use os valores da maneira que quiser

dictionaryA.update(dictionaryB)adiciona o conteúdo dictionaryBda dictionaryAsubstituir quaisquer chaves duplicadas.

Você faria

self.attribute = kwargs.pop('name', default_value)

ou

self.attribute = kwargs.get('name', default_value)

Se você usar pop, poderá verificar se há algum valor falso enviado e tomar a ação apropriada (se houver).

Usar ** kwargs e valores padrão é fácil. Às vezes, no entanto, você não deve usar ** kwargs em primeiro lugar.

Nesse caso, não estamos realmente fazendo o melhor uso de ** kwargs.

class ExampleClass( object ):
    def __init__(self, **kwargs):
        self.val = kwargs.get('val',"default1")
        self.val2 = kwargs.get('val2',"default2")

O acima é um "por que se preocupar?" declaração. É o mesmo que

class ExampleClass( object ):
    def __init__(self, val="default1", val2="default2"):
        self.val = val
        self.val2 = val2

Quando você usa ** kwargs, significa que uma palavra-chave não é apenas opcional, mas condicional. Existem regras mais complexas do que valores padrão simples.

Quando você usa ** kwargs, geralmente significa algo mais como o seguinte, onde padrões simples não se aplicam.

class ExampleClass( object ):
    def __init__(self, **kwargs):
        self.val = "default1"
        self.val2 = "default2"
        if "val" in kwargs:
            self.val = kwargs["val"]
            self.val2 = 2*self.val
        elif "val2" in kwargs:
            self.val2 = kwargs["val2"]
            self.val = self.val2 / 2
        else:
            raise TypeError( "must provide val= or val2= parameter values" )

Como **kwargsé usado quando o número de argumentos é desconhecido, por que não fazer isso?

class Exampleclass(object):
  def __init__(self, **kwargs):
    for k in kwargs.keys():
       if k in [acceptable_keys_list]:
          self.__setattr__(k, kwargs[k])

Aqui está outra abordagem:

def my_func(arg1, arg2, arg3):
    ... so something ...

kwargs = {'arg1': 'Value One', 'arg2': 'Value Two', 'arg3': 'Value Three'}
# Now you can call the function with kwargs like this:

my_func(**kwargs)

Eu acho que a maneira correta de usar **kwargsem Python quando se trata de valores padrão é usar o método de dicionário setdefault, conforme indicado abaixo:

class ExampleClass:
    def __init__(self, **kwargs):
        kwargs.setdefault('val', value1)
        kwargs.setdefault('val2', value2)

Dessa forma, se um usuário passar 'val' ou 'val2' na palavra-chave args, eles serão usados; caso contrário, os valores padrão que foram definidos serão usados.

Você poderia fazer algo assim

class ExampleClass:
    def __init__(self, **kwargs):
        arguments = {'val':1, 'val2':2}
        arguments.update(kwargs)
        self.val = arguments['val']
        self.val2 = arguments['val2']

Dando seguimento a @srhegde sugestão de usar setattr :

class ExampleClass(object):
    __acceptable_keys_list = ['foo', 'bar']

    def __init__(self, **kwargs):
        [self.__setattr__(key, kwargs.get(key)) for key in self.__acceptable_keys_list]

Essa variante é útil quando se espera que a classe tenha todos os itens de nossa acceptablelista.

Se você quiser combinar isso com * args, precisará manter * args e ** kwargs no final da definição.

Assim:

def method(foo, bar=None, *args, **kwargs):
    do_something_with(foo, bar)
    some_other_function(*args, **kwargs)

@AbhinavGupta e @Steef sugeriram o uso update(), que achei muito útil para processar grandes listas de argumentos:

args.update(kwargs)

E se quisermos verificar se o usuário não passou nenhum argumento espúrio / sem suporte? O @VinaySajip apontou que pop()pode ser usado para processar iterativamente a lista de argumentos. Então, quaisquer argumentos restantes são espúrios. Agradável.

Aqui está outra maneira possível de fazer isso, que mantém a sintaxe simples de usar update():

# kwargs = dictionary of user-supplied arguments
# args = dictionary containing default arguments

# Check that user hasn't given spurious arguments
unknown_args = user_args.keys() - default_args.keys()
if unknown_args:
    raise TypeError('Unknown arguments: {}'.format(unknown_args))

# Update args to contain user-supplied arguments
args.update(kwargs)

unknown_argsé um setcontendo os nomes dos argumentos que não ocorrem nos padrões.

Outra solução simples para o processamento de argumentos desconhecidos ou múltiplos pode ser:

class ExampleClass(object):

    def __init__(self, x, y, **kwargs):
      self.x = x
      self.y = y
      self.attributes = kwargs

    def SomeFunction(self):
      if 'something' in self.attributes:
        dosomething()

** kwargs oferece a liberdade de adicionar qualquer número de argumentos de palavras-chave. Pode-se ter uma lista de chaves para as quais ele pode definir valores padrão. Mas definir valores padrão para um número indefinido de chaves parece desnecessário. Finalmente, pode ser importante ter as chaves como atributos da instância. Então, eu faria o seguinte:

class Person(object):
listed_keys = ['name', 'age']

def __init__(self, **kwargs):
    _dict = {}
    # Set default values for listed keys
    for item in self.listed_keys: 
        _dict[item] = 'default'
    # Update the dictionary with all kwargs
    _dict.update(kwargs)

    # Have the keys of kwargs as instance attributes
    self.__dict__.update(_dict)