Modo corretto di usare ** kwargs in Python

Qual è il modo corretto di usare **kwargsin Python quando si tratta di valori predefiniti?

kwargsrestituisce un dizionario, ma qual è il modo migliore per impostare i valori predefiniti o ce n'è uno? Devo solo accedervi come dizionario? Utilizzare la funzione get?

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

Una domanda semplice, ma su cui non riesco a trovare buone risorse. Le persone lo fanno in modi diversi nel codice che ho visto ed è difficile sapere cosa usare.

È possibile passare un valore predefinito a get()per le chiavi che non sono nel dizionario:

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

Tuttavia, se prevedi di utilizzare un argomento specifico con un determinato valore predefinito, perché non utilizzare gli argomenti denominati in primo luogo?

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

Mentre la maggior parte delle risposte afferma che, ad esempio,

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

equivale a"

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

questo non è vero. In quest'ultimo caso, fpuò essere chiamato come f(23, 42), mentre il primo caso accetta solo argomenti con nome - nessuna chiamata posizionale. Spesso si desidera consentire al chiamante la massima flessibilità e quindi è preferibile il secondo modulo, come affermano la maggior parte delle risposte: ma non è sempre così. Quando si accettano molti parametri opzionali di cui in genere vengono passati solo alcuni, può essere un'ottima idea (evitare incidenti e codice illeggibile nei siti di chiamata!) Per forzare l'uso di argomenti denominati - ne threading.Threadè un esempio. Il primo modulo è il modo in cui lo implementi in Python 2.

Il linguaggio è così importante che in Python 3 ora ha una sintassi di supporto speciale: ogni argomento dopo un singolo *nella deffirma è solo parola chiave, cioè non può essere passato come argomento posizionale, ma solo come un nome. Quindi in Python 3 puoi scrivere quanto sopra come:

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

In effetti, in Python 3 puoi persino avere argomenti solo per parole chiave che non sono opzionali (quelli senza un valore predefinito).

Tuttavia, Python 2 ha ancora molti anni di vita produttiva, quindi è meglio non dimenticare le tecniche e gli idiomi che ti consentono di implementare in Python 2 importanti idee di design che sono direttamente supportate nel linguaggio in Python 3!

Suggerisco qualcosa del genere

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 poi usa i valori come preferisci

dictionaryA.update(dictionaryB)aggiunge il contenuto dictionaryBalla dictionaryAsovrascrittura di eventuali chiavi duplicate.

Faresti

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

o

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

Se lo usi pop, puoi verificare se ci sono valori spuri inviati e intraprendere l'azione appropriata (se presente).

L'uso di ** kwargs e dei valori predefiniti è semplice. A volte, tuttavia, non dovresti usare ** kwargs in primo luogo.

In questo caso, non stiamo davvero sfruttando al meglio ** kwargs.

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

Quanto sopra è un "perché preoccuparsi?" dichiarazione. È lo stesso di

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

Quando usi ** kwargs, intendi che una parola chiave non è solo facoltativa, ma condizionale. Esistono regole più complesse dei semplici valori predefiniti.

Quando usi ** kwargs, di solito intendi qualcosa di più simile al seguente, in cui non si applicano le impostazioni predefinite semplici.

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

Poiché **kwargsviene utilizzato quando il numero di argomenti è sconosciuto, perché non farlo?

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

Ecco un altro approccio:

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)

Penso che il modo corretto di utilizzare **kwargsin Python quando si tratta di valori predefiniti sia quello di utilizzare il metodo del dizionario setdefault, come indicato di seguito:

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

In questo modo, se un utente passa "val" o "val2" nella parola chiave args, verranno utilizzati; in caso contrario, verranno utilizzati i valori predefiniti impostati.

Potresti fare qualcosa del genere

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

Facendo seguito a @srhegde suggerimento di utilizzare 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]

Questa variante è utile quando si prevede che la classe abbia tutti gli elementi nel nostro acceptableelenco.

Se vuoi combinare questo con * args devi mantenere * args e ** kwargs alla fine della definizione.

Così:

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

@AbhinavGupta e @Steef hanno suggerito di utilizzare update(), che ho trovato molto utile per l'elaborazione di grandi elenchi di argomenti:

args.update(kwargs)

Cosa succede se vogliamo verificare che l'utente non abbia superato argomenti spuri / non supportati? @VinaySajip ha sottolineato che pop()può essere utilizzato per elaborare iterativamente l'elenco degli argomenti. Quindi, tutti gli argomenti rimanenti sono spuri. Bello.

Ecco un altro modo possibile per farlo, che mantiene la semplice sintassi dell'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_argsè un setcontenente i nomi degli argomenti che non si verificano nelle impostazioni predefinite.

Un'altra soluzione semplice per l'elaborazione di argomenti sconosciuti o multipli può essere:

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 offre la libertà di aggiungere qualsiasi numero di argomenti per parole chiave. Uno può avere un elenco di chiavi per le quali può impostare valori predefiniti. Ma l'impostazione di valori predefiniti per un numero indefinito di chiavi sembra superflua. Infine, potrebbe essere importante avere le chiavi come attributi di istanza. Quindi, farei questo come segue:

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)