Forma adecuada de usar ** kwargs en Python

¿Cuál es la forma correcta de usar **kwargsen Python cuando se trata de valores predeterminados?

kwargsdevuelve un diccionario, pero ¿cuál es la mejor manera de establecer valores predeterminados, o hay alguno? ¿Debo acceder a él como un diccionario? Utilice la función get?

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

Una pregunta simple, pero en la que no puedo encontrar buenos recursos. La gente lo hace de diferentes maneras en el código que he visto y es difícil saber qué usar.

Puede pasar un valor predeterminado a las get()claves que no están en el diccionario:

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

Sin embargo, si planea usar un argumento particular con un valor predeterminado particular, ¿por qué no usar argumentos nombrados en primer lugar?

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

Si bien la mayoría de las respuestas dicen eso, por ejemplo,

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

es lo mismo que"

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

esto no es verdad. En este último caso, fpuede ser llamado como f(23, 42), mientras que el primer caso acepta argumentos con nombre sólo - no hay llamadas posicionales. A menudo, desea permitir que la persona que llama tenga la máxima flexibilidad y, por lo tanto, es preferible la segunda forma, como afirman la mayoría de las respuestas: pero ese no es siempre el caso. Cuando acepta muchos parámetros opcionales, de los cuales generalmente solo se pasan unos pocos, puede ser una excelente idea (¡evitar accidentes y códigos ilegibles en sus sitios de llamadas!) Forzar el uso de argumentos con nombre, threading.Threades un ejemplo. La primera forma es cómo implementar eso en Python 2.

El idioma es tan importante que en Python 3 ahora tiene una sintaxis de soporte especial: cada argumento después de un solo *en la deffirma es solo de palabra clave, es decir, no se puede pasar como un argumento posicional, sino solo como uno con nombre. Entonces, en Python 3 podría codificar lo anterior como:

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

De hecho, en Python 3 incluso puede tener argumentos de solo palabras clave que no son opcionales (los que no tienen un valor predeterminado).

Sin embargo, Python 2 todavía tiene largos años de vida productiva por delante, por lo que es mejor no olvidar las técnicas y expresiones idiomáticas que le permiten implementar en Python 2 ideas de diseño importantes que se admiten directamente en el lenguaje de Python 3.

Sugiero algo como esto

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'}

Y luego usa los valores como quieras

dictionaryA.update(dictionaryB)agrega el contenido de dictionaryBa dictionaryAsobrescribir los duplicados de las llaves.

Tu harias

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

o

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

Si lo usa pop, puede verificar si hay valores falsos enviados y tomar las medidas apropiadas (si corresponde).

Usar ** kwargs y valores predeterminados es fácil. A veces, sin embargo, no deberías usar ** kwargs en primer lugar.

En este caso, realmente no estamos haciendo el mejor uso de ** kwargs.

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

Lo anterior es un "¿por qué molestarse?" declaración. Es lo mismo que

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

Cuando usa ** kwargs, quiere decir que una palabra clave no es solo opcional, sino condicional. Hay reglas más complejas que los valores predeterminados simples.

Cuando usa ** kwargs, generalmente quiere decir algo más parecido a lo siguiente, donde los valores predeterminados simples no se aplican.

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 **kwargsse usa cuando se desconoce el número de argumentos, ¿por qué no hacer esto?

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

Aquí hay otro enfoque:

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)

Creo que la forma correcta de usar **kwargsen Python cuando se trata de valores predeterminados es usar el método de diccionario setdefault, como se indica a continuación:

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

De esta manera, si un usuario pasa 'val' o 'val2' en la palabra clave args, se usarán; de lo contrario, se usarán los valores predeterminados que se hayan establecido.

Podrías hacer algo como esto

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

El seguimiento de @srhegde sugerencia de utilizar 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]

Esta variante es útil cuando se espera que la clase tenga todos los elementos de nuestra acceptablelista.

Si desea combinar esto con * args, debe mantener * args y ** kwargs al final de la definición.

Entonces:

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

@AbhinavGupta y @Steef sugirieron usar update(), lo que me pareció muy útil para procesar grandes listas de argumentos:

args.update(kwargs)

¿Qué sucede si queremos verificar que el usuario no haya pasado ningún argumento falso / no admitido? @VinaySajip señaló que pop()se puede usar para procesar iterativamente la lista de argumentos. Entonces, cualquier argumento sobrante es falso. Agradable.

Aquí hay otra forma posible de hacer esto, que mantiene la sintaxis simple de uso 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_argses un que setcontiene los nombres de los argumentos que no aparecen en los valores predeterminados.

Otra solución simple para procesar argumentos desconocidos o múltiples puede 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 le da la libertad de agregar cualquier número de argumentos de palabras clave. Uno puede tener una lista de claves para las cuales puede establecer valores predeterminados. Pero establecer valores predeterminados para un número indefinido de teclas parece innecesario. Finalmente, puede ser importante tener las claves como atributos de instancia. Entonces, haría esto de la siguiente manera:

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)